From 726d800676311ed162c548434961b05723d7a24d Mon Sep 17 00:00:00 2001 From: Mattrixwv Date: Sun, 4 Dec 2022 13:30:16 -0500 Subject: [PATCH] Added problems up to 50 --- .../project_euler/ProblemSelection.java | 14 +- .../project_euler/problems/Problem46.java | 122 ++++++++++++++ .../project_euler/problems/Problem47.java | 140 ++++++++++++++++ .../project_euler/problems/Problem48.java | 95 +++++++++++ .../project_euler/problems/Problem49.java | 158 ++++++++++++++++++ .../project_euler/problems/Problem50.java | 144 ++++++++++++++++ 6 files changed, 669 insertions(+), 4 deletions(-) create mode 100644 src/main/java/com/mattrixwv/project_euler/problems/Problem46.java create mode 100644 src/main/java/com/mattrixwv/project_euler/problems/Problem47.java create mode 100644 src/main/java/com/mattrixwv/project_euler/problems/Problem48.java create mode 100644 src/main/java/com/mattrixwv/project_euler/problems/Problem49.java create mode 100644 src/main/java/com/mattrixwv/project_euler/problems/Problem50.java diff --git a/src/main/java/com/mattrixwv/project_euler/ProblemSelection.java b/src/main/java/com/mattrixwv/project_euler/ProblemSelection.java index 6e473af..7e991ab 100644 --- a/src/main/java/com/mattrixwv/project_euler/ProblemSelection.java +++ b/src/main/java/com/mattrixwv/project_euler/ProblemSelection.java @@ -36,10 +36,11 @@ public class ProblemSelection{ private static final Scanner input = new Scanner(System.in); //Holds the valid problem numbers public static final List PROBLEM_NUMBERS = new ArrayList<>(Arrays.asList( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, - 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, - 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, - 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, - 41, 42, 43, 44, 45, 67)); + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, + 67)); //Returns the problem corresponding to the given problem number public static Problem getProblem(Integer problemNumber){ @@ -90,6 +91,11 @@ public class ProblemSelection{ case 43 : problem = new Problem43(); break; case 44 : problem = new Problem44(); break; case 45 : problem = new Problem45(); break; + case 46 : problem = new Problem46(); break; + case 47 : problem = new Problem47(); break; + case 48 : problem = new Problem48(); break; + case 49 : problem = new Problem49(); break; + case 50 : problem = new Problem50(); break; case 67 : problem = new Problem67(); break; } return problem; diff --git a/src/main/java/com/mattrixwv/project_euler/problems/Problem46.java b/src/main/java/com/mattrixwv/project_euler/problems/Problem46.java new file mode 100644 index 0000000..5670a79 --- /dev/null +++ b/src/main/java/com/mattrixwv/project_euler/problems/Problem46.java @@ -0,0 +1,122 @@ +//ProjectEulerJava/src/main/java/mattrixwv/project_euler/Problems/Problem46.java +//Mattrixwv +// Created: 08-22-22 +//Modified: 08-22-22 +//What is the smallest odd coposite number that cannot be written as the sum of a prime and twice a square? +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses +/* + Copyright (C) 2022 Matthew Ellison + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with this program. If not, see . +*/ +package com.mattrixwv.project_euler.problems; + + +import java.util.ArrayList; + +import com.mattrixwv.generators.SieveOfEratosthenes; + + +public class Problem46 extends Problem{ + //Variables + //Instance variables + private long num; + + //Functions + //Constructor + public Problem46(){ + super("What is the smallest odd composite number that connot be written as the sum of a prime and twice a square?"); + num = 0; + } + //Operational functions + //Solve the problem + public void solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + + //Start the timer + timer.start(); + + + //Setup a prime sieve + SieveOfEratosthenes sieve = new SieveOfEratosthenes(); + ArrayList primes = new ArrayList<>(); + primes.add(sieve.next()); + //Run until we find a composite number + for(int currentOdd = 3;num == 0;currentOdd += 2){ + boolean foundEquation = false; + //Add elements to the prime array until you reach a number greater than the current number to test + while(primes.get(primes.size() - 1) < currentOdd){ + primes.add(sieve.next()); + } + //Make sure the number isn't prime + if(primes.get(primes.size() - 1) == currentOdd){ + continue; + } + //Check if the number can be calculated with the formula + //Start with the smallest prime and work your way up + for(long prime : primes){ + //Start with 1 and work your way up until the number becomes too large + boolean tooLarge = false; + for(int cnt = 1;(!tooLarge) && (!foundEquation);++cnt){ + //Find the value of the equation for these numbers + long equation = prime + (2 * cnt * cnt); + //If the number is too large break the loop + if(equation > currentOdd){ + tooLarge = true; + } + //If the number == equation set a flag to break the loops + else if(equation == currentOdd){ + foundEquation = true; + } + } + } + if(!foundEquation){ + num = currentOdd; + } + } + + + //Stop the timer + timer.stop(); + + //Set a flag to show the problem is solved + solved = true; + } + //Reset the problem so it can be run again + @Override + public void reset(){ + super.reset(); + num = 0; + } + + //Gets + //Returns a string with the solution to the problem + public String getResult(){ + solvedCheck("results"); + return String.format("The smallest odd composite that cannot be written as the sum of a prime and twice a square is %d", num); + } + //Returns the number + public long getCompositeNum(){ + solvedCheck("composite number"); + return num; + } +} + +/* Results: +The smallest odd composite that cannot be written as the sum of a prime and twice a square is 5777 +It took an average of 5.603 milliseconds to run this problem through 100 iterations +*/ diff --git a/src/main/java/com/mattrixwv/project_euler/problems/Problem47.java b/src/main/java/com/mattrixwv/project_euler/problems/Problem47.java new file mode 100644 index 0000000..3d3c280 --- /dev/null +++ b/src/main/java/com/mattrixwv/project_euler/problems/Problem47.java @@ -0,0 +1,140 @@ +//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem47.java +//Mattrixwv +// Created: 08-22-22 +//Modified: 08-22-22 +//What is the first of four consecutive integers to have four distinct prime factors each? +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses +/* + Copyright (C) 2022 Matthew Ellison + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with this program. If not, see . +*/ +package com.mattrixwv.project_euler.problems; + + +import java.util.HashMap; +import java.util.List; + +import com.mattrixwv.NumberAlgorithms; + + +public class Problem47 extends Problem{ + //Variables + //Instance variables + private long num; //The first of the consecutive numbers + + //Function + //Constructor + public Problem47(){ + super("What is the first of four consecutive integers to have four distinct prime factors each?"); + num = 0; + } + //Operational functions + //Solve the problem + public void solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + + //Start the timer + timer.start(); + + + //Go through every number + HashMap> factors = new HashMap<>(); + factors.put(1L, NumberAlgorithms.getFactors(1L)); + factors.put(2L, NumberAlgorithms.getFactors(2L)); + factors.put(3L, NumberAlgorithms.getFactors(3L)); + for(long cnt = 1;num == 0;++cnt){ + boolean found = false; + //Get the next set of factors + factors.put(cnt + 3, NumberAlgorithms.getFactors(cnt + 3)); + + //Make maps of the factors and their powers + HashMap factors0 = new HashMap<>(); + for(Long factor : factors.get(cnt)){ + factors0.merge(factor, 1L, Long::sum); + } + HashMap factors1 = new HashMap<>(); + for(Long factor : factors.get(cnt + 1)){ + factors1.merge(factor, 1L, Long::sum); + } + HashMap factors2 = new HashMap<>(); + for(Long factor : factors.get(cnt + 2)){ + factors2.merge(factor, 1L, Long::sum); + } + HashMap factors3 = new HashMap<>(); + for(Long factor : factors.get(cnt + 3)){ + factors3.merge(factor, 1L, Long::sum); + } + + //Make sure all of the maps have the correct number of elements + if((factors0.keySet().size() != 4) || (factors1.keySet().size() != 4) || (factors2.keySet().size() != 4) || (factors3.keySet().size() != 4)){ + continue; + } + + //Make sure none of the elements match + for(Long key : factors0.keySet()){ + if(factors0.get(key).equals(factors1.get(key)) || factors0.get(key).equals(factors1.get(key)) || factors0.get(key).equals(factors3.get(key))){ + found = true; + } + } + for(Long key : factors1.keySet()){ + if(factors1.get(key).equals(factors2.get(key)) || factors1.get(key).equals(factors2.get(key))){ + found = true; + } + } + for(Long key : factors2.keySet()){ + if(factors2.get(key).equals(factors3.get(key))){ + found = true; + } + } + + if(!found){ + num = cnt; + } + } + + + //Stop the timer + timer.stop(); + + //Set a flag to show the problem is solved + solved = true; + } + //Reset the problem so it can be run again + @Override + public void reset(){ + super.reset(); + num = 0; + } + + //Gets + //Returns a string with the solution to the problem + public String getResult(){ + solvedCheck("results"); + return String.format("The first number is %d", num); + } + //Returns the number + public long getFirstNum(){ + solvedCheck("first number"); + return num; + } +} + +/* Results +The first number is 134043 +It took 50.878 seconds to solve this problem. +*/ diff --git a/src/main/java/com/mattrixwv/project_euler/problems/Problem48.java b/src/main/java/com/mattrixwv/project_euler/problems/Problem48.java new file mode 100644 index 0000000..cda45f7 --- /dev/null +++ b/src/main/java/com/mattrixwv/project_euler/problems/Problem48.java @@ -0,0 +1,95 @@ +//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem48.java +//Mattrixwv +// Created: 08-23-22 +//Modified: 08-23-22 +//Find the last ten digits of the series 1^1 + 2^2 + 3^3 + ... + 1000^1000 +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses +/* + Copyright (C) 2022 Matthew Ellison + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with this program. If not, see . +*/ +package com.mattrixwv.project_euler.problems; + + +import java.math.BigInteger; + + +public class Problem48 extends Problem{ + //Variables + //Static variables + private static final BigInteger TOP_NUM = BigInteger.valueOf(1000); + //Instance variables + private BigInteger sum; + + //Functions + //Constructor + public Problem48(){ + super("Find the last ten digits of the series Σn^n for 1<=n<=1000"); + sum = BigInteger.ZERO; + } + //Operational functions + //Solve the problem + public void solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + + //Start the timer + timer.start(); + + + //Start with 1 and execute the formula for each number + for(BigInteger cnt = BigInteger.ONE;cnt.compareTo(TOP_NUM) <= 0;cnt = cnt.add(BigInteger.ONE)){ + sum = sum.add(cnt.pow(cnt.intValue())); + } + + + //Stop the timer + timer.stop(); + + //Set a flag to show the problem is solved + solved = true; + } + //Reset the rpobelm so it can be run again + @Override + public void reset(){ + super.reset(); + sum = BigInteger.ZERO; + } + + //Gets + //Returns a string with the solution to the problem + public String getResult(){ + solvedCheck("results"); + return String.format("The last ten digits of the series Σn^n for 1<=n<=1000 is %s", getSumDigits()); + } + //Returns the sum of the series + public BigInteger getSum(){ + solvedCheck("sum"); + return sum; + } + //Returns the last 10 digits of the sum + public String getSumDigits(){ + solvedCheck("last 10 digits of the sum"); + String sumString = sum.toString(); + return sumString.substring(sumString.length() - 10); + } +} + +/* Results +The last ten digits of the series Σn^n for 1<=n<=1000 is 9110846700 +It took an average of 3.831 milliseconds to run this problem through 100 iterations +*/ diff --git a/src/main/java/com/mattrixwv/project_euler/problems/Problem49.java b/src/main/java/com/mattrixwv/project_euler/problems/Problem49.java new file mode 100644 index 0000000..abf448f --- /dev/null +++ b/src/main/java/com/mattrixwv/project_euler/problems/Problem49.java @@ -0,0 +1,158 @@ +//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem49.java +//Mattrixwv +// Created: 08-23-22 +//Modified: 08-23-22 +//What is the 12-digit number formed by concatenating the three terms in the sequence? +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses +/* + Copyright (C) 2022 Matthew Ellison + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with this program. If not, see . +*/ +package com.mattrixwv.project_euler.problems; + + +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashSet; +import java.util.List; + +import com.mattrixwv.NumberAlgorithms; +import com.mattrixwv.StringAlgorithms; + + +public class Problem49 extends Problem{ + //Variables + //Static variables + private static final int MIN_NUMBER = 1000; + private static final int MAX_NUMBER = 9999; + //Instance variables + private String concatenationOfNumbers; + + //Functions + //Constructor + public Problem49(){ + super("What is the 12-digit number formed by concatenating the three terms in the sequence?"); + concatenationOfNumbers = ""; + } + //Operational functions + //Solve the problem + public void solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + + //Start the timer + timer.start(); + + + //Get all of the prime numbers <= MAX_NUMBER + List primes = NumberAlgorithms.getPrimes(MAX_NUMBER); + //Loop through every prime from min to max and check if its permutations match the sequence + for(Integer prime : primes){ + //Skip all primes < MIN + if(prime < MIN_NUMBER){ + continue; + } + //Get all permutations of the number + List primeStrsRaw = StringAlgorithms.getPermutations(prime.toString()); + HashSet primeStrs = new HashSet<>(); + for(String str : primeStrsRaw){ + primeStrs.add(str); + } + //Skip the provided example + if(primeStrs.contains("1487")){ + continue; + } + //Remove any even numbers and numbers smaller than the current number + ArrayList remaining = new ArrayList<>(); + for(String primeStr : primeStrs){ + Integer num = Integer.valueOf(primeStr); + if(((num % 2) != 0) && (num >= prime)){ + remaining.add(num); + } + } + //Check if there are at least 3 elements remaining + ArrayList matches = new ArrayList<>(); + if(remaining.size() >= 3){ + //Check if 3 elements are prime + for(Integer num : remaining){ + if(NumberAlgorithms.isPrime(num)){ + matches.add(num); + } + } + } + Collections.sort(matches); + //If there are at least 3 matches see if there are any that are equidistant + if(matches.size() >= 3){ + HashSet distances = new HashSet<>(); + for(int cnt1 = 0;cnt1 < matches.size();++cnt1){ + for(int cnt2 = cnt1 + 1;cnt2 < matches.size();++cnt2){ + int num = matches.get(cnt2) - matches.get(cnt1); + if((MIN_NUMBER + num + num) <= MAX_NUMBER){ + distances.add(num); + } + } + } + for(Integer distance : distances){ + for(Integer match : matches){ + if(matches.contains(match + distance) && (matches.contains(match + distance + distance))){ + concatenationOfNumbers = match.toString() + Integer.toString(match + distance) + Integer.toString(match + distance + distance); + } + if(!concatenationOfNumbers.isBlank()){ + break; + } + } + if(!concatenationOfNumbers.isBlank()){ + break; + } + } + } + if(!concatenationOfNumbers.isBlank()){ + break; + } + } + + + //Stop the timer + timer.stop(); + + //Set a flag to show the problem is solved + solved = true; + } + //Reset the problem so it can be run again + @Override + public void reset(){ + super.reset(); + concatenationOfNumbers = ""; + } + + //Gets + //Returns a string with the solution to the problem + public String getResult(){ + solvedCheck("results"); + return String.format("The 12-digit number formed by concatenation the three terms in the sequence is %s", concatenationOfNumbers); + } + //Returns the concatenation of numbers + public String getConcatNums(){ + solvedCheck("concatenation of numbers"); + return concatenationOfNumbers; + } +} + +/* Results: +The 12-digit number formed by concatenation the three terms in the sequence is 296962999629 +It took an average of 4.261 milliseconds to run this problem through 100 iterations +*/ diff --git a/src/main/java/com/mattrixwv/project_euler/problems/Problem50.java b/src/main/java/com/mattrixwv/project_euler/problems/Problem50.java new file mode 100644 index 0000000..0218e22 --- /dev/null +++ b/src/main/java/com/mattrixwv/project_euler/problems/Problem50.java @@ -0,0 +1,144 @@ +//ProjectEulerJava/src/main/java/com/mattrixwv/project_euler/problems/Problem50.java +//Mattrixwv +// Created: 08-23-22 +//Modified: 08-23-22 +//Which prime, below one-million, can be written as the sum of the most consecutive primes? +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses +/* + Copyright (C) 2022 Matthew Ellison + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with this program. If not, see . +*/ +package com.mattrixwv.project_euler.problems; + + +import java.util.ArrayList; +import java.util.List; + +import com.mattrixwv.ArrayAlgorithms; +import com.mattrixwv.NumberAlgorithms; + + +public class Problem50 extends Problem{ + //Variables + //Static variables + private static final long MAX = 999999; + //Instance variables + private ArrayList consecutivePrimes; + + //Functions + //Constructor + public Problem50(){ + super("Which prime, below one-million, can be written as the sum of the most consecutive primes?"); + consecutivePrimes = new ArrayList<>(); + } + //Operational functions + //Solve the problem + public void solve(){ + //If the porblem has already been solved do nothing and end the function + if(solved){ + return; + } + + //Start the timer + timer.start(); + + + //Get all primes < MAX + List primes = NumberAlgorithms.getPrimes(MAX); + //Check every length of consecutive primes for a prime sum. Stop when the length becomes too long + boolean tooLong = false; + for(long length = 1;!tooLong;++length){ + //If the length is even you only need to check offset 0 because of 2 + if((length % 2) == 0){ + long sum = 0; + //Get the sum of consecutive primes + for(int cnt = 0;cnt < length;++cnt){ + sum += primes.get(cnt); + } + //If the new sum is prime save it + if(primes.contains(sum)){ + consecutivePrimes = new ArrayList<>(); + for(int cnt = 0;cnt < length;++cnt){ + consecutivePrimes.add(primes.get(cnt)); + } + } + } + //If the length is odd you need to check every offset until the sum becomes too large + else{ + //Set the offset (always skipping 2 because this is an odd length sum) + for(int start = 1;(start + length) < primes.size();++start){ + long sum = 0; + //Get the sum of consecutive primes + for(int cnt = 0;cnt < length;++cnt){ + sum += primes.get(start + cnt); + } + //If the sum is too large the offset has gotten too high, so break the loop + if(sum > MAX){ + //If the offset is minimum break the length loop because all subsequent sums will be too large + if(start == 1){ + tooLong = true; + } + break; + } + //If the new sum is prime save it + else if(primes.contains(sum)){ + consecutivePrimes = new ArrayList<>(); + for(int cnt = 0;cnt < length;++cnt){ + consecutivePrimes.add(primes.get(start + cnt)); + } + break; + } + } + } + } + + + //Stop the timer + timer.stop(); + + //Set a flag to show the problem is solved + solved = true; + } + //Reset the problem so it can be run again + @Override + public void reset(){ + super.reset(); + consecutivePrimes = new ArrayList<>(); + } + + //Gets + //Returns a string with the solution to the problem + public String getResult(){ + solvedCheck("results"); + return String.format("The prime below one-million that can be written as the sum of the most consecutive primes is %d", ArrayAlgorithms.getLongSum(consecutivePrimes)); + } + //Returns the list of consecutive primes + public ArrayList getConsecutivePrimes(){ + solvedCheck("list of consecutive primes"); + @SuppressWarnings("unchecked") + ArrayList clone = (ArrayList)consecutivePrimes.clone(); + return clone; + } + //Returns the sum of the primes + public long getPrime(){ + solvedCheck("prime"); + return ArrayAlgorithms.getLongSum(consecutivePrimes); + } +} + +/* Results: +The prime below one-million that can be written as the sum of the most consecutive primes is 997651 +It took an average of 77.425 milliseconds to run this problem through 100 iterations +*/