ProjectEuler/ProjectEulerJava
1
0
Fork 0
mirror of https://bitbucket.org/Mattrixwv/projecteulerjava.git synced 2025-12-06 17:13:58 -05:00
Code Issues Packages Projects Releases Wiki Activity

Fixed sonarqube problems

Browse Source
This commit is contained in:
Mattrixwv
2022-08-20 14:30:43 -04:00
parent a82e18e7c7
commit 51447fcbb2
45 changed files with 250 additions and 239 deletions
Download Patch File Download Diff File Expand all files Collapse all files

194
src/main/java/com/mattrixwv/project_euler/Benchmark.java Normal file
View File

@@ -0,0 +1,194 @@
//ProjectEuler/ProjectEulerJava/src/man/java/mattrixwv/ProjectEuler/Benchmark.java
//Matthew Ellison
// Created: 07-08-20
//Modified: 07-09-20
//This runs the benchmark functions for the Java version of the ProjectEuler project
/*
Copyright (C) 2020 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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
import com.mattrixwv.Stopwatch;
import com.mattrixwv.exceptions.InvalidResult;
import com.mattrixwv.project_euler.problems.Problem;
public class Benchmark{
private Benchmark(){}
private static final Scanner input = new Scanner(System.in);
private enum BenchmarkOptions{RUN_SPECIFIC, RUN_ALL_SHORT, RUN_ALL, EXIT, SIZE};
private static final ArrayList<Integer> tooLong = new ArrayList<>(Arrays.asList(15, 23, 24, 35));
//The driver function for the benchmark selection
public static void benchmarkMenu() throws InvalidResult{
BenchmarkOptions selection;
printMenu();
selection = getMenuSelection();
switch(selection){
case RUN_SPECIFIC : runSpecific(); break;
case RUN_ALL_SHORT : runAllShort(); break;
case RUN_ALL : runAll(); break;
case EXIT : break;
case SIZE : break;
}
}
//Print the benchmark menu
private static void printMenu(){
System.out.println("1. Run a specific problem");
System.out.println("2. Run all problems that have a reasonably short run time");
System.out.println("3. Run all problems");
System.out.println("4. Exit the menu");
System.out.println();
}
//Returns a valid menu option
private static BenchmarkOptions getMenuSelection(){
int selection = input.nextInt();
while(!isValidMenu(selection)){
System.out.println("That is an invalid option!\nPress Enter to continue");
printMenu();
selection = input.nextInt();
}
return getSelection(selection);
}
//Determines if a value is a valid menu option. Helper for getBechmarkMenuSelection
private static boolean isValidMenu(int selection){
//Ordinal + 1 because enum starts at 0
if((selection > 0) && (selection < (BenchmarkOptions.SIZE.ordinal() + 1))){
return true;
}
else{
return false;
}
}
//A helper function for getMenuSelection that turns an integer to a BenchmarkOptions
private static BenchmarkOptions getSelection(Integer selection){
BenchmarkOptions sel = null;
switch(selection){
case 1 : sel = BenchmarkOptions.RUN_SPECIFIC; break;
case 2 : sel = BenchmarkOptions.RUN_ALL_SHORT; break;
case 3 : sel = BenchmarkOptions.RUN_ALL; break;
case 4 : sel = BenchmarkOptions.EXIT; break;
default : sel = BenchmarkOptions.SIZE;
}
return sel;
}
//Determines which problem user wants to run and runs it
private static void runSpecific() throws InvalidResult{
//Ask which problem the user wants to run
int problemNumber = ProblemSelection.getProblemNumber();
//Ask how many times to run the problem
int timesToRun = getNumberOfTimesToRun();
//Get the problem and print its description
Problem problem = ProblemSelection.getProblem(problemNumber);
System.out.println(problemNumber + ". " + problem.getDescription());
//Run the problem the specific number of times
double totalTime = runProblem(problem, timesToRun);
//Print the results
System.out.println(getBenchmarkResults(problem, totalTime, timesToRun));
}
//Runs all problems except a few that are specified because of run length
private static void runAllShort() throws InvalidResult{
//Ask how many times to run the problems
int timesToRun = getNumberOfTimesToRun();
//Run through all valid problem numbers, skipping a few that are in the tooLong list
for(int cnt = 1;cnt < ProblemSelection.PROBLEM_NUMBERS.size();++cnt){
int problemNumber = ProblemSelection.PROBLEM_NUMBERS.get(cnt);
//If the problem number is contained in the list of problems that take too long skip it
if(tooLong.contains(problemNumber)){
continue;
}
//Get the problem and print its description
Problem problem = ProblemSelection.getProblem(problemNumber);
System.out.println(problemNumber + ". " + problem.getDescription());
//Run each problem the specified number of times
double totalTime = runProblem(problem, timesToRun);
//Print the results
System.out.println(getBenchmarkResults(problem, totalTime, timesToRun));
}
}
//Runs all problems
private static void runAll() throws InvalidResult{
//Ask how many times to run the problem
int timesToRun = getNumberOfTimesToRun();
//Run through all valid problem numbers, skipping a few that are in the tooLong list
for(int cnt = 1;cnt < ProblemSelection.PROBLEM_NUMBERS.size();++cnt){
int problemNumber = ProblemSelection.PROBLEM_NUMBERS.get(cnt);
//Get the problem
Problem problem = ProblemSelection.getProblem(problemNumber);
//Run each problem the specified number of times
System.out.println(problemNumber + ". " + problem.getDescription());
double totalTime = runProblem(problem, timesToRun);
//Print the results
System.out.println(getBenchmarkResults(problem, totalTime, timesToRun));
}
}
//Asks how many times a problem is supposed to run and returns the value
private static int getNumberOfTimesToRun(){
int numOfTimesToRun = 1;
System.out.print("How many times do you want to run this problem? ");
numOfTimesToRun = input.nextInt();
while(numOfTimesToRun < 1){
System.out.println("That is an invalid number!");
System.out.print("How many times do you want to run this problem? ");
numOfTimesToRun = input.nextInt();
}
return numOfTimesToRun;
}
//Runs the problem the given number of times
private static double runProblem(Problem problem, int timesToRun) throws InvalidResult{
double totalTime = 0;
System.out.print("Solving");
for(int cnt = 0;cnt < timesToRun;++cnt){
System.out.print('.');
//Reset the data so you are actually counting the run time an additional time
problem.reset();
//Solve the problem
problem.solve();
//Get the time data
totalTime += problem.getTimer().getNano();
}
return totalTime;
}
//Prints the benchmark results of a problem
private static String getBenchmarkResults(Problem problem, double totalTime, int timesRun) throws InvalidResult{
//Calculate the average run time of the problem
totalTime /= timesRun;
String timeResults = Stopwatch.getStr(totalTime);
//Tally the results
return "%n%n" + problem.getResult() + "%nIt took an average of " + timeResults + " to run this problem through " + timesRun + " iterations%n%n";
}
}

137
src/main/java/com/mattrixwv/project_euler/Driver.java Normal file
View File

@@ -0,0 +1,137 @@
//ProjectEuler/ProjectEulerJava/src/man/java/mattrixwv/ProjectEuler/Driver.java
//Matthew Ellison
// Created: 06-07-20
//Modified: 07-09-20
//This is the driver function for the Java version of the ProjectEuler project
/*
Copyright (C) 2020 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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler;
import java.util.Scanner;
import com.mattrixwv.exceptions.InvalidResult;
public class Driver{
//An enum to hold the possible menu selections
private enum SELECTIONS{SOLVE, DESCRIPTION, LIST, BENCHMARK, EXIT, SIZE};
private static final Scanner input = new Scanner(System.in);
//Drives the program
public static void main(String[] args) throws InvalidResult{
SELECTIONS selection; //Holds the menu selection of the user
do{
//Print the menu and prompt the user to select an action
printMenu();
selection = getMenuSelection();
switch(selection){
case SOLVE : solveMenu(); break;
case DESCRIPTION : descriptionMenu(); break;
case LIST : ProblemSelection.listProblems(); break;
case BENCHMARK : Benchmark.benchmarkMenu(); break;
case EXIT : break;
case SIZE :
default : printErrorMessage();
}
}while(!selection.equals(SELECTIONS.EXIT));
}
//Print the menu
private static void printMenu(){
System.out.println("1. Solve a problem");
System.out.println("2. Print a problem description");
System.out.println("3. List valid problem numbers");
System.out.println("4. Benchmark");
System.out.println("5. Exit");
System.out.println();
}
//Get a menu selection from the user
private static SELECTIONS getMenuSelection(){
Integer selection = input.nextInt();
while(!isValidMenu(selection)){
System.out.println("That is an invalid option!\nPress Enter to continue");
printMenu();
selection = input.nextInt();
}
return getSelection(selection);
}
//Make sure the value passed in is a valid menu option
private static boolean isValidMenu(Integer selection){
//Ordinal + 1 because enum starts at 0
return ((selection > 0) && (selection < (SELECTIONS.SIZE.ordinal() + 1)));
}
//Turns an integer passed to it into a SELECTION enum
private static SELECTIONS getSelection(Integer selection){
SELECTIONS sel = null;
switch(selection){
case 1 : sel = SELECTIONS.SOLVE; break;
case 2 : sel = SELECTIONS.DESCRIPTION; break;
case 3 : sel = SELECTIONS.LIST; break;
case 4 : sel = SELECTIONS.BENCHMARK; break;
case 5 : sel = SELECTIONS.EXIT; break;
default : sel = SELECTIONS.SIZE;
}
return sel;
}
//Print an error message
private static void printErrorMessage(){
System.out.println("That is an invalid selection!");
}
//Handle what happens when a user wants to solve a problem
private static void solveMenu() throws InvalidResult{
Integer problemNumber = ProblemSelection.getProblemNumber();
//This selection solves all problems in order
if(problemNumber.equals(0)){
//Solve to every valid problem number, skipping over 0
for(Integer problemLocation = 1;problemLocation < ProblemSelection.PROBLEM_NUMBERS.size();++problemLocation){
//Solve the problems
System.out.print(ProblemSelection.PROBLEM_NUMBERS.get(problemLocation).toString() + ". ");
ProblemSelection.solveProblem(ProblemSelection.PROBLEM_NUMBERS.get(problemLocation));
}
}
//This is if a single problem number was chosen
else{
//Solve the problem
ProblemSelection.solveProblem(problemNumber);
}
}
//Handle what happens when a user wants to see the description of a problem
private static void descriptionMenu(){
//Give some extra space to print the description
System.out.println("\n");
//Get the problem number
Integer problemNumber = ProblemSelection.getProblemNumber();
//If the problem number is 0 print out all the descriptions
if(problemNumber.equals(0)){
//Print description for every valid problem number, skipping over 0
for(Integer problemLocation = 1;problemLocation < ProblemSelection.PROBLEM_NUMBERS.size();++problemLocation){
//Print the problem's description
System.out.print(ProblemSelection.PROBLEM_NUMBERS.get(problemLocation) + ". ");
ProblemSelection.printDescription(ProblemSelection.PROBLEM_NUMBERS.get(problemLocation));
System.out.println();
}
}
//Otherwise print out a single problem's description
else{
ProblemSelection.printDescription(problemNumber);
}
}
}

126
src/main/java/com/mattrixwv/project_euler/ProblemSelection.java Normal file
View File

@@ -0,0 +1,126 @@
//ProjectEuler/ProjectEulerJava/src/man/java/mattrixwv/ProjectEuler/ProblemSelection.java
//Matthew Ellison
// Created: 07-08-20
//Modified: 07-09-20
//This class holds all of the functions needed to handle a problem
/*
Copyright (C) 2020 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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
import com.mattrixwv.exceptions.InvalidResult;
import com.mattrixwv.project_euler.problems.*;
public class ProblemSelection{
private static final Scanner input = new Scanner(System.in);
//Holds the valid problem numbers
public static final List<Integer> 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, 67));
//Returns the problem corresponding to the given problem number
public static Problem getProblem(Integer problemNumber){
Problem problem = null;
switch(problemNumber){
case 1 : problem = new Problem1(); break;
case 2 : problem = new Problem2(); break;
case 3 : problem = new Problem3(); break;
case 4 : problem = new Problem4(); break;
case 5 : problem = new Problem5(); break;
case 6 : problem = new Problem6(); break;
case 7 : problem = new Problem7(); break;
case 8 : problem = new Problem8(); break;
case 9 : problem = new Problem9(); break;
case 10 : problem = new Problem10(); break;
case 11 : problem = new Problem11(); break;
case 12 : problem = new Problem12(); break;
case 13 : problem = new Problem13(); break;
case 14 : problem = new Problem14(); break;
case 15 : problem = new Problem15(); break;
case 16 : problem = new Problem16(); break;
case 17 : problem = new Problem17(); break;
case 18 : problem = new Problem18(); break;
case 19 : problem = new Problem19(); break;
case 20 : problem = new Problem20(); break;
case 21 : problem = new Problem21(); break;
case 22 : problem = new Problem22(); break;
case 23 : problem = new Problem23(); break;
case 24 : problem = new Problem24(); break;
case 25 : problem = new Problem25(); break;
case 26 : problem = new Problem26(); break;
case 27 : problem = new Problem27(); break;
case 28 : problem = new Problem28(); break;
case 29 : problem = new Problem29(); break;
case 30 : problem = new Problem30(); break;
case 31 : problem = new Problem31(); break;
case 32 : problem = new Problem32(); break;
case 33 : problem = new Problem33(); break;
case 34 : problem = new Problem34(); break;
case 35 : problem = new Problem35(); break;
case 36 : problem = new Problem36(); break;
case 37 : problem = new Problem37(); break;
case 38 : problem = new Problem38(); break;
case 67 : problem = new Problem67(); break;
}
return problem;
}
//Print the description of a problem
public static void printDescription(Integer problemNumber){
//Get the problem
Problem problem = getProblem(problemNumber);
//Print the problem's description
System.out.println(problem.getDescription());
}
//Solve a problem
public static void solveProblem(Integer problemNumber) throws InvalidResult{
//Get the problem
Problem problem = getProblem(problemNumber);
//Print the problem description
System.out.println(problem.getDescription());
//Solve the problem
problem.solve();
//Print the results
System.out.println(problem.getResult() + "\nIt took " + problem.getTime() + " to solve this problem.\n\n");
}
//Get a valid problem number from a user
public static Integer getProblemNumber(){
Integer problemNumber = 0;
System.out.print("Enter a problem number: ");
problemNumber = input.nextInt();
while(!PROBLEM_NUMBERS.contains(problemNumber)){
System.out.print("That is an invalid problem number!\nEnter a problem number: ");
problemNumber = input.nextInt();
}
return problemNumber;
}
//List all valid problem numbers
public static void listProblems(){
System.out.print(PROBLEM_NUMBERS.get(1));
for(Integer problemNumber = 2;problemNumber < PROBLEM_NUMBERS.size();++problemNumber){
System.out.print(", " + PROBLEM_NUMBERS.get(problemNumber).toString());
}
System.out.println();
}
}

34
src/main/java/com/mattrixwv/project_euler/Unsolved.java Normal file
View File

@@ -0,0 +1,34 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Unsolved.java
//Matthew Ellison
// Created: 07-17-20
//Modified: 07-17-20
//This is an exception that is thrown by the problem classes
/*
Copyright (C) 2020 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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler;
public class Unsolved extends RuntimeException{
private static final long serialVersionUID = 1L;
public Unsolved(){
super();
}
public Unsolved(String exceptionString){
super(exceptionString);
}
}

77
src/main/java/com/mattrixwv/project_euler/problems/Problem.java Normal file
View File

@@ -0,0 +1,77 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem.java
//Matthew Ellison
// Created: 03-01-19
//Modified: 08-20-22
//This is a base class for problems to use as a template
/*
Copyright (C) 2021 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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import com.mattrixwv.Stopwatch;
import com.mattrixwv.exceptions.InvalidResult;
import com.mattrixwv.project_euler.Unsolved;
public abstract class Problem{
//Variables
//Instance variables
protected final Stopwatch timer = new Stopwatch(); //To time how long it takes to run the algorithm
private final String description; //Holds the description of the problem
protected boolean solved; //Shows whether the problem has already been solved
//Constructor
protected Problem(String description){
this.description = description;
solved = false;
}
//Gets
//Returns the description of the problem
public String getDescription(){
return description;
}
//Returns the result of solving the problem
public abstract String getResult();
//Returns the time taken to run the problem as a string
public String getTime() throws InvalidResult, Unsolved{
if(!solved){
throw new Unsolved();
}
return timer.getStr();
}
//Returns the timer as a stopwatch
public Stopwatch getTimer(){
if(!solved){
throw new Unsolved();
}
return timer;
}
void solvedCheck(String str){
if(!solved){
throw new Unsolved("You must solve the problem before you can see the " + str);
}
}
//Solve the problem
public abstract void solve() throws InvalidResult;
//Reset the problem so it can be run again
public void reset(){
timer.reset();
solved = false;
}
}

92
src/main/java/com/mattrixwv/project_euler/problems/Problem1.java Normal file
View File

@@ -0,0 +1,92 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem1.java
//Matthew Ellison
// Created: 03-01-19
//Modified: 08-20-22
//What is the sum of all the multiples of 3 or 5 that are less than 1000
//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses
/*
Copyright (C) 2021 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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
public class Problem1 extends Problem{
//Variables
//Static variables
private static final int TOP_NUM = 999; //The largest number to be checked
//Instance variables
private int fullSum; //The sum of all the numbers
//Functions
//Constructor
public Problem1(){
super(String.format("What is the sum of all the multiples of 3 or 5 that are less than %d?", (TOP_NUM + 1)));
fullSum = 0;
}
//Operational functions
//Solve the problem
@Override
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 the sum of the progressions of 3 and 5 and remove the sum of progressions of the overlap
fullSum = sumOfProgression(3) + sumOfProgression(5) - sumOfProgression(3 * 5);
//Stop the timer
timer.stop();
//Throw 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();
fullSum = 0;
}
//Gets the sum of the progression of the multiple
private int sumOfProgression(double multiple){
double numTerms = Math.floor((double)TOP_NUM / multiple); //This gets the number of multiples of a particular number that is < MAX_NUMBER
//The sum of progression formula is (n / 2)(a + l). n = number of terms, a = multiple, l = last term
return (int)((numTerms / 2.0) * (multiple + (numTerms * multiple)));
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("The sum of all numbers < %d is %d", (TOP_NUM + 1), fullSum);
}
//Returns the requested sum
public int getSum(){
solvedCheck("sum");
return fullSum;
}
}
/* Results:
The sum of all numbers < 1000 is 233168
It took an average of 298.000 nanoseconds to run this problem through 100 iterations
*/

90
src/main/java/com/mattrixwv/project_euler/problems/Problem10.java Normal file
View File

@@ -0,0 +1,90 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem10.java
//Matthew Ellison
// Created: 03-03-19
//Modified: 08-20-22
//Find the sum of all the primes below two million
//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses
/*
Copyright (C) 2021 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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import com.mattrixwv.ArrayAlgorithms;
import com.mattrixwv.NumberAlgorithms;
public class Problem10 extends Problem{
//Variables
//Static variables
private static final long GOAL_NUMBER = 2000000 - 1; //The largest number to check for primes
//Instance variables
private long sum; //The sum of all of the prime numbers
//Functions
//Constructor
public Problem10(){
super(String.format("Find the sum of all the primes below %d.", GOAL_NUMBER + 1));
sum = 0;
}
//Operational functions
//Solve the problem
@Override
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 the sum of all prime numbers < GOAL_NUMBER
sum = ArrayAlgorithms.getLongSum(NumberAlgorithms.getPrimes(GOAL_NUMBER)); //Subtract 1 from the number so that it is < the number
//Stop the timer
timer.stop();
//Throw 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();
sum = 0;
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("The sum of all the primes < %d is %d", GOAL_NUMBER + 1, sum);
}
//Returns the sum that was requested
public long getSum(){
solvedCheck("sum");
return sum;
}
}
/* Results:
The sum of all the primes < 2000000 is 142913828922
It took an average of 186.751 milliseconds to run this problem through 100 iterations
*/

233
src/main/java/com/mattrixwv/project_euler/problems/Problem11.java Normal file
View File

@@ -0,0 +1,233 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem11.java
//Matthew Ellison
// Created: 03-03-19
//Modified: 08-20-22
//What is the greatest product of four adjacent numbers in the same direction (up, down, left, right, or diagonally) in the 20×20 grid?
/*
08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48
*/
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import java.util.ArrayList;
import java.util.List;
import com.mattrixwv.ArrayAlgorithms;
public class Problem11 extends Problem{
//Variables
//Static variables
//This is the grid of numbers that we will be working with
private static final Integer[][] grid = {{8, 02, 22, 97, 38, 15, 00, 40, 00, 75, 04, 05, 07, 78, 52, 12, 50, 77, 91, 8},
{49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48, 04, 56, 62, 00},
{81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30, 03, 49, 13, 36, 65},
{52, 70, 95, 23, 04, 60, 11, 42, 69, 24, 68, 56, 01, 32, 56, 71, 37, 02, 36, 91},
{22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80},
{24, 47, 32, 60, 99, 03, 45, 02, 44, 75, 33, 53, 78, 36, 84, 20, 35, 17, 12, 50},
{32, 98, 81, 28, 64, 23, 67, 10, 26, 38, 40, 67, 59, 54, 70, 66, 18, 38, 64, 70},
{67, 26, 20, 68, 02, 62, 12, 20, 95, 63, 94, 39, 63, 8, 40, 91, 66, 49, 94, 21},
{24, 55, 58, 05, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72},
{21, 36, 23, 9, 75, 00, 76, 44, 20, 45, 35, 14, 00, 61, 33, 97, 34, 31, 33, 95},
{78, 17, 53, 28, 22, 75, 31, 67, 15, 94, 03, 80, 04, 62, 16, 14, 9, 53, 56, 92},
{16, 39, 05, 42, 96, 35, 31, 47, 55, 58, 88, 24, 00, 17, 54, 24, 36, 29, 85, 57},
{86, 56, 00, 48, 35, 71, 89, 07, 05, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58},
{19, 80, 81, 68, 05, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77, 04, 89, 55, 40},
{04, 52, 8, 83, 97, 35, 99, 16, 07, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66},
{88, 36, 68, 87, 57, 62, 20, 72, 03, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69},
{04, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18, 8, 46, 29, 32, 40, 62, 76, 36},
{20, 69, 36, 41, 72, 30, 23, 88, 34, 62, 99, 69, 82, 67, 59, 85, 74, 04, 36, 16},
{20, 73, 35, 29, 78, 31, 90, 01, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57, 05, 54},
{01, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52, 01, 89, 19, 67, 48}};
//Instance variables
private ArrayList<Integer> greatestProduct; //Holds the largest product we have found so far
//Functions
//Constructor
public Problem11(){
super("What is the greatest product of four adjacent numbers in the same direction (up, down, left, right, or diagonally) in the 20×20 grid?");
greatestProduct = new ArrayList<>();
}
//Operational functions
//Solve the problem
@Override
public void solve(){
//If the problem has already been solved do nothing and end the function
if(solved){
return;
}
//Holds the numbers we are currently working on
ArrayList<Integer> currentProduct = new ArrayList<>();
//Make sure all elements have at least 4 elements
for(int cnt = 0;cnt < 4;++cnt){
greatestProduct.add(0);
currentProduct.add(0);
}
//Start the timer
timer.start();
//Loop through every row and column
for(int row = 0;row < grid.length;++row){
for(int col = 0;col < grid[row].length;++col){
//Directional booleans to show whether you can move a certain direction
boolean left = false;
boolean right = false;
boolean down = false;
//Check which direction you will be able to move
if((col - 3) >= 1){
left = true;
}
if((col + 3) < grid[row].length){
right = true;
}
if((row + 3) < 20){
down = true;
}
//Check the direction you are able to go
//Right
if(right){
//Fill the product
currentProduct.set(0, grid[row][col]);
currentProduct.set(1, grid[row][col + 1]);
currentProduct.set(2, grid[row][col + 2]);
currentProduct.set(3, grid[row][col + 3]);
//If the current number's product is greater than the greatest product replace it
if(ArrayAlgorithms.getProd(currentProduct) > ArrayAlgorithms.getProd(greatestProduct)){
greatestProduct.set(0, currentProduct.get(0));
greatestProduct.set(1, currentProduct.get(1));
greatestProduct.set(2, currentProduct.get(2));
greatestProduct.set(3, currentProduct.get(3));
}
}
//Down
if(down){
//Fill the product
currentProduct.set(0, grid[row][col]);
currentProduct.set(1, grid[row + 1][col]);
currentProduct.set(2, grid[row + 2][col]);
currentProduct.set(3, grid[row + 3][col]);
//If the current number's product is greater than the greatest product replace it
if(ArrayAlgorithms.getProd(currentProduct) > ArrayAlgorithms.getProd(greatestProduct)){
greatestProduct.set(0, currentProduct.get(0));
greatestProduct.set(1, currentProduct.get(1));
greatestProduct.set(2, currentProduct.get(2));
greatestProduct.set(3, currentProduct.get(3));
}
}
//LeftDown
if(left && down){
//Fill the product
currentProduct.set(0, grid[row][col]);
currentProduct.set(1, grid[row + 1][col - 1]);
currentProduct.set(2, grid[row + 2][col - 2]);
currentProduct.set(3, grid[row + 3][col - 3]);
//If the current number's product is greater than the greatest product replace it
if(ArrayAlgorithms.getProd(currentProduct) > ArrayAlgorithms.getProd(greatestProduct)){
greatestProduct.set(0, currentProduct.get(0));
greatestProduct.set(1, currentProduct.get(1));
greatestProduct.set(2, currentProduct.get(2));
greatestProduct.set(3, currentProduct.get(3));
}
}
//RightDown
if(right && down){
//Fill the product
currentProduct.set(0, grid[row][col]);
currentProduct.set(1, grid[row + 1][col + 1]);
currentProduct.set(2, grid[row + 2][col + 2]);
currentProduct.set(3, grid[row + 3][col + 3]);
//If the current number's product is greater than the greatest product replace it
if(ArrayAlgorithms.getProd(currentProduct) > ArrayAlgorithms.getProd(greatestProduct)){
greatestProduct.set(0, currentProduct.get(0));
greatestProduct.set(1, currentProduct.get(1));
greatestProduct.set(2, currentProduct.get(2));
greatestProduct.set(3, currentProduct.get(3));
}
}
}
}
//Stop the timer
timer.stop();
//Throw 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();
greatestProduct.clear();
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("The greatest product of 4 numbers in a line is %d%nThe numbers are %s", ArrayAlgorithms.getProd(greatestProduct), greatestProduct.toString());
}
//Returns the numbers that were being searched
public List<Integer> getNumbers(){
solvedCheck("numbers");
return greatestProduct;
}
//Returns the product that was requested
public int getProduct(){
solvedCheck("product of the numbers");
return ArrayAlgorithms.getProd(greatestProduct);
}
}
/* Results:
The greatest product of 4 numbers in a line is 70600674
The numbers are [89, 94, 97, 87]
It took an average of 301.209 microseconds to run this problem through 100 iterations
*/

126
src/main/java/com/mattrixwv/project_euler/problems/Problem12.java Normal file
View File

@@ -0,0 +1,126 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem12.java
//Matthew Ellison
// Created: 03-04-19
//Modified: 08-20-22
//What is the value of the first triangle number to have over five hundred divisors?
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import java.util.ArrayList;
import java.util.List;
import com.mattrixwv.NumberAlgorithms;
public class Problem12 extends Problem{
//Variables
//Static variables
private static final Long GOAL_DIVISORS = 500L; //The minimum number of divisors that you want
//Instance variables
private long sum; //The sum of the numbers up to counter
private long counter; //The next number to be added to sum
private List<Long> divisors; //Holds the divisors of the triangular number sum
//Functions
//Constructor
public Problem12(){
super(String.format("What is the value of the first triangle number to have over %d divisors?", GOAL_DIVISORS));
sum = 1;
counter = 2;
divisors = new ArrayList<>();
}
//Operational functions
//Solve the problem
public void solve(){
//If the problem has already been solved do nothing and end the function
if(solved){
return;
}
//Setup the other variables
boolean foundNumber = false; //To flag whether the number has been found
//Start the timer
timer.start();
//Loop until you find the appropriate number
while((!foundNumber) && (sum > 0)){
divisors = NumberAlgorithms.getDivisors(sum);
//If the number of divisors is correct set the flag
if(divisors.size() > GOAL_DIVISORS.intValue()){
foundNumber = true;
}
//Otherwise add to the sum and increase the next number
else{
sum += counter;
++counter;
}
}
//Stop the timer
timer.stop();
//Throw 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();
sum = 1;
counter = 2;
divisors.clear();
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("The triangular number %d is the sum of all numbers >= %d and has %d divisors", sum, counter - 1, divisors.size());
}
//Returns the triangular number
public long getTriangularNumber(){
solvedCheck("triangular number");
return sum;
}
//Get the final number that was added to the triangular number
public long getLastNumberAdded(){
solvedCheck("last number added to get the triangular number");
return counter - 1;
}
//Returns the list of divisors of the requested number
public List<Long> getDivisorsOfTriangularNumber(){
solvedCheck("divisors of the triangular number");
return divisors;
}
//Returns the number of divisors of the requested number
public int getNumberOfDivisors(){
solvedCheck("number of divisors of the triangular number");
return divisors.size();
}
}
/* Results:
The triangular number 76576500 is the sum of all numbers >= 12375 and has 576 divisors
It took an average of 344.173 milliseconds to run this problem through 100 iterations
*/

314
src/main/java/com/mattrixwv/project_euler/problems/Problem13.java Normal file
View File

@@ -0,0 +1,314 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem13.java
//Matthew Ellison
// Created: 03-04-19
//Modified: 08-20-22
//Work out the first ten digits of the sum of the following one-hundred 50-digit numbers
/*
37107287533902102798797998220837590246510135740250
46376937677490009712648124896970078050417018260538
74324986199524741059474233309513058123726617309629
91942213363574161572522430563301811072406154908250
23067588207539346171171980310421047513778063246676
89261670696623633820136378418383684178734361726757
28112879812849979408065481931592621691275889832738
44274228917432520321923589422876796487670272189318
47451445736001306439091167216856844588711603153276
70386486105843025439939619828917593665686757934951
62176457141856560629502157223196586755079324193331
64906352462741904929101432445813822663347944758178
92575867718337217661963751590579239728245598838407
58203565325359399008402633568948830189458628227828
80181199384826282014278194139940567587151170094390
35398664372827112653829987240784473053190104293586
86515506006295864861532075273371959191420517255829
71693888707715466499115593487603532921714970056938
54370070576826684624621495650076471787294438377604
53282654108756828443191190634694037855217779295145
36123272525000296071075082563815656710885258350721
45876576172410976447339110607218265236877223636045
17423706905851860660448207621209813287860733969412
81142660418086830619328460811191061556940512689692
51934325451728388641918047049293215058642563049483
62467221648435076201727918039944693004732956340691
15732444386908125794514089057706229429197107928209
55037687525678773091862540744969844508330393682126
18336384825330154686196124348767681297534375946515
80386287592878490201521685554828717201219257766954
78182833757993103614740356856449095527097864797581
16726320100436897842553539920931837441497806860984
48403098129077791799088218795327364475675590848030
87086987551392711854517078544161852424320693150332
59959406895756536782107074926966537676326235447210
69793950679652694742597709739166693763042633987085
41052684708299085211399427365734116182760315001271
65378607361501080857009149939512557028198746004375
35829035317434717326932123578154982629742552737307
94953759765105305946966067683156574377167401875275
88902802571733229619176668713819931811048770190271
25267680276078003013678680992525463401061632866526
36270218540497705585629946580636237993140746255962
24074486908231174977792365466257246923322810917141
91430288197103288597806669760892938638285025333403
34413065578016127815921815005561868836468420090470
23053081172816430487623791969842487255036638784583
11487696932154902810424020138335124462181441773470
63783299490636259666498587618221225225512486764533
67720186971698544312419572409913959008952310058822
95548255300263520781532296796249481641953868218774
76085327132285723110424803456124867697064507995236
37774242535411291684276865538926205024910326572967
23701913275725675285653248258265463092207058596522
29798860272258331913126375147341994889534765745501
18495701454879288984856827726077713721403798879715
38298203783031473527721580348144513491373226651381
34829543829199918180278916522431027392251122869539
40957953066405232632538044100059654939159879593635
29746152185502371307642255121183693803580388584903
41698116222072977186158236678424689157993532961922
62467957194401269043877107275048102390895523597457
23189706772547915061505504953922979530901129967519
86188088225875314529584099251203829009407770775672
11306739708304724483816533873502340845647058077308
82959174767140363198008187129011875491310547126581
97623331044818386269515456334926366572897563400500
42846280183517070527831839425882145521227251250327
55121603546981200581762165212827652751691296897789
32238195734329339946437501907836945765883352399886
75506164965184775180738168837861091527357929701337
62177842752192623401942399639168044983993173312731
32924185707147349566916674687634660915035914677504
99518671430235219628894890102423325116913619626622
73267460800591547471830798392868535206946944540724
76841822524674417161514036427982273348055556214818
97142617910342598647204516893989422179826088076852
87783646182799346313767754307809363333018982642090
10848802521674670883215120185883543223812876952786
71329612474782464538636993009049310363619763878039
62184073572399794223406235393808339651327408011116
66627891981488087797941876876144230030984490851411
60661826293682836764744779239180335110989069790714
85786944089552990653640447425576083659976645795096
66024396409905389607120198219976047599490197230297
64913982680032973156037120041377903785566085089252
16730939319872750275468906903707539413042652315011
94809377245048795150954100921645863754710598436791
78639167021187492431995700641917969777599028300699
15368713711936614952811305876380278410754449733078
40789923115535562561142322423255033685442488917353
44889911501440648020369068063960672322193204149535
41503128880339536053299340368006977710650566631954
81234880673210146739058568557934581403627822703280
82616570773948327592232845941706525094512325230608
22918802058777319719839450180888072429661980811197
77158542502016545090413245809786882778948721859617
72107838435069186155435662884062257473692284509516
20849603980134001723930671666823555245252804609722
53503534226472524250874054075591789781264330331690
*/
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import com.mattrixwv.ArrayAlgorithms;
public class Problem13 extends Problem{
//Variables
//Instance variables
private ArrayList<BigInteger> nums; //Holds the numbers that are being summed
private BigInteger sum; //The sum of all the numbers
//Functions
//Constructor
public Problem13(){
super("Work out the first ten digits of the sum of the one-hundred 50-digit numbers");
nums = new ArrayList<BigInteger>();
reserveVectors();
setNums();
sum = BigInteger.ZERO;
}
//Operational functions
//A function to set the nums vector
private void reserveVectors(){
nums.ensureCapacity(100);
}
//Reserve the size of the vector to speed up insertion
private void setNums(){
//Setup the array
nums.add(new BigInteger("37107287533902102798797998220837590246510135740250"));
nums.add(new BigInteger("46376937677490009712648124896970078050417018260538"));
nums.add(new BigInteger("74324986199524741059474233309513058123726617309629"));
nums.add(new BigInteger("91942213363574161572522430563301811072406154908250"));
nums.add(new BigInteger("23067588207539346171171980310421047513778063246676"));
nums.add(new BigInteger("89261670696623633820136378418383684178734361726757"));
nums.add(new BigInteger("28112879812849979408065481931592621691275889832738"));
nums.add(new BigInteger("44274228917432520321923589422876796487670272189318"));
nums.add(new BigInteger("47451445736001306439091167216856844588711603153276"));
nums.add(new BigInteger("70386486105843025439939619828917593665686757934951"));
nums.add(new BigInteger("62176457141856560629502157223196586755079324193331"));
nums.add(new BigInteger("64906352462741904929101432445813822663347944758178"));
nums.add(new BigInteger("92575867718337217661963751590579239728245598838407"));
nums.add(new BigInteger("58203565325359399008402633568948830189458628227828"));
nums.add(new BigInteger("80181199384826282014278194139940567587151170094390"));
nums.add(new BigInteger("35398664372827112653829987240784473053190104293586"));
nums.add(new BigInteger("86515506006295864861532075273371959191420517255829"));
nums.add(new BigInteger("71693888707715466499115593487603532921714970056938"));
nums.add(new BigInteger("54370070576826684624621495650076471787294438377604"));
nums.add(new BigInteger("53282654108756828443191190634694037855217779295145"));
nums.add(new BigInteger("36123272525000296071075082563815656710885258350721"));
nums.add(new BigInteger("45876576172410976447339110607218265236877223636045"));
nums.add(new BigInteger("17423706905851860660448207621209813287860733969412"));
nums.add(new BigInteger("81142660418086830619328460811191061556940512689692"));
nums.add(new BigInteger("51934325451728388641918047049293215058642563049483"));
nums.add(new BigInteger("62467221648435076201727918039944693004732956340691"));
nums.add(new BigInteger("15732444386908125794514089057706229429197107928209"));
nums.add(new BigInteger("55037687525678773091862540744969844508330393682126"));
nums.add(new BigInteger("18336384825330154686196124348767681297534375946515"));
nums.add(new BigInteger("80386287592878490201521685554828717201219257766954"));
nums.add(new BigInteger("78182833757993103614740356856449095527097864797581"));
nums.add(new BigInteger("16726320100436897842553539920931837441497806860984"));
nums.add(new BigInteger("48403098129077791799088218795327364475675590848030"));
nums.add(new BigInteger("87086987551392711854517078544161852424320693150332"));
nums.add(new BigInteger("59959406895756536782107074926966537676326235447210"));
nums.add(new BigInteger("69793950679652694742597709739166693763042633987085"));
nums.add(new BigInteger("41052684708299085211399427365734116182760315001271"));
nums.add(new BigInteger("65378607361501080857009149939512557028198746004375"));
nums.add(new BigInteger("35829035317434717326932123578154982629742552737307"));
nums.add(new BigInteger("94953759765105305946966067683156574377167401875275"));
nums.add(new BigInteger("88902802571733229619176668713819931811048770190271"));
nums.add(new BigInteger("25267680276078003013678680992525463401061632866526"));
nums.add(new BigInteger("36270218540497705585629946580636237993140746255962"));
nums.add(new BigInteger("24074486908231174977792365466257246923322810917141"));
nums.add(new BigInteger("91430288197103288597806669760892938638285025333403"));
nums.add(new BigInteger("34413065578016127815921815005561868836468420090470"));
nums.add(new BigInteger("23053081172816430487623791969842487255036638784583"));
nums.add(new BigInteger("11487696932154902810424020138335124462181441773470"));
nums.add(new BigInteger("63783299490636259666498587618221225225512486764533"));
nums.add(new BigInteger("67720186971698544312419572409913959008952310058822"));
nums.add(new BigInteger("95548255300263520781532296796249481641953868218774"));
nums.add(new BigInteger("76085327132285723110424803456124867697064507995236"));
nums.add(new BigInteger("37774242535411291684276865538926205024910326572967"));
nums.add(new BigInteger("23701913275725675285653248258265463092207058596522"));
nums.add(new BigInteger("29798860272258331913126375147341994889534765745501"));
nums.add(new BigInteger("18495701454879288984856827726077713721403798879715"));
nums.add(new BigInteger("38298203783031473527721580348144513491373226651381"));
nums.add(new BigInteger("34829543829199918180278916522431027392251122869539"));
nums.add(new BigInteger("40957953066405232632538044100059654939159879593635"));
nums.add(new BigInteger("29746152185502371307642255121183693803580388584903"));
nums.add(new BigInteger("41698116222072977186158236678424689157993532961922"));
nums.add(new BigInteger("62467957194401269043877107275048102390895523597457"));
nums.add(new BigInteger("23189706772547915061505504953922979530901129967519"));
nums.add(new BigInteger("86188088225875314529584099251203829009407770775672"));
nums.add(new BigInteger("11306739708304724483816533873502340845647058077308"));
nums.add(new BigInteger("82959174767140363198008187129011875491310547126581"));
nums.add(new BigInteger("97623331044818386269515456334926366572897563400500"));
nums.add(new BigInteger("42846280183517070527831839425882145521227251250327"));
nums.add(new BigInteger("55121603546981200581762165212827652751691296897789"));
nums.add(new BigInteger("32238195734329339946437501907836945765883352399886"));
nums.add(new BigInteger("75506164965184775180738168837861091527357929701337"));
nums.add(new BigInteger("62177842752192623401942399639168044983993173312731"));
nums.add(new BigInteger("32924185707147349566916674687634660915035914677504"));
nums.add(new BigInteger("99518671430235219628894890102423325116913619626622"));
nums.add(new BigInteger("73267460800591547471830798392868535206946944540724"));
nums.add(new BigInteger("76841822524674417161514036427982273348055556214818"));
nums.add(new BigInteger("97142617910342598647204516893989422179826088076852"));
nums.add(new BigInteger("87783646182799346313767754307809363333018982642090"));
nums.add(new BigInteger("10848802521674670883215120185883543223812876952786"));
nums.add(new BigInteger("71329612474782464538636993009049310363619763878039"));
nums.add(new BigInteger("62184073572399794223406235393808339651327408011116"));
nums.add(new BigInteger("66627891981488087797941876876144230030984490851411"));
nums.add(new BigInteger("60661826293682836764744779239180335110989069790714"));
nums.add(new BigInteger("85786944089552990653640447425576083659976645795096"));
nums.add(new BigInteger("66024396409905389607120198219976047599490197230297"));
nums.add(new BigInteger("64913982680032973156037120041377903785566085089252"));
nums.add(new BigInteger("16730939319872750275468906903707539413042652315011"));
nums.add(new BigInteger("94809377245048795150954100921645863754710598436791"));
nums.add(new BigInteger("78639167021187492431995700641917969777599028300699"));
nums.add(new BigInteger("15368713711936614952811305876380278410754449733078"));
nums.add(new BigInteger("40789923115535562561142322423255033685442488917353"));
nums.add(new BigInteger("44889911501440648020369068063960672322193204149535"));
nums.add(new BigInteger("41503128880339536053299340368006977710650566631954"));
nums.add(new BigInteger("81234880673210146739058568557934581403627822703280"));
nums.add(new BigInteger("82616570773948327592232845941706525094512325230608"));
nums.add(new BigInteger("22918802058777319719839450180888072429661980811197"));
nums.add(new BigInteger("77158542502016545090413245809786882778948721859617"));
nums.add(new BigInteger("72107838435069186155435662884062257473692284509516"));
nums.add(new BigInteger("20849603980134001723930671666823555245252804609722"));
nums.add(new BigInteger("53503534226472524250874054075591789781264330331690"));
}
//Solve the problem
@Override
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 the sum of all the numbers
sum = ArrayAlgorithms.getBigSum(nums);
//Stop the timer
timer.stop();
//Throw 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();
sum = BigInteger.ZERO;
nums.clear();
reserveVectors();
setNums();
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("The sum of all %d numbers is %d%nThe first 10 digits of the sum of the numbers is %s", nums.size(), sum, (sum.toString()).substring(0, 10));
}
//Returns the list of 50-digit numbers
public List<BigInteger> getNumbers(){
solvedCheck("numbers");
return nums;
}
//Returns the sum of the 50-digit numbers
public BigInteger getSum(){
solvedCheck("sum");
return sum;
}
}
/* Results:
The sum of all 100 numbers is 5537376230390876637302048746832985971773659831892672
The first 10 digits of the sum of the numbers is 5537376230
It took an average of 129.354 microseconds to run this problem through 100 iterations
*/

124
src/main/java/com/mattrixwv/project_euler/problems/Problem14.java Normal file
View File

@@ -0,0 +1,124 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem14.java
//Matthew Ellison
// Created: 03-04-19
//Modified: 08-20-22
/*
The following iterative sequence is defined for the set of positive integers:
n → n/2 (n is even)
n → 3n + 1 (n is odd)
Which starting number, under one million, produces the longest chain?
*/
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
public class Problem14 extends Problem{
//Variables
//Static variables
private static final long MAX_NUM = 1000000 - 1; //This is the top number that you will be checking against the series
//Instance variables
private long maxLength; //This is the length of the longest chain
private long maxNum; //This is the starting number of the longest chain
//Functions
//Constructor
public Problem14(){
super(String.format("Which starting number, under %d, produces the longest chain using the iterative sequence?", MAX_NUM + 1));
maxLength = 0;
maxNum = 0;
}
//Operational functions
//Solve the problem
@Override
public void solve(){
//If the problem has already been solved do nothing and end the function
if(solved){
return;
}
//Start the timer
timer.start();
//Loop through all numbers <= MAX_NUM and check them against the series
for(long currentNum = 1L;currentNum <= MAX_NUM;++currentNum){
long currentLength = checkSeries(currentNum);
//If the current number has a longer series than the max then the current becomes the max
if(currentLength > maxLength){
maxLength = currentLength;
maxNum = currentNum;
}
}
//Stop the timer
timer.stop();
//Throw a flag to show the problem is solved
solved = true;
}
//This function follows the rules of the sequence and returns its length
private long checkSeries(long num){
long length = 1L; //Start at 1 because you need to count the starting number
//Follow the series, adding 1 for each step you take
while(num > 1){
if((num % 2) == 0){
num /= 2;
}
else{
num = (3 * num) + 1;
}
++length;
}
//Return the length of the series
return length;
}
//Reset the problem so it can be run again
@Override
public void reset(){
super.reset();
maxLength = 0;
maxNum = 0;
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("The number %d produced a chain of %d steps", maxNum, maxLength);
}
//Returns the length of the requested chain
public long getLength(){
solvedCheck("length of the longest chain");
return maxLength;
}
//Returns the starting number of the requested chain
public long getStartingNumber(){
solvedCheck("starting number of the longest chain");
return maxNum;
}
}
/* Results:
The number 837799 produced a chain of 525 steps
It took an average of 286.004 milliseconds to run this problem through 100 iterations
*/

107
src/main/java/com/mattrixwv/project_euler/problems/Problem15.java Normal file
View File

@@ -0,0 +1,107 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem15.java
//Matthew Ellison
// Created: 03-04-19
//Modified: 08-20-22
//How many routes from the top left corner to the bottom right corner are there through a 20×20 grid if you can only move right and down?
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
public class Problem15 extends Problem{
//Variables
//Static vaiables
private static final int WIDTH = 20; //The width of the box to traverse
private static final int LENGTH = 20; //The height of the box to traverse
//Instance variables
private long numOfRoutes; //The number of routes from 0, 0 to 20, 20
//Functions
//Constructor
public Problem15(){
super(String.format("How many routes from the top left corner to the bottom right corner are there through a %dx%d grid if you can only move right and down?", WIDTH, LENGTH));
numOfRoutes = 0;
}
//Operational functions
//Solve the problems
@Override
public void solve(){
//If the problem has already been solved do nothing and end the function
if(solved){
return;
}
//Start the timer
timer.start();
//We write this as a recursive function
//When in a location it always moves right first, then down
move(0, 0);
//Stop the timer
timer.stop();
//Throw a flag to show the problem is solved
solved = true;
}
//This function acts as a handler for moving the position on the grid and counting the distance
//It moves right first, then down
private void move(int currentX, int currentY){
//Check if you are at the end and act accordingly
if((currentX == WIDTH) && (currentY == LENGTH)){
++numOfRoutes;
return;
}
//Move right if possible
if(currentX < WIDTH){
move(currentX + 1, currentY);
}
//Move down if possible
if(currentY < LENGTH){
move(currentX, currentY + 1);
}
}
//Reset the problem so it can be run again
@Override
public void reset(){
super.reset();
numOfRoutes = 0;
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("The number of routes is %d", numOfRoutes);
}
//Returns the number of routes found
public long getNumberOfRoutes(){
solvedCheck("number of routes");
return numOfRoutes;
}
}
/* Results:
The number of routes is 137846528820
It took an average of 20.702 minutes to run this problem through 10 iterations
*/

107
src/main/java/com/mattrixwv/project_euler/problems/Problem16.java Normal file
View File

@@ -0,0 +1,107 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem16.java
//Matthew Ellison
// Created: 03-04-19
//Modified: 08-20-22
//What is the sum of the digits of the number 2^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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import java.math.BigInteger;
public class Problem16 extends Problem{
//Variables
//Static variables
private static final int NUM_TO_POWER = 2; //The number that is going to be raised to a power
private static final int POWER = 1000; //The power that the number is going to be raised to
//Instance variables
private BigInteger num; //The number to be calculated
private int sumOfElements; //The sum of all digits in the number
//Functions
//Constructor
public Problem16(){
super(String.format("What is the sum of the digits of the number %d^%d?", NUM_TO_POWER, POWER));
num = BigInteger.ZERO;
sumOfElements = 0;
}
//Operational functions
//Solve the problem
@Override
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 the number
num = BigInteger.valueOf(NUM_TO_POWER).pow(POWER);
//Get a string of the number
String numString = num.toString();
//Add up the individual characters of the string
for(int cnt = 0;cnt < numString.length();++cnt){
sumOfElements += Integer.parseInt(numString.substring(cnt, cnt + 1));
}
//Stop the timer
timer.stop();
//Throw 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 = BigInteger.ZERO;
sumOfElements = 0;
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("%d^%d = %s%nThe sum of the elements is %d", NUM_TO_POWER, POWER, num.toString(), sumOfElements);
}
//Returns the number that was calculated
public BigInteger getNumber(){
solvedCheck("number");
return num;
}
//Return the sum of the digits of the number
public int getSum(){
solvedCheck("sum");
return sumOfElements;
}
}
/* Results:
2^1000 = 10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831652624386837205668069376
The sum of the elements is 1366
It took an average of 60.914 microseconds to run this problem through 100 iterations
*/

206
src/main/java/com/mattrixwv/project_euler/problems/Problem17.java Normal file
View File

@@ -0,0 +1,206 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem17.java
//Matthew Ellison
// Created: 03-04-19
//Modified: 08-20-22
//If all the numbers from 1 to 1000 (one thousand) inclusive were written out in words, how many letters would be used?
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import com.mattrixwv.project_euler.Unsolved;
public class Problem17 extends Problem{
//Variables
//Static variables
private static final int START_NUM = 1; //This is the smallest number to get the words of
private static final int STOP_NUM = 1000; //This is the largest number to get the words of
//Instance variables
private long letterCount; //This is the cumulative number of letters in the words of the numbers
//Functions
//Constructor
public Problem17(){
super(String.format("If all the numbers from %d to %d inclusive were written out in words, how many letters would be used?", START_NUM, STOP_NUM));
letterCount = 0;
}
//Operational functions
//Solve the problem
@Override
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 increment
for(int num = START_NUM;num <= STOP_NUM;++num){
//Pass the number to a function that will create a string for the number
String currentNumString = makeWordFromNum(num);
//Pass the string to the function that will count the number of letters in it, ignoring whitespace and punctuation and add that number to the running tally
letterCount += getNumberChars(currentNumString);
}
//Stop the timer
timer.stop();
//Throw 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();
letterCount = 0;
}
//This function makes a word out of the number passed into it
private String makeWordFromNum(int number){
int num = number;
StringBuilder numberString = new StringBuilder();
//Starting with the largest digit create a string based on the number passed in
//Check for negative
if(num < 0){
numberString.append("negative ");
}
//Check if the number is zero
if(num == 0){
numberString.append("zero");
}
//Start with the thousands place
if((num / 1000D) >= 1D){
numberString.append(makeWordFromNum((int)Math.floor(num / 1000D)));
numberString.append(" thousand");
num -= ((int)Math.floor(num / 1000D) * 1000);
}
//Check the hundreds place
if((num / 100D) >= 1D){
numberString.append(makeWordFromNum((int)Math.floor(num / 100D)));
numberString.append(" hundred");
num -= ((int)Math.floor(num / 100D) * 100);
}
//Insert an and if there is need
if(!numberString.toString().isBlank() && (num > 0)){
numberString.append(" and ");
}
//Check for tens place
if((num / 10D) >= 2D){
//For the tens you need to do something special
int tensPlace = (int)Math.floor(num / 10D);
switch(tensPlace){
case 9: numberString.append("ninety"); break;
case 8: numberString.append("eighty"); break;
case 7: numberString.append("seventy"); break;
case 6: numberString.append("sixty"); break;
case 5: numberString.append("fifty"); break;
case 4: numberString.append("forty"); break;
case 3: numberString.append("thirty"); break;
case 2: numberString.append("twenty"); break;
}
num -= (tensPlace * 10);
//If there is something left in the number you will need a dash to separate the tens and ones place
if(num > 0){
numberString.append("-");
}
}
//Check for teens
else if((num / 10D) >= 1D){
int onesPlace = (num % 10);
switch(onesPlace){
case 9: numberString.append("nineteen"); break;
case 8: numberString.append("eighteen"); break;
case 7: numberString.append("seventeen"); break;
case 6: numberString.append("sixteen"); break;
case 5: numberString.append("fifteen"); break;
case 4: numberString.append("fourteen"); break;
case 3: numberString.append("thirteen"); break;
case 2: numberString.append("twelve"); break;
case 1: numberString.append("eleven"); break;
case 0: numberString.append("ten"); break;
}
//If this was hit the number was completed
num = 0;
}
//Check for the ones place
if(num >= 1){
switch(num){
case 9: numberString.append("nine"); break;
case 8: numberString.append("eight"); break;
case 7: numberString.append("seven"); break;
case 6: numberString.append("six"); break;
case 5: numberString.append("five"); break;
case 4: numberString.append("four"); break;
case 3: numberString.append("three"); break;
case 2: numberString.append("two"); break;
case 1: numberString.append("one"); break;
}
//If this was hit the number was completed
num = 0;
}
//If the number is not 0 there was a problem
if(num != 0){
throw new Unsolved("The number " + number + " was not completely reduced!\nRemainder is " + num);
}
//Return the string
return numberString.toString();
}
//This counts the number of letters in the string that is passed in (ignoring numbers and punctuation)
private int getNumberChars(String number){
int sumOfLetters = 0;
//Start at location 0 and count the number of letters, ignoring punctuation and whitespace
for(int location = 0;location < number.length();++location){
if(Character.isAlphabetic(number.charAt(location))){
sumOfLetters += 1;
}
}
//Return the number of letters
return sumOfLetters;
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("The sum of all the letters in all the numbers %d-%d is %d", START_NUM, STOP_NUM, letterCount);
}
//Returns the number of letters asked for
public long getLetterCount(){
solvedCheck("letter count");
return letterCount;
}
}
/* Results:
The sum of all the letters in all the numbers 1-1000 is 21124
It took an average of 216.210 microseconds to run this problem through 100 iterations
*/

285
src/main/java/com/mattrixwv/project_euler/problems/Problem18.java Normal file
View File

@@ -0,0 +1,285 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem18.java
//Matthew Ellison
// Created: 03-11-19
//Modified: 08-20-22
//Find the maximum total from top to bottom
/*
75
95 64
17 47 82
18 35 87 10
20 04 82 47 65
19 01 23 75 03 34
88 02 77 73 07 63 67
99 65 04 28 06 16 70 92
41 41 26 56 83 40 80 70 33
41 48 72 33 47 32 37 16 94 29
53 71 44 65 25 43 91 52 97 51 14
70 11 33 28 77 73 17 78 39 68 17 57
91 71 52 38 17 14 91 43 58 50 27 29 48
63 66 04 68 89 53 67 30 73 16 69 87 40 31
04 62 98 27 23 09 70 98 73 93 38 53 60 04 23
*/
//This is done using a breadth first search
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
public class Problem18 extends Problem{
//Structures
//Used to keep track of where the best location came from
protected static class Location{
public int xLocation;
public int yLocation;
public int total;
//Used originally for debugging so I could trace the path backwards
public boolean fromRight;
Location(int x, int y, int t, boolean r){
xLocation = x;
yLocation = y;
total = t;
fromRight = r;
}
}
//Variables
//Static variables
protected static ArrayList<ArrayList<Integer>> list; //The list to hold the numbers in
static{
list = new ArrayList<ArrayList<Integer>>(
Arrays.asList(
new ArrayList<Integer>(Arrays.asList(75)),
new ArrayList<Integer>(Arrays.asList(95, 64)),
new ArrayList<Integer>(Arrays.asList(17, 47, 82)),
new ArrayList<Integer>(Arrays.asList(18, 35, 87, 10)),
new ArrayList<Integer>(Arrays.asList(20, 04, 82, 47, 65)),
new ArrayList<Integer>(Arrays.asList(19, 01, 23, 75, 03, 34)),
new ArrayList<Integer>(Arrays.asList(88, 02, 77, 73, 07, 63, 67)),
new ArrayList<Integer>(Arrays.asList(99, 65, 04, 28, 06, 16, 70, 92)),
new ArrayList<Integer>(Arrays.asList(41, 41, 26, 56, 83, 40, 80, 70, 33)),
new ArrayList<Integer>(Arrays.asList(41, 48, 72, 33, 47, 32, 37, 16, 94, 29)),
new ArrayList<Integer>(Arrays.asList(53, 71, 44, 65, 25, 43, 91, 52, 97, 51, 14)),
new ArrayList<Integer>(Arrays.asList(70, 11, 33, 28, 77, 73, 17, 78, 39, 68, 17, 57)),
new ArrayList<Integer>(Arrays.asList(91, 71, 52, 38, 17, 14, 91, 43, 58, 50, 27, 29, 48)),
new ArrayList<Integer>(Arrays.asList(63, 66, 04, 68, 89, 53, 67, 30, 73, 16, 69, 87, 40, 31)),
new ArrayList<Integer>(Arrays.asList(04, 62, 98, 27, 23, 9, 70, 98, 73, 93, 38, 53, 60, 04, 23))
));
}
//Instance variables
protected ArrayList<Location> foundPoints; //For the points that you have already found the shortest distance to
protected ArrayList<Location> possiblePoints; //For the locations you are checking this round
protected int actualTotal; //The true total of the path from the top to the bottom
//Functions
//Constructor
public Problem18(){
super("Find the maximum total from top to bottom");
foundPoints = new ArrayList<>();
possiblePoints = new ArrayList<>();
actualTotal = 0;
}
//Operational functions
//This function turns every number in the array into (100 - num) to allow you to find the largest numbers rather than the smallest
protected void invert(ArrayList<ArrayList<Integer>> list){
//Loop through every row in the list
for(int rowCnt = 0;rowCnt < list.size();++rowCnt){
//Loop through every column in the list
for(int colCnt = 0;colCnt < list.get(rowCnt).size();++colCnt){
//The current element gets the value of 100 - value
list.get(rowCnt).set(colCnt, 100 - list.get(rowCnt).get(colCnt));
}
}
}
//This function helps by removing the element that is the same as the minimum location
protected void removeHelper(ArrayList<Location> possiblePoints, final Location minLoc){
possiblePoints.removeIf(loc -> ((loc.xLocation == minLoc.xLocation) && (loc.yLocation == minLoc.yLocation)));
}
//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();
//Invert the list
invert(list);
//Add the first row as a found point because you have to go through the top element
foundPoints.add(new Location(0, 0, list.get(0).get(0), false));
//Add the second row as possible points
possiblePoints.add(new Location(0, 1, (list.get(0).get(0) + list.get(1).get(0)), true));
possiblePoints.add(new Location(1, 1, (list.get(0).get(0) + list.get(1).get(1)), false));
boolean foundBottom = false; //Used when you find a point at the bottom of the list
//Loop until you find the bottom of the list
while(!foundBottom){
//Check which possible point gives us the lowest number. If more than one has the same number simply keep the first one
Location minLoc = possiblePoints.get(0);
for(Location loc : possiblePoints){
if(loc.total < minLoc.total){
minLoc = loc;
}
}
//Remove it from the list of possible points
removeHelper(possiblePoints, minLoc);
//Add that point to the list of found points
foundPoints.add(minLoc);
//Add to the list of possible points from the point we just found and
//If you are at the bottom raise the flag to end the program
int xLoc = minLoc.xLocation;
int yLoc = minLoc.yLocation + 1; //Add one because you will always be moving to the next row
if(yLoc >= list.size()){
foundBottom = true;
}
else{
possiblePoints.add(new Location(xLoc, yLoc, minLoc.total + list.get(yLoc).get(xLoc), true));
//Advance the x location to simulate going right
++xLoc;
//Check if x is out of bounds
if(xLoc < list.get(yLoc).size()){
possiblePoints.add(new Location(xLoc, yLoc, minLoc.total + list.get(yLoc).get(xLoc), false));
}
}
}
//Invert the list again so it is correct
invert(list);
//Save the results
//Get the correct total which will be the inversion of the current one
actualTotal = ((100 * list.size()) - foundPoints.get(foundPoints.size() - 1).total);
//Stop the timer
timer.stop();
//Throw 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();
foundPoints.clear();
possiblePoints.clear();
actualTotal = 0;
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("The value of the longest path is %d", actualTotal);
}
//Returns the pyramid that was traversed as a string
public String getPyramid(){
solvedCheck("pyramid of numbers");
StringBuilder results = new StringBuilder();
//Loop through all elements of the list and print them
for(ArrayList<Integer> row : list){
for(int column : row){
results.append(String.format("%2d ", column));
}
results.append('\n');
}
return results.toString();
}
//Returns the trail the algorithm took as a string
public String getTrail(){
solvedCheck("trail of the shortest path");
StringBuilder results = new StringBuilder();
//Save the trail the algorithm took
ArrayList<Location> trail = new ArrayList<Location>();
trail.add(foundPoints.get(foundPoints.size() - 1));
boolean top = false;
while(!top){
boolean found = false;
int loc = foundPoints.size() - 1;
Location toAdd = null;
while(!found){
if(loc < 0){
results.append("Error: Location < 0\n");
System.exit(1);
}
Iterator<Location> it = foundPoints.iterator();
Location tempLoc = null;
for(int cnt = 0;cnt < loc;++cnt){
tempLoc = it.next();
}
if(trail.get(0).fromRight){
if((tempLoc.xLocation == trail.get(0).xLocation) && (tempLoc.yLocation == (trail.get(0).yLocation - 1))){
found = true;
toAdd = tempLoc;
}
else{
--loc;
}
}
else{
if((tempLoc.xLocation == (trail.get(0).xLocation - 1)) && (tempLoc.yLocation == (trail.get(0).yLocation - 1))){
found = true;
toAdd = tempLoc;
}
else{
--loc;
}
}
}
trail.add(0, toAdd);
if(trail.get(0).yLocation == 0){
top = true;
}
}
for(Location loc : trail){
results.append(list.get(loc.yLocation).get(loc.xLocation));
if(loc.yLocation < (list.size() - 1)){
results.append("->");
}
}
return results.toString();
}
//Returns the total that was asked for
public int getTotal(){
solvedCheck("total");
return actualTotal;
}
}
/* Results:
The value of the longest path is 1074
It took an average of 198.418 microseconds to run this problem through 100 iterations
*/

213
src/main/java/com/mattrixwv/project_euler/problems/Problem19.java Normal file
View File

@@ -0,0 +1,213 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem19.java
//Matthew Ellison
// Created: 03-13-19
//Modified: 08-20-22
//How many Sundays fell on the first of the month during the twentieth century (1 Jan 1901 to 31 Dec 2000)?
/*
You are given the following information, but you may prefer to do some research for yourself.
1 Jan 1900 was a Monday.
Thirty days has September,
April, June and November.
All the rest have thirty-one,
Saving February alone,
Which has twenty-eight, rain or shine.
And on leap years, twenty-nine.
A leap year occurs on any year evenly divisible by 4, but not on a century unless it is divisible by 400.
*/
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
public class Problem19 extends Problem{
//Variables
//Static variables
//An easier way to signal day of the week
private enum DAYS{SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, NUMBER_OF_DAYS, ERROR};
private static final int START_YEAR = 1901; //The first year we are going to test
private static final int END_YEAR = 2000; //The last year we are going to test
//Instance variables
private long totalSundays; //Keep track of the number of sundays
//Functions
//Constructor
public Problem19(){
super("How many Sundays fell on the first of the month during the twentieth century (1 Jan 1901 to 31 Dec 2000)?");
totalSundays = 0;
}
//Operational functions
//Solve the problem
@Override
public void solve(){
//If the problem has already been solved do nothing and end the function
if(solved){
return;
}
//Start the timer
timer.start();
//Run for all years 1901-2000
for(int year = START_YEAR;year <= END_YEAR;++year){
//Run for all months in the year
for(int month = 1;month <= 12;++month){
DAYS day = getDay(month, 1, year);
if(day == DAYS.ERROR){
System.out.println("There was an error with the day");
}
else if(day == DAYS.SUNDAY){
++totalSundays;
}
}
}
//Stop the timer
timer.stop();
//Throw a flag to show the problem is solved
solved = true;
}
//Return the day of the week that the date you pass into it is on
private DAYS getDay(int month, int day, int year){
//Make sure the numbers are within propper bounds
if((month < 1) || (month > 12) || (day < 1) || (day > 31) || (year < 1)){
return DAYS.ERROR;
}
int numDays = 0;
int currentYear = 1;
int currentMonth = 1;
int currentDay = DAYS.SATURDAY.ordinal();
--day;
//Add the correct number of days for every year
while(currentYear < year){
if(isLeapYear(currentYear)){
numDays += 366;
}
else{
numDays += 365;
}
++currentYear;
}
//Add the correct number of days for every month
while(currentMonth < month){
switch(currentMonth){
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12: numDays += 31; break;
case 4:
case 6:
case 9:
case 11: numDays += 30; break;
case 2:
if(isLeapYear(currentYear)){
numDays += 29;
}
else{
numDays += 28;
}
break;
}
++currentMonth;
}
//Account for the weird year of 1752
if(year > 1752){
numDays -= 11;
}
else if(year == 1752){
if(month > 9){
numDays -= 11;
}
else if(month == 9){
if(day >= 14){
numDays -= 11;
}
//Days 3-13 were skipped that year
else if((day > 2) && (day < 14)){
System.out.println("Hit 1752 error");
return DAYS.ERROR;
}
}
}
//Add the correct number of days for every day
numDays += day;
currentDay += numDays;
currentDay = currentDay % DAYS.NUMBER_OF_DAYS.ordinal();
DAYS typeDay = DAYS.values()[currentDay];
switch(typeDay){
case SUNDAY: return DAYS.SUNDAY;
case MONDAY: return DAYS.MONDAY;
case TUESDAY: return DAYS.TUESDAY;
case WEDNESDAY: return DAYS.WEDNESDAY;
case THURSDAY: return DAYS.THURSDAY;
case FRIDAY: return DAYS.FRIDAY;
case SATURDAY: return DAYS.SATURDAY;
default: System.out.println("Hit default error"); return DAYS.ERROR;
}
}
//Returns true if the year passed to it is a leap year
private boolean isLeapYear(int year){
if(year < 1){
return false;
}
else if((year % 100) == 0){
//This rule only applies at and after 1800
if(year <= 1700){
return true;
}
else if((year % 400) == 0){
return true;
}
}
else if((year % 4) == 0){
return true;
}
return false;
}
//Reset the problem so it can be run again
@Override
public void reset(){
super.reset();
totalSundays = 0;
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("There are %d Sundays that landed on the first of the months from %d to %d", totalSundays, START_YEAR, END_YEAR);
}
//Returns the total sundays that were asked for
public long getTotalSundays(){
solvedCheck("total number of sundays");
return totalSundays;
}
}
/* Results:
There are 171 Sundays that landed on the first of the months from 1901 to 2000
It took an average of 4.656 milliseconds to run this problem through 100 iterations
*/

98
src/main/java/com/mattrixwv/project_euler/problems/Problem2.java Normal file
View File

@@ -0,0 +1,98 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem2.java
//Matthew Ellison
// Created: 03-01-19
//Modified: 08-20-22
//The sum of the even Fibonacci numbers less than 4,000,000
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import java.util.List;
import com.mattrixwv.NumberAlgorithms;
public class Problem2 extends Problem{
//Variables
//Static variables
private static final int TOP_NUM = 4000000 - 1; //The largest number that will be checked as a fibonacci number
//Instance variables
private int fullSum; //Holds the sum of all the numbers
//Functions
//Constructor
public Problem2(){
super(String.format("What is the sum of the even Fibonacci numbers less than %d?", (TOP_NUM + 1)));
fullSum = 0;
}
//Operational functions
//Solve the problem
@Override
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 a list of all fibonacci numbers <= TOP_NUM
List<Integer> fibNums = NumberAlgorithms.getAllFib(TOP_NUM);
//Step through every element in the list checking if it is even
for(int num : fibNums){
//If the number is even add it to the running tally
if((num % 2) == 0){
fullSum += num;
}
}
//Stop the timer
timer.stop();
//Throw 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();
fullSum = 0;
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("The sum of all even fibonacci numbers <= %d is %d", TOP_NUM, fullSum);
}
//Returns the requested sum
public int getSum(){
solvedCheck("sum");
return fullSum;
}
}
/* Results:
The sum of all even fibonacci numbers <= 3999999 is 4613732
It took an average of 29.713 microseconds to run this problem through 100 iterations
*/

114
src/main/java/com/mattrixwv/project_euler/problems/Problem20.java Normal file
View File

@@ -0,0 +1,114 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem20.java
//Matthew Ellison
// Created: 03-14-19
//Modified: 08-20-22
//What is the sum of the digits of 100!?
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import java.math.BigInteger;
public class Problem20 extends Problem{
//Variables
//Static variables
private static final int TOP_NUM = 100; //The largest number that will be multiplied
//Instance variables
private BigInteger num; //Holds the number 100!
private long sum; //The sum of the digits of num
//Functions
//Constructor
public Problem20(){
super(String.format("What is the sum of the digits of %d!?", TOP_NUM));
num = BigInteger.ONE;
sum = 0;
}
//Operational functions
//Solve the problem
@Override
public void solve(){
//If the problem has already been solved do nothing and end the function
if(solved){
return;
}
//Start the timer
timer.start();
//Run through every number from 1 to 100 and multiply it by the current num to generate 100!
for(int cnt = TOP_NUM;cnt > 1;--cnt){
num = num.multiply(BigInteger.valueOf(cnt));
}
//Get a string of the number because it is easier to pull apart the individual characters
String numString = num.toString();
//Run through every character in the string, convert it back to an integer and add it to the running sum
for(int cnt = 0;cnt < numString.length();++cnt){
Character digit = numString.charAt(cnt);
sum += Integer.valueOf(digit.toString());
}
//Stop the timer
timer.stop();
//Throw 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 = BigInteger.ONE;
sum = 0;
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("%d! = %s%nThe sum of the digits is: %d", TOP_NUM, num.toString(), sum);
}
//Returns the number 100!
public BigInteger getNumber(){
solvedCheck("number");
return num;
}
//Returns the number 100! in a string
public String getNumberString(){
solvedCheck("number as a string");
return num.toString(10);
}
//Returns the sum of the digits of 100!
public long getSum(){
//If the problem hasn't been solved throw an exception
solvedCheck("sum of the digits");
return sum;
}
}
/* Restuls:
100! = 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000
The sum of the digits is: 648
It took an average of 91.162 microseconds to run this problem through 100 iterations
*/

155
src/main/java/com/mattrixwv/project_euler/problems/Problem21.java Normal file
View File

@@ -0,0 +1,155 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem21.java
//Matthew Ellison
// Created: 03-18-19
//Modified: 08-20-22
//Evaluate the sum of all the amicable numbers under 10000
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import com.mattrixwv.ArrayAlgorithms;
import com.mattrixwv.NumberAlgorithms;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Problem21 extends Problem{
//Variables
//Static variables
private static final int LIMIT = 10000; //The number that is > the largest number to be checked
//Instance variables
private ArrayList<Integer> divisorSum; //Holds the sum of the divisors of the subscript number
private ArrayList<Integer> amicable; //Holds all amicable numbers
//Functions
//Constructor
public Problem21(){
super(String.format("Evaluate the sum of all the amicable numbers under %d", LIMIT));
divisorSum = new ArrayList<>();
amicable = new ArrayList<>();
reserveArray();
}
//Operational functions
//Reserve the size of the array to speed up insertion
private void reserveArray(){
divisorSum.ensureCapacity(LIMIT); //Reserving it now makes it faster later
//Make sure the arraylist is filled with 0's
while(divisorSum.size() < LIMIT){
divisorSum.add(0);
}
}
//Solve the problem
@Override
public void solve(){
//If the problem has already been solved do nothing and end the function
if(solved){
return;
}
//Start the timer
timer.start();
//Generate the divisors of all numbers < 10000, get their sum, and add it to the list
for(int cnt = 1;cnt < LIMIT;++cnt){
List<Integer> divisors = NumberAlgorithms.getDivisors(cnt); //Get all the divisors of a number
if(divisors.size() > 1){
divisors.remove(divisors.get(divisors.size() - 1)); //Remove the last entry because it will be the number itself
}
divisorSum.set(cnt, ArrayAlgorithms.getSum(divisors)); //Add the sum of the divisors of the vector
}
//Check every sum of divisors in the list for a matching sum
for(int cnt = 1;cnt < divisorSum.size();++cnt){
int sum = divisorSum.get(cnt);
//If the sum is greater than the number of divisors then it is impossible to be amicable. Skip the number and continue
if(sum >= divisorSum.size()){
continue;
}
//We know that divisorSum.at(cnt) == sum, so if divisorSum.at(sum) == cnt we found an amicable number
if(divisorSum.get(sum).compareTo(cnt) == 0){
//A number can't be amicable with itself
if(sum == cnt){
continue;
}
//Add it to the arraylist of amicable numbers
amicable.add(cnt);
}
}
//Sort the arraylist for neatness
Collections.sort(amicable);
//Stop the timer
timer.stop();
//Throw 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();
divisorSum.clear();
amicable.clear();
reserveArray();
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
StringBuilder result = new StringBuilder(String.format("All amicable numbers less than %d are%n", LIMIT));
for(int cnt = 0;cnt < amicable.size();++cnt){
result.append(String.format("%d%n", amicable.get(cnt)));
}
result.append(String.format("The sum of all of these amicable numbers is %d", ArrayAlgorithms.getSum(amicable)));
return result.toString();
}
//Returns a vector with all of the amicable numbers calculated
public List<Integer> getAmicable(){
solvedCheck("amicable numbers");
return amicable;
}
//Returns the sum of all of the amicable numbers
public int getSum(){
solvedCheck("sum of the amicable numbers");
return ArrayAlgorithms.getSum(amicable);
}
}
/* Results:
All amicable numbers less than 10000 are
220
284
1184
1210
2620
2924
5020
5564
6232
6368
The sum of all of these amicable numbers is 31626
It took an average of 9.848 milliseconds to run this problem through 100 iterations
*/

485
src/main/java/com/mattrixwv/project_euler/problems/Problem22.java Normal file
View File

@@ -0,0 +1,485 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem22.java
//Matthew Ellison
// Created: 03-20-19
//Modified: 08-20-22
//What is the total of all the name scores in this file?
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import com.mattrixwv.ArrayAlgorithms;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
public class Problem22 extends Problem{
//Variables
//Static variables
//Holds the names that will be scored
private static final ArrayList<String> names = new ArrayList<String>(Arrays.asList("MARY","PATRICIA","LINDA","BARBARA","ELIZABETH","JENNIFER","MARIA","SUSAN","MARGARET","DOROTHY","LISA","NANCY","KAREN",
"BETTY","HELEN","SANDRA","DONNA","CAROL","RUTH","SHARON","MICHELLE","LAURA","SARAH","KIMBERLY","DEBORAH","JESSICA","SHIRLEY",
"CYNTHIA","ANGELA","MELISSA","BRENDA","AMY","ANNA","REBECCA","VIRGINIA","KATHLEEN","PAMELA","MARTHA","DEBRA","AMANDA","STEPHANIE",
"CAROLYN","CHRISTINE","MARIE","JANET","CATHERINE","FRANCES","ANN","JOYCE","DIANE","ALICE","JULIE","HEATHER","TERESA","DORIS",
"GLORIA","EVELYN","JEAN","CHERYL","MILDRED","KATHERINE","JOAN","ASHLEY","JUDITH","ROSE","JANICE","KELLY","NICOLE","JUDY",
"CHRISTINA","KATHY","THERESA","BEVERLY","DENISE","TAMMY","IRENE","JANE","LORI","RACHEL","MARILYN","ANDREA","KATHRYN","LOUISE",
"SARA","ANNE","JACQUELINE","WANDA","BONNIE","JULIA","RUBY","LOIS","TINA","PHYLLIS","NORMA","PAULA","DIANA","ANNIE","LILLIAN",
"EMILY","ROBIN","PEGGY","CRYSTAL","GLADYS","RITA","DAWN","CONNIE","FLORENCE","TRACY","EDNA","TIFFANY","CARMEN","ROSA","CINDY",
"GRACE","WENDY","VICTORIA","EDITH","KIM","SHERRY","SYLVIA","JOSEPHINE","THELMA","SHANNON","SHEILA","ETHEL","ELLEN","ELAINE",
"MARJORIE","CARRIE","CHARLOTTE","MONICA","ESTHER","PAULINE","EMMA","JUANITA","ANITA","RHONDA","HAZEL","AMBER","EVA","DEBBIE",
"APRIL","LESLIE","CLARA","LUCILLE","JAMIE","JOANNE","ELEANOR","VALERIE","DANIELLE","MEGAN","ALICIA","SUZANNE","MICHELE","GAIL",
"BERTHA","DARLENE","VERONICA","JILL","ERIN","GERALDINE","LAUREN","CATHY","JOANN","LORRAINE","LYNN","SALLY","REGINA","ERICA",
"BEATRICE","DOLORES","BERNICE","AUDREY","YVONNE","ANNETTE","JUNE","SAMANTHA","MARION","DANA","STACY","ANA","RENEE","IDA","VIVIAN",
"ROBERTA","HOLLY","BRITTANY","MELANIE","LORETTA","YOLANDA","JEANETTE","LAURIE","KATIE","KRISTEN","VANESSA","ALMA","SUE","ELSIE",
"BETH","JEANNE","VICKI","CARLA","TARA","ROSEMARY","EILEEN","TERRI","GERTRUDE","LUCY","TONYA","ELLA","STACEY","WILMA","GINA",
"KRISTIN","JESSIE","NATALIE","AGNES","VERA","WILLIE","CHARLENE","BESSIE","DELORES","MELINDA","PEARL","ARLENE","MAUREEN","COLLEEN",
"ALLISON","TAMARA","JOY","GEORGIA","CONSTANCE","LILLIE","CLAUDIA","JACKIE","MARCIA","TANYA","NELLIE","MINNIE","MARLENE","HEIDI",
"GLENDA","LYDIA","VIOLA","COURTNEY","MARIAN","STELLA","CAROLINE","DORA","JO","VICKIE","MATTIE","TERRY","MAXINE","IRMA","MABEL",
"MARSHA","MYRTLE","LENA","CHRISTY","DEANNA","PATSY","HILDA","GWENDOLYN","JENNIE","NORA","MARGIE","NINA","CASSANDRA","LEAH","PENNY",
"KAY","PRISCILLA","NAOMI","CAROLE","BRANDY","OLGA","BILLIE","DIANNE","TRACEY","LEONA","JENNY","FELICIA","SONIA","MIRIAM","VELMA",
"BECKY","BOBBIE","VIOLET","KRISTINA","TONI","MISTY","MAE","SHELLY","DAISY","RAMONA","SHERRI","ERIKA","KATRINA","CLAIRE","LINDSEY",
"LINDSAY","GENEVA","GUADALUPE","BELINDA","MARGARITA","SHERYL","CORA","FAYE","ADA","NATASHA","SABRINA","ISABEL","MARGUERITE",
"HATTIE","HARRIET","MOLLY","CECILIA","KRISTI","BRANDI","BLANCHE","SANDY","ROSIE","JOANNA","IRIS","EUNICE","ANGIE","INEZ","LYNDA",
"MADELINE","AMELIA","ALBERTA","GENEVIEVE","MONIQUE","JODI","JANIE","MAGGIE","KAYLA","SONYA","JAN","LEE","KRISTINE","CANDACE",
"FANNIE","MARYANN","OPAL","ALISON","YVETTE","MELODY","LUZ","SUSIE","OLIVIA","FLORA","SHELLEY","KRISTY","MAMIE","LULA","LOLA",
"VERNA","BEULAH","ANTOINETTE","CANDICE","JUANA","JEANNETTE","PAM","KELLI","HANNAH","WHITNEY","BRIDGET","KARLA","CELIA","LATOYA",
"PATTY","SHELIA","GAYLE","DELLA","VICKY","LYNNE","SHERI","MARIANNE","KARA","JACQUELYN","ERMA","BLANCA","MYRA","LETICIA","PAT",
"KRISTA","ROXANNE","ANGELICA","JOHNNIE","ROBYN","FRANCIS","ADRIENNE","ROSALIE","ALEXANDRA","BROOKE","BETHANY","SADIE","BERNADETTE",
"TRACI","JODY","KENDRA","JASMINE","NICHOLE","RACHAEL","CHELSEA","MABLE","ERNESTINE","MURIEL","MARCELLA","ELENA","KRYSTAL",
"ANGELINA","NADINE","KARI","ESTELLE","DIANNA","PAULETTE","LORA","MONA","DOREEN","ROSEMARIE","ANGEL","DESIREE","ANTONIA","HOPE",
"GINGER","JANIS","BETSY","CHRISTIE","FREDA","MERCEDES","MEREDITH","LYNETTE","TERI","CRISTINA","EULA","LEIGH","MEGHAN","SOPHIA",
"ELOISE","ROCHELLE","GRETCHEN","CECELIA","RAQUEL","HENRIETTA","ALYSSA","JANA","KELLEY","GWEN","KERRY","JENNA","TRICIA","LAVERNE",
"OLIVE","ALEXIS","TASHA","SILVIA","ELVIRA","CASEY","DELIA","SOPHIE","KATE","PATTI","LORENA","KELLIE","SONJA","LILA","LANA","DARLA",
"MAY","MINDY","ESSIE","MANDY","LORENE","ELSA","JOSEFINA","JEANNIE","MIRANDA","DIXIE","LUCIA","MARTA","FAITH","LELA","JOHANNA",
"SHARI","CAMILLE","TAMI","SHAWNA","ELISA","EBONY","MELBA","ORA","NETTIE","TABITHA","OLLIE","JAIME","WINIFRED","KRISTIE","MARINA",
"ALISHA","AIMEE","RENA","MYRNA","MARLA","TAMMIE","LATASHA","BONITA","PATRICE","RONDA","SHERRIE","ADDIE","FRANCINE","DELORIS",
"STACIE","ADRIANA","CHERI","SHELBY","ABIGAIL","CELESTE","JEWEL","CARA","ADELE","REBEKAH","LUCINDA","DORTHY","CHRIS","EFFIE",
"TRINA","REBA","SHAWN","SALLIE","AURORA","LENORA","ETTA","LOTTIE","KERRI","TRISHA","NIKKI","ESTELLA","FRANCISCA","JOSIE","TRACIE",
"MARISSA","KARIN","BRITTNEY","JANELLE","LOURDES","LAUREL","HELENE","FERN","ELVA","CORINNE","KELSEY","INA","BETTIE","ELISABETH",
"AIDA","CAITLIN","INGRID","IVA","EUGENIA","CHRISTA","GOLDIE","CASSIE","MAUDE","JENIFER","THERESE","FRANKIE","DENA","LORNA",
"JANETTE","LATONYA","CANDY","MORGAN","CONSUELO","TAMIKA","ROSETTA","DEBORA","CHERIE","POLLY","DINA","JEWELL","FAY","JILLIAN",
"DOROTHEA","NELL","TRUDY","ESPERANZA","PATRICA","KIMBERLEY","SHANNA","HELENA","CAROLINA","CLEO","STEFANIE","ROSARIO","OLA",
"JANINE","MOLLIE","LUPE","ALISA","LOU","MARIBEL","SUSANNE","BETTE","SUSANA","ELISE","CECILE","ISABELLE","LESLEY","JOCELYN",
"PAIGE","JONI","RACHELLE","LEOLA","DAPHNE","ALTA","ESTER","PETRA","GRACIELA","IMOGENE","JOLENE","KEISHA","LACEY","GLENNA",
"GABRIELA","KERI","URSULA","LIZZIE","KIRSTEN","SHANA","ADELINE","MAYRA","JAYNE","JACLYN","GRACIE","SONDRA","CARMELA","MARISA",
"ROSALIND","CHARITY","TONIA","BEATRIZ","MARISOL","CLARICE","JEANINE","SHEENA","ANGELINE","FRIEDA","LILY","ROBBIE","SHAUNA",
"MILLIE","CLAUDETTE","CATHLEEN","ANGELIA","GABRIELLE","AUTUMN","KATHARINE","SUMMER","JODIE","STACI","LEA","CHRISTI","JIMMIE",
"JUSTINE","ELMA","LUELLA","MARGRET","DOMINIQUE","SOCORRO","RENE","MARTINA","MARGO","MAVIS","CALLIE","BOBBI","MARITZA","LUCILE",
"LEANNE","JEANNINE","DEANA","AILEEN","LORIE","LADONNA","WILLA","MANUELA","GALE","SELMA","DOLLY","SYBIL","ABBY","LARA","DALE",
"IVY","DEE","WINNIE","MARCY","LUISA","JERI","MAGDALENA","OFELIA","MEAGAN","AUDRA","MATILDA","LEILA","CORNELIA","BIANCA","SIMONE",
"BETTYE","RANDI","VIRGIE","LATISHA","BARBRA","GEORGINA","ELIZA","LEANN","BRIDGETTE","RHODA","HALEY","ADELA","NOLA","BERNADINE",
"FLOSSIE","ILA","GRETA","RUTHIE","NELDA","MINERVA","LILLY","TERRIE","LETHA","HILARY","ESTELA","VALARIE","BRIANNA","ROSALYN",
"EARLINE","CATALINA","AVA","MIA","CLARISSA","LIDIA","CORRINE","ALEXANDRIA","CONCEPCION","TIA","SHARRON","RAE","DONA","ERICKA",
"JAMI","ELNORA","CHANDRA","LENORE","NEVA","MARYLOU","MELISA","TABATHA","SERENA","AVIS","ALLIE","SOFIA","JEANIE","ODESSA","NANNIE",
"HARRIETT","LORAINE","PENELOPE","MILAGROS","EMILIA","BENITA","ALLYSON","ASHLEE","TANIA","TOMMIE","ESMERALDA","KARINA","EVE",
"PEARLIE","ZELMA","MALINDA","NOREEN","TAMEKA","SAUNDRA","HILLARY","AMIE","ALTHEA","ROSALINDA","JORDAN","LILIA","ALANA","GAY",
"CLARE","ALEJANDRA","ELINOR","MICHAEL","LORRIE","JERRI","DARCY","EARNESTINE","CARMELLA","TAYLOR","NOEMI","MARCIE","LIZA",
"ANNABELLE","LOUISA","EARLENE","MALLORY","CARLENE","NITA","SELENA","TANISHA","KATY","JULIANNE","JOHN","LAKISHA","EDWINA",
"MARICELA","MARGERY","KENYA","DOLLIE","ROXIE","ROSLYN","KATHRINE","NANETTE","CHARMAINE","LAVONNE","ILENE","KRIS","TAMMI",
"SUZETTE","CORINE","KAYE","JERRY","MERLE","CHRYSTAL","LINA","DEANNE","LILIAN","JULIANA","ALINE","LUANN","KASEY","MARYANNE",
"EVANGELINE","COLETTE","MELVA","LAWANDA","YESENIA","NADIA","MADGE","KATHIE","EDDIE","OPHELIA","VALERIA","NONA","MITZI","MARI",
"GEORGETTE","CLAUDINE","FRAN","ALISSA","ROSEANN","LAKEISHA","SUSANNA","REVA","DEIDRE","CHASITY","SHEREE","CARLY","JAMES","ELVIA",
"ALYCE","DEIRDRE","GENA","BRIANA","ARACELI","KATELYN","ROSANNE","WENDI","TESSA","BERTA","MARVA","IMELDA","MARIETTA","MARCI",
"LEONOR","ARLINE","SASHA","MADELYN","JANNA","JULIETTE","DEENA","AURELIA","JOSEFA","AUGUSTA","LILIANA","YOUNG","CHRISTIAN",
"LESSIE","AMALIA","SAVANNAH","ANASTASIA","VILMA","NATALIA","ROSELLA","LYNNETTE","CORINA","ALFREDA","LEANNA","CAREY","AMPARO",
"COLEEN","TAMRA","AISHA","WILDA","KARYN","CHERRY","QUEEN","MAURA","MAI","EVANGELINA","ROSANNA","HALLIE","ERNA","ENID","MARIANA",
"LACY","JULIET","JACKLYN","FREIDA","MADELEINE","MARA","HESTER","CATHRYN","LELIA","CASANDRA","BRIDGETT","ANGELITA","JANNIE",
"DIONNE","ANNMARIE","KATINA","BERYL","PHOEBE","MILLICENT","KATHERYN","DIANN","CARISSA","MARYELLEN","LIZ","LAURI","HELGA","GILDA",
"ADRIAN","RHEA","MARQUITA","HOLLIE","TISHA","TAMERA","ANGELIQUE","FRANCESCA","BRITNEY","KAITLIN","LOLITA","FLORINE","ROWENA",
"REYNA","TWILA","FANNY","JANELL","INES","CONCETTA","BERTIE","ALBA","BRIGITTE","ALYSON","VONDA","PANSY","ELBA","NOELLE","LETITIA",
"KITTY","DEANN","BRANDIE","LOUELLA","LETA","FELECIA","SHARLENE","LESA","BEVERLEY","ROBERT","ISABELLA","HERMINIA","TERRA","CELINA",
"TORI","OCTAVIA","JADE","DENICE","GERMAINE","SIERRA","MICHELL","CORTNEY","NELLY","DORETHA","SYDNEY","DEIDRA","MONIKA","LASHONDA",
"JUDI","CHELSEY","ANTIONETTE","MARGOT","BOBBY","ADELAIDE","NAN","LEEANN","ELISHA","DESSIE","LIBBY","KATHI","GAYLA","LATANYA",
"MINA","MELLISA","KIMBERLEE","JASMIN","RENAE","ZELDA","ELDA","MA","JUSTINA","GUSSIE","EMILIE","CAMILLA","ABBIE","ROCIO","KAITLYN",
"JESSE","EDYTHE","ASHLEIGH","SELINA","LAKESHA","GERI","ALLENE","PAMALA","MICHAELA","DAYNA","CARYN","ROSALIA","SUN","JACQULINE",
"REBECA","MARYBETH","KRYSTLE","IOLA","DOTTIE","BENNIE","BELLE","AUBREY","GRISELDA","ERNESTINA","ELIDA","ADRIANNE","DEMETRIA",
"DELMA","CHONG","JAQUELINE","DESTINY","ARLEEN","VIRGINA","RETHA","FATIMA","TILLIE","ELEANORE","CARI","TREVA","BIRDIE","WILHELMINA",
"ROSALEE","MAURINE","LATRICE","YONG","JENA","TARYN","ELIA","DEBBY","MAUDIE","JEANNA","DELILAH","CATRINA","SHONDA","HORTENCIA",
"THEODORA","TERESITA","ROBBIN","DANETTE","MARYJANE","FREDDIE","DELPHINE","BRIANNE","NILDA","DANNA","CINDI","BESS","IONA","HANNA",
"ARIEL","WINONA","VIDA","ROSITA","MARIANNA","WILLIAM","RACHEAL","GUILLERMINA","ELOISA","CELESTINE","CAREN","MALISSA","LONA",
"CHANTEL","SHELLIE","MARISELA","LEORA","AGATHA","SOLEDAD","MIGDALIA","IVETTE","CHRISTEN","ATHENA","JANEL","CHLOE","VEDA","PATTIE",
"TESSIE","TERA","MARILYNN","LUCRETIA","KARRIE","DINAH","DANIELA","ALECIA","ADELINA","VERNICE","SHIELA","PORTIA","MERRY","LASHAWN",
"DEVON","DARA","TAWANA","OMA","VERDA","CHRISTIN","ALENE","ZELLA","SANDI","RAFAELA","MAYA","KIRA","CANDIDA","ALVINA","SUZAN",
"SHAYLA","LYN","LETTIE","ALVA","SAMATHA","ORALIA","MATILDE","MADONNA","LARISSA","VESTA","RENITA","INDIA","DELOIS","SHANDA",
"PHILLIS","LORRI","ERLINDA","CRUZ","CATHRINE","BARB","ZOE","ISABELL","IONE","GISELA","CHARLIE","VALENCIA","ROXANNA","MAYME",
"KISHA","ELLIE","MELLISSA","DORRIS","DALIA","BELLA","ANNETTA","ZOILA","RETA","REINA","LAURETTA","KYLIE","CHRISTAL","PILAR",
"CHARLA","ELISSA","TIFFANI","TANA","PAULINA","LEOTA","BREANNA","JAYME","CARMEL","VERNELL","TOMASA","MANDI","DOMINGA","SANTA",
"MELODIE","LURA","ALEXA","TAMELA","RYAN","MIRNA","KERRIE","VENUS","NOEL","FELICITA","CRISTY","CARMELITA","BERNIECE","ANNEMARIE",
"TIARA","ROSEANNE","MISSY","CORI","ROXANA","PRICILLA","KRISTAL","JUNG","ELYSE","HAYDEE","ALETHA","BETTINA","MARGE","GILLIAN",
"FILOMENA","CHARLES","ZENAIDA","HARRIETTE","CARIDAD","VADA","UNA","ARETHA","PEARLINE","MARJORY","MARCELA","FLOR","EVETTE",
"ELOUISE","ALINA","TRINIDAD","DAVID","DAMARIS","CATHARINE","CARROLL","BELVA","NAKIA","MARLENA","LUANNE","LORINE","KARON","DORENE",
"DANITA","BRENNA","TATIANA","SAMMIE","LOUANN","LOREN","JULIANNA","ANDRIA","PHILOMENA","LUCILA","LEONORA","DOVIE","ROMONA","MIMI",
"JACQUELIN","GAYE","TONJA","MISTI","JOE","GENE","CHASTITY","STACIA","ROXANN","MICAELA","NIKITA","MEI","VELDA","MARLYS","JOHNNA",
"AURA","LAVERN","IVONNE","HAYLEY","NICKI","MAJORIE","HERLINDA","GEORGE","ALPHA","YADIRA","PERLA","GREGORIA","DANIEL","ANTONETTE",
"SHELLI","MOZELLE","MARIAH","JOELLE","CORDELIA","JOSETTE","CHIQUITA","TRISTA","LOUIS","LAQUITA","GEORGIANA","CANDI","SHANON",
"LONNIE","HILDEGARD","CECIL","VALENTINA","STEPHANY","MAGDA","KAROL","GERRY","GABRIELLA","TIANA","ROMA","RICHELLE","RAY",
"PRINCESS","OLETA","JACQUE","IDELLA","ALAINA","SUZANNA","JOVITA","BLAIR","TOSHA","RAVEN","NEREIDA","MARLYN","KYLA","JOSEPH",
"DELFINA","TENA","STEPHENIE","SABINA","NATHALIE","MARCELLE","GERTIE","DARLEEN","THEA","SHARONDA","SHANTEL","BELEN","VENESSA",
"ROSALINA","ONA","GENOVEVA","COREY","CLEMENTINE","ROSALBA","RENATE","RENATA","MI","IVORY","GEORGIANNA","FLOY","DORCAS","ARIANA",
"TYRA","THEDA","MARIAM","JULI","JESICA","DONNIE","VIKKI","VERLA","ROSELYN","MELVINA","JANNETTE","GINNY","DEBRAH","CORRIE","ASIA",
"VIOLETA","MYRTIS","LATRICIA","COLLETTE","CHARLEEN","ANISSA","VIVIANA","TWYLA","PRECIOUS","NEDRA","LATONIA","LAN","HELLEN",
"FABIOLA","ANNAMARIE","ADELL","SHARYN","CHANTAL","NIKI","MAUD","LIZETTE","LINDY","KIA","KESHA","JEANA","DANELLE","CHARLINE",
"CHANEL","CARROL","VALORIE","LIA","DORTHA","CRISTAL","SUNNY","LEONE","LEILANI","GERRI","DEBI","ANDRA","KESHIA","IMA","EULALIA",
"EASTER","DULCE","NATIVIDAD","LINNIE","KAMI","GEORGIE","CATINA","BROOK","ALDA","WINNIFRED","SHARLA","RUTHANN","MEAGHAN",
"MAGDALENE","LISSETTE","ADELAIDA","VENITA","TRENA","SHIRLENE","SHAMEKA","ELIZEBETH","DIAN","SHANTA","MICKEY","LATOSHA","CARLOTTA",
"WINDY","SOON","ROSINA","MARIANN","LEISA","JONNIE","DAWNA","CATHIE","BILLY","ASTRID","SIDNEY","LAUREEN","JANEEN","HOLLI","FAWN",
"VICKEY","TERESSA","SHANTE","RUBYE","MARCELINA","CHANDA","CARY","TERESE","SCARLETT","MARTY","MARNIE","LULU","LISETTE","JENIFFER",
"ELENOR","DORINDA","DONITA","CARMAN","BERNITA","ALTAGRACIA","ALETA","ADRIANNA","ZORAIDA","RONNIE","NICOLA","LYNDSEY","KENDALL",
"JANINA","CHRISSY","AMI","STARLA","PHYLIS","PHUONG","KYRA","CHARISSE","BLANCH","SANJUANITA","RONA","NANCI","MARILEE","MARANDA",
"CORY","BRIGETTE","SANJUANA","MARITA","KASSANDRA","JOYCELYN","IRA","FELIPA","CHELSIE","BONNY","MIREYA","LORENZA","KYONG","ILEANA",
"CANDELARIA","TONY","TOBY","SHERIE","OK","MARK","LUCIE","LEATRICE","LAKESHIA","GERDA","EDIE","BAMBI","MARYLIN","LAVON","HORTENSE",
"GARNET","EVIE","TRESSA","SHAYNA","LAVINA","KYUNG","JEANETTA","SHERRILL","SHARA","PHYLISS","MITTIE","ANABEL","ALESIA","THUY",
"TAWANDA","RICHARD","JOANIE","TIFFANIE","LASHANDA","KARISSA","ENRIQUETA","DARIA","DANIELLA","CORINNA","ALANNA","ABBEY","ROXANE",
"ROSEANNA","MAGNOLIA","LIDA","KYLE","JOELLEN","ERA","CORAL","CARLEEN","TRESA","PEGGIE","NOVELLA","NILA","MAYBELLE","JENELLE",
"CARINA","NOVA","MELINA","MARQUERITE","MARGARETTE","JOSEPHINA","EVONNE","DEVIN","CINTHIA","ALBINA","TOYA","TAWNYA","SHERITA",
"SANTOS","MYRIAM","LIZABETH","LISE","KEELY","JENNI","GISELLE","CHERYLE","ARDITH","ARDIS","ALESHA","ADRIANE","SHAINA","LINNEA",
"KAROLYN","HONG","FLORIDA","FELISHA","DORI","DARCI","ARTIE","ARMIDA","ZOLA","XIOMARA","VERGIE","SHAMIKA","NENA","NANNETTE","MAXIE",
"LOVIE","JEANE","JAIMIE","INGE","FARRAH","ELAINA","CAITLYN","STARR","FELICITAS","CHERLY","CARYL","YOLONDA","YASMIN","TEENA",
"PRUDENCE","PENNIE","NYDIA","MACKENZIE","ORPHA","MARVEL","LIZBETH","LAURETTE","JERRIE","HERMELINDA","CAROLEE","TIERRA","MIRIAN",
"META","MELONY","KORI","JENNETTE","JAMILA","ENA","ANH","YOSHIKO","SUSANNAH","SALINA","RHIANNON","JOLEEN","CRISTINE","ASHTON",
"ARACELY","TOMEKA","SHALONDA","MARTI","LACIE","KALA","JADA","ILSE","HAILEY","BRITTANI","ZONA","SYBLE","SHERRYL","RANDY","NIDIA",
"MARLO","KANDICE","KANDI","DEB","DEAN","AMERICA","ALYCIA","TOMMY","RONNA","NORENE","MERCY","JOSE","INGEBORG","GIOVANNA","GEMMA",
"CHRISTEL","AUDRY","ZORA","VITA","VAN","TRISH","STEPHAINE","SHIRLEE","SHANIKA","MELONIE","MAZIE","JAZMIN","INGA","HOA","HETTIE",
"GERALYN","FONDA","ESTRELLA","ADELLA","SU","SARITA","RINA","MILISSA","MARIBETH","GOLDA","EVON","ETHELYN","ENEDINA","CHERISE",
"CHANA","VELVA","TAWANNA","SADE","MIRTA","LI","KARIE","JACINTA","ELNA","DAVINA","CIERRA","ASHLIE","ALBERTHA","TANESHA","STEPHANI",
"NELLE","MINDI","LU","LORINDA","LARUE","FLORENE","DEMETRA","DEDRA","CIARA","CHANTELLE","ASHLY","SUZY","ROSALVA","NOELIA","LYDA",
"LEATHA","KRYSTYNA","KRISTAN","KARRI","DARLINE","DARCIE","CINDA","CHEYENNE","CHERRIE","AWILDA","ALMEDA","ROLANDA","LANETTE",
"JERILYN","GISELE","EVALYN","CYNDI","CLETA","CARIN","ZINA","ZENA","VELIA","TANIKA","PAUL","CHARISSA","THOMAS","TALIA","MARGARETE",
"LAVONDA","KAYLEE","KATHLENE","JONNA","IRENA","ILONA","IDALIA","CANDIS","CANDANCE","BRANDEE","ANITRA","ALIDA","SIGRID","NICOLETTE",
"MARYJO","LINETTE","HEDWIG","CHRISTIANA","CASSIDY","ALEXIA","TRESSIE","MODESTA","LUPITA","LITA","GLADIS","EVELIA","DAVIDA",
"CHERRI","CECILY","ASHELY","ANNABEL","AGUSTINA","WANITA","SHIRLY","ROSAURA","HULDA","EUN","BAILEY","YETTA","VERONA","THOMASINA",
"SIBYL","SHANNAN","MECHELLE","LUE","LEANDRA","LANI","KYLEE","KANDY","JOLYNN","FERNE","EBONI","CORENE","ALYSIA","ZULA","NADA",
"MOIRA","LYNDSAY","LORRETTA","JUAN","JAMMIE","HORTENSIA","GAYNELL","CAMERON","ADRIA","VINA","VICENTA","TANGELA","STEPHINE",
"NORINE","NELLA","LIANA","LESLEE","KIMBERELY","ILIANA","GLORY","FELICA","EMOGENE","ELFRIEDE","EDEN","EARTHA","CARMA","BEA","OCIE",
"MARRY","LENNIE","KIARA","JACALYN","CARLOTA","ARIELLE","YU","STAR","OTILIA","KIRSTIN","KACEY","JOHNETTA","JOEY","JOETTA",
"JERALDINE","JAUNITA","ELANA","DORTHEA","CAMI","AMADA","ADELIA","VERNITA","TAMAR","SIOBHAN","RENEA","RASHIDA","OUIDA","ODELL",
"NILSA","MERYL","KRISTYN","JULIETA","DANICA","BREANNE","AUREA","ANGLEA","SHERRON","ODETTE","MALIA","LORELEI","LIN","LEESA",
"KENNA","KATHLYN","FIONA","CHARLETTE","SUZIE","SHANTELL","SABRA","RACQUEL","MYONG","MIRA","MARTINE","LUCIENNE","LAVADA","JULIANN",
"JOHNIE","ELVERA","DELPHIA","CLAIR","CHRISTIANE","CHAROLETTE","CARRI","AUGUSTINE","ASHA","ANGELLA","PAOLA","NINFA","LEDA","LAI",
"EDA","SUNSHINE","STEFANI","SHANELL","PALMA","MACHELLE","LISSA","KECIA","KATHRYNE","KARLENE","JULISSA","JETTIE","JENNIFFER","HUI",
"CORRINA","CHRISTOPHER","CAROLANN","ALENA","TESS","ROSARIA","MYRTICE","MARYLEE","LIANE","KENYATTA","JUDIE","JANEY","IN","ELMIRA",
"ELDORA","DENNA","CRISTI","CATHI","ZAIDA","VONNIE","VIVA","VERNIE","ROSALINE","MARIELA","LUCIANA","LESLI","KARAN","FELICE",
"DENEEN","ADINA","WYNONA","TARSHA","SHERON","SHASTA","SHANITA","SHANI","SHANDRA","RANDA","PINKIE","PARIS","NELIDA","MARILOU",
"LYLA","LAURENE","LACI","JOI","JANENE","DOROTHA","DANIELE","DANI","CAROLYNN","CARLYN","BERENICE","AYESHA","ANNELIESE","ALETHEA",
"THERSA","TAMIKO","RUFINA","OLIVA","MOZELL","MARYLYN","MADISON","KRISTIAN","KATHYRN","KASANDRA","KANDACE","JANAE","GABRIEL",
"DOMENICA","DEBBRA","DANNIELLE","CHUN","BUFFY","BARBIE","ARCELIA","AJA","ZENOBIA","SHAREN","SHAREE","PATRICK","PAGE","MY",
"LAVINIA","KUM","KACIE","JACKELINE","HUONG","FELISA","EMELIA","ELEANORA","CYTHIA","CRISTIN","CLYDE","CLARIBEL","CARON",
"ANASTACIA","ZULMA","ZANDRA","YOKO","TENISHA","SUSANN","SHERILYN","SHAY","SHAWANDA","SABINE","ROMANA","MATHILDA","LINSEY",
"KEIKO","JOANA","ISELA","GRETTA","GEORGETTA","EUGENIE","DUSTY","DESIRAE","DELORA","CORAZON","ANTONINA","ANIKA","WILLENE","TRACEE",
"TAMATHA","REGAN","NICHELLE","MICKIE","MAEGAN","LUANA","LANITA","KELSIE","EDELMIRA","BREE","AFTON","TEODORA","TAMIE","SHENA",
"MEG","LINH","KELI","KACI","DANYELLE","BRITT","ARLETTE","ALBERTINE","ADELLE","TIFFINY","STORMY","SIMONA","NUMBERS","NICOLASA",
"NICHOL","NIA","NAKISHA","MEE","MAIRA","LOREEN","KIZZY","JOHNNY","JAY","FALLON","CHRISTENE","BOBBYE","ANTHONY","YING","VINCENZA",
"TANJA","RUBIE","RONI","QUEENIE","MARGARETT","KIMBERLI","IRMGARD","IDELL","HILMA","EVELINA","ESTA","EMILEE","DENNISE","DANIA",
"CARL","CARIE","ANTONIO","WAI","SANG","RISA","RIKKI","PARTICIA","MUI","MASAKO","MARIO","LUVENIA","LOREE","LONI","LIEN","KEVIN",
"GIGI","FLORENCIA","DORIAN","DENITA","DALLAS","CHI","BILLYE","ALEXANDER","TOMIKA","SHARITA","RANA","NIKOLE","NEOMA","MARGARITE",
"MADALYN","LUCINA","LAILA","KALI","JENETTE","GABRIELE","EVELYNE","ELENORA","CLEMENTINA","ALEJANDRINA","ZULEMA","VIOLETTE",
"VANNESSA","THRESA","RETTA","PIA","PATIENCE","NOELLA","NICKIE","JONELL","DELTA","CHUNG","CHAYA","CAMELIA","BETHEL","ANYA",
"ANDREW","THANH","SUZANN","SPRING","SHU","MILA","LILLA","LAVERNA","KEESHA","KATTIE","GIA","GEORGENE","EVELINE","ESTELL","ELIZBETH",
"VIVIENNE","VALLIE","TRUDIE","STEPHANE","MICHEL","MAGALY","MADIE","KENYETTA","KARREN","JANETTA","HERMINE","HARMONY","DRUCILLA",
"DEBBI","CELESTINA","CANDIE","BRITNI","BECKIE","AMINA","ZITA","YUN","YOLANDE","VIVIEN","VERNETTA","TRUDI","SOMMER","PEARLE",
"PATRINA","OSSIE","NICOLLE","LOYCE","LETTY","LARISA","KATHARINA","JOSELYN","JONELLE","JENELL","IESHA","HEIDE","FLORINDA",
"FLORENTINA","FLO","ELODIA","DORINE","BRUNILDA","BRIGID","ASHLI","ARDELLA","TWANA","THU","TARAH","SUNG","SHEA","SHAVON","SHANE",
"SERINA","RAYNA","RAMONITA","NGA","MARGURITE","LUCRECIA","KOURTNEY","KATI","JESUS","JESENIA","DIAMOND","CRISTA","AYANA","ALICA",
"ALIA","VINNIE","SUELLEN","ROMELIA","RACHELL","PIPER","OLYMPIA","MICHIKO","KATHALEEN","JOLIE","JESSI","JANESSA","HANA","HA",
"ELEASE","CARLETTA","BRITANY","SHONA","SALOME","ROSAMOND","REGENA","RAINA","NGOC","NELIA","LOUVENIA","LESIA","LATRINA","LATICIA",
"LARHONDA","JINA","JACKI","HOLLIS","HOLLEY","EMMY","DEEANN","CORETTA","ARNETTA","VELVET","THALIA","SHANICE","NETA","MIKKI","MICKI",
"LONNA","LEANA","LASHUNDA","KILEY","JOYE","JACQULYN","IGNACIA","HYUN","HIROKO","HENRY","HENRIETTE","ELAYNE","DELINDA","DARNELL",
"DAHLIA","COREEN","CONSUELA","CONCHITA","CELINE","BABETTE","AYANNA","ANETTE","ALBERTINA","SKYE","SHAWNEE","SHANEKA","QUIANA",
"PAMELIA","MIN","MERRI","MERLENE","MARGIT","KIESHA","KIERA","KAYLENE","JODEE","JENISE","ERLENE","EMMIE","ELSE","DARYL","DALILA",
"DAISEY","CODY","CASIE","BELIA","BABARA","VERSIE","VANESA","SHELBA","SHAWNDA","SAM","NORMAN","NIKIA","NAOMA","MARNA","MARGERET",
"MADALINE","LAWANA","KINDRA","JUTTA","JAZMINE","JANETT","HANNELORE","GLENDORA","GERTRUD","GARNETT","FREEDA","FREDERICA","FLORANCE",
"FLAVIA","DENNIS","CARLINE","BEVERLEE","ANJANETTE","VALDA","TRINITY","TAMALA","STEVIE","SHONNA","SHA","SARINA","ONEIDA","MICAH",
"MERILYN","MARLEEN","LURLINE","LENNA","KATHERIN","JIN","JENI","HAE","GRACIA","GLADY","FARAH","ERIC","ENOLA","EMA","DOMINQUE",
"DEVONA","DELANA","CECILA","CAPRICE","ALYSHA","ALI","ALETHIA","VENA","THERESIA","TAWNY","SONG","SHAKIRA","SAMARA","SACHIKO",
"RACHELE","PAMELLA","NICKY","MARNI","MARIEL","MAREN","MALISA","LIGIA","LERA","LATORIA","LARAE","KIMBER","KATHERN","KAREY",
"JENNEFER","JANETH","HALINA","FREDIA","DELISA","DEBROAH","CIERA","CHIN","ANGELIKA","ANDREE","ALTHA","YEN","VIVAN","TERRESA",
"TANNA","SUK","SUDIE","SOO","SIGNE","SALENA","RONNI","REBBECCA","MYRTIE","MCKENZIE","MALIKA","MAIDA","LOAN","LEONARDA","KAYLEIGH",
"FRANCE","ETHYL","ELLYN","DAYLE","CAMMIE","BRITTNI","BIRGIT","AVELINA","ASUNCION","ARIANNA","AKIKO","VENICE","TYESHA","TONIE",
"TIESHA","TAKISHA","STEFFANIE","SINDY","SANTANA","MEGHANN","MANDA","MACIE","LADY","KELLYE","KELLEE","JOSLYN","JASON","INGER",
"INDIRA","GLINDA","GLENNIS","FERNANDA","FAUSTINA","ENEIDA","ELICIA","DOT","DIGNA","DELL","ARLETTA","ANDRE","WILLIA","TAMMARA",
"TABETHA","SHERRELL","SARI","REFUGIO","REBBECA","PAULETTA","NIEVES","NATOSHA","NAKITA","MAMMIE","KENISHA","KAZUKO","KASSIE",
"GARY","EARLEAN","DAPHINE","CORLISS","CLOTILDE","CAROLYNE","BERNETTA","AUGUSTINA","AUDREA","ANNIS","ANNABELL","YAN","TENNILLE",
"TAMICA","SELENE","SEAN","ROSANA","REGENIA","QIANA","MARKITA","MACY","LEEANNE","LAURINE","KYM","JESSENIA","JANITA","GEORGINE",
"GENIE","EMIKO","ELVIE","DEANDRA","DAGMAR","CORIE","COLLEN","CHERISH","ROMAINE","PORSHA","PEARLENE","MICHELINE","MERNA","MARGORIE",
"MARGARETTA","LORE","KENNETH","JENINE","HERMINA","FREDERICKA","ELKE","DRUSILLA","DORATHY","DIONE","DESIRE","CELENA","BRIGIDA",
"ANGELES","ALLEGRA","THEO","TAMEKIA","SYNTHIA","STEPHEN","SOOK","SLYVIA","ROSANN","REATHA","RAYE","MARQUETTA","MARGART","LING",
"LAYLA","KYMBERLY","KIANA","KAYLEEN","KATLYN","KARMEN","JOELLA","IRINA","EMELDA","ELENI","DETRA","CLEMMIE","CHERYLL","CHANTELL",
"CATHEY","ARNITA","ARLA","ANGLE","ANGELIC","ALYSE","ZOFIA","THOMASINE","TENNIE","SON","SHERLY","SHERLEY","SHARYL","REMEDIOS",
"PETRINA","NICKOLE","MYUNG","MYRLE","MOZELLA","LOUANNE","LISHA","LATIA","LANE","KRYSTA","JULIENNE","JOEL","JEANENE","JACQUALINE",
"ISAURA","GWENDA","EARLEEN","DONALD","CLEOPATRA","CARLIE","AUDIE","ANTONIETTA","ALISE","ALEX","VERDELL","VAL","TYLER","TOMOKO",
"THAO","TALISHA","STEVEN","SO","SHEMIKA","SHAUN","SCARLET","SAVANNA","SANTINA","ROSIA","RAEANN","ODILIA","NANA","MINNA","MAGAN",
"LYNELLE","LE","KARMA","JOEANN","IVANA","INELL","ILANA","HYE","HONEY","HEE","GUDRUN","FRANK","DREAMA","CRISSY","CHANTE",
"CARMELINA","ARVILLA","ARTHUR","ANNAMAE","ALVERA","ALEIDA","AARON","YEE","YANIRA","VANDA","TIANNA","TAM","STEFANIA","SHIRA",
"PERRY","NICOL","NANCIE","MONSERRATE","MINH","MELYNDA","MELANY","MATTHEW","LOVELLA","LAURE","KIRBY","KACY","JACQUELYNN","HYON",
"GERTHA","FRANCISCO","ELIANA","CHRISTENA","CHRISTEEN","CHARISE","CATERINA","CARLEY","CANDYCE","ARLENA","AMMIE","YANG","WILLETTE",
"VANITA","TUYET","TINY","SYREETA","SILVA","SCOTT","RONALD","PENNEY","NYLA","MICHAL","MAURICE","MARYAM","MARYA","MAGEN","LUDIE",
"LOMA","LIVIA","LANELL","KIMBERLIE","JULEE","DONETTA","DIEDRA","DENISHA","DEANE","DAWNE","CLARINE","CHERRYL","BRONWYN","BRANDON",
"ALLA","VALERY","TONDA","SUEANN","SORAYA","SHOSHANA","SHELA","SHARLEEN","SHANELLE","NERISSA","MICHEAL","MERIDITH","MELLIE","MAYE",
"MAPLE","MAGARET","LUIS","LILI","LEONILA","LEONIE","LEEANNA","LAVONIA","LAVERA","KRISTEL","KATHEY","KATHE","JUSTIN","JULIAN",
"JIMMY","JANN","ILDA","HILDRED","HILDEGARDE","GENIA","FUMIKO","EVELIN","ERMELINDA","ELLY","DUNG","DOLORIS","DIONNA","DANAE",
"BERNEICE","ANNICE","ALIX","VERENA","VERDIE","TRISTAN","SHAWNNA","SHAWANA","SHAUNNA","ROZELLA","RANDEE","RANAE","MILAGRO",
"LYNELL","LUISE","LOUIE","LOIDA","LISBETH","KARLEEN","JUNITA","JONA","ISIS","HYACINTH","HEDY","GWENN","ETHELENE","ERLINE",
"EDWARD","DONYA","DOMONIQUE","DELICIA","DANNETTE","CICELY","BRANDA","BLYTHE","BETHANN","ASHLYN","ANNALEE","ALLINE","YUKO","VELLA",
"TRANG","TOWANDA","TESHA","SHERLYN","NARCISA","MIGUELINA","MERI","MAYBELL","MARLANA","MARGUERITA","MADLYN","LUNA","LORY",
"LORIANN","LIBERTY","LEONORE","LEIGHANN","LAURICE","LATESHA","LARONDA","KATRICE","KASIE","KARL","KALEY","JADWIGA","GLENNIE",
"GEARLDINE","FRANCINA","EPIFANIA","DYAN","DORIE","DIEDRE","DENESE","DEMETRICE","DELENA","DARBY","CRISTIE","CLEORA","CATARINA",
"CARISA","BERNIE","BARBERA","ALMETA","TRULA","TEREASA","SOLANGE","SHEILAH","SHAVONNE","SANORA","ROCHELL","MATHILDE","MARGARETA",
"MAIA","LYNSEY","LAWANNA","LAUNA","KENA","KEENA","KATIA","JAMEY","GLYNDA","GAYLENE","ELVINA","ELANOR","DANUTA","DANIKA","CRISTEN",
"CORDIE","COLETTA","CLARITA","CARMON","BRYNN","AZUCENA","AUNDREA","ANGELE","YI","WALTER","VERLIE","VERLENE","TAMESHA","SILVANA",
"SEBRINA","SAMIRA","REDA","RAYLENE","PENNI","PANDORA","NORAH","NOMA","MIREILLE","MELISSIA","MARYALICE","LARAINE","KIMBERY",
"KARYL","KARINE","KAM","JOLANDA","JOHANA","JESUSA","JALEESA","JAE","JACQUELYNE","IRISH","ILUMINADA","HILARIA","HANH","GENNIE",
"FRANCIE","FLORETTA","EXIE","EDDA","DREMA","DELPHA","BEV","BARBAR","ASSUNTA","ARDELL","ANNALISA","ALISIA","YUKIKO","YOLANDO",
"WONDA","WEI","WALTRAUD","VETA","TEQUILA","TEMEKA","TAMEIKA","SHIRLEEN","SHENITA","PIEDAD","OZELLA","MIRTHA","MARILU","KIMIKO",
"JULIANE","JENICE","JEN","JANAY","JACQUILINE","HILDE","FE","FAE","EVAN","EUGENE","ELOIS","ECHO","DEVORAH","CHAU","BRINDA",
"BETSEY","ARMINDA","ARACELIS","APRYL","ANNETT","ALISHIA","VEOLA","USHA","TOSHIKO","THEOLA","TASHIA","TALITHA","SHERY","RUDY",
"RENETTA","REIKO","RASHEEDA","OMEGA","OBDULIA","MIKA","MELAINE","MEGGAN","MARTIN","MARLEN","MARGET","MARCELINE","MANA","MAGDALEN",
"LIBRADA","LEZLIE","LEXIE","LATASHIA","LASANDRA","KELLE","ISIDRA","ISA","INOCENCIA","GWYN","FRANCOISE","ERMINIA","ERINN","DIMPLE",
"DEVORA","CRISELDA","ARMANDA","ARIE","ARIANE","ANGELO","ANGELENA","ALLEN","ALIZA","ADRIENE","ADALINE","XOCHITL","TWANNA","TRAN",
"TOMIKO","TAMISHA","TAISHA","SUSY","SIU","RUTHA","ROXY","RHONA","RAYMOND","OTHA","NORIKO","NATASHIA","MERRIE","MELVIN","MARINDA",
"MARIKO","MARGERT","LORIS","LIZZETTE","LEISHA","KAILA","KA","JOANNIE","JERRICA","JENE","JANNET","JANEE","JACINDA","HERTA",
"ELENORE","DORETTA","DELAINE","DANIELL","CLAUDIE","CHINA","BRITTA","APOLONIA","AMBERLY","ALEASE","YURI","YUK","WEN","WANETA",
"UTE","TOMI","SHARRI","SANDIE","ROSELLE","REYNALDA","RAGUEL","PHYLICIA","PATRIA","OLIMPIA","ODELIA","MITZIE","MITCHELL","MISS",
"MINDA","MIGNON","MICA","MENDY","MARIVEL","MAILE","LYNETTA","LAVETTE","LAURYN","LATRISHA","LAKIESHA","KIERSTEN","KARY","JOSPHINE",
"JOLYN","JETTA","JANISE","JACQUIE","IVELISSE","GLYNIS","GIANNA","GAYNELLE","EMERALD","DEMETRIUS","DANYELL","DANILLE","DACIA",
"CORALEE","CHER","CEOLA","BRETT","BELL","ARIANNE","ALESHIA","YUNG","WILLIEMAE","TROY","TRINH","THORA","TAI","SVETLANA","SHERIKA",
"SHEMEKA","SHAUNDA","ROSELINE","RICKI","MELDA","MALLIE","LAVONNA","LATINA","LARRY","LAQUANDA","LALA","LACHELLE","KLARA","KANDIS",
"JOHNA","JEANMARIE","JAYE","HANG","GRAYCE","GERTUDE","EMERITA","EBONIE","CLORINDA","CHING","CHERY","CAROLA","BREANN","BLOSSOM",
"BERNARDINE","BECKI","ARLETHA","ARGELIA","ARA","ALITA","YULANDA","YON","YESSENIA","TOBI","TASIA","SYLVIE","SHIRL","SHIRELY",
"SHERIDAN","SHELLA","SHANTELLE","SACHA","ROYCE","REBECKA","REAGAN","PROVIDENCIA","PAULENE","MISHA","MIKI","MARLINE","MARICA",
"LORITA","LATOYIA","LASONYA","KERSTIN","KENDA","KEITHA","KATHRIN","JAYMIE","JACK","GRICELDA","GINETTE","ERYN","ELINA","ELFRIEDA",
"DANYEL","CHEREE","CHANELLE","BARRIE","AVERY","AURORE","ANNAMARIA","ALLEEN","AILENE","AIDE","YASMINE","VASHTI","VALENTINE",
"TREASA","TORY","TIFFANEY","SHERYLL","SHARIE","SHANAE","SAU","RAISA","PA","NEDA","MITSUKO","MIRELLA","MILDA","MARYANNA","MARAGRET",
"MABELLE","LUETTA","LORINA","LETISHA","LATARSHA","LANELLE","LAJUANA","KRISSY","KARLY","KARENA","JON","JESSIKA","JERICA","JEANELLE",
"JANUARY","JALISA","JACELYN","IZOLA","IVEY","GREGORY","EUNA","ETHA","DREW","DOMITILA","DOMINICA","DAINA","CREOLA","CARLI","CAMIE",
"BUNNY","BRITTNY","ASHANTI","ANISHA","ALEEN","ADAH","YASUKO","WINTER","VIKI","VALRIE","TONA","TINISHA","THI","TERISA","TATUM",
"TANEKA","SIMONNE","SHALANDA","SERITA","RESSIE","REFUGIA","PAZ","OLENE","NA","MERRILL","MARGHERITA","MANDIE","MAN","MAIRE",
"LYNDIA","LUCI","LORRIANE","LORETA","LEONIA","LAVONA","LASHAWNDA","LAKIA","KYOKO","KRYSTINA","KRYSTEN","KENIA","KELSI","JUDE",
"JEANICE","ISOBEL","GEORGIANN","GENNY","FELICIDAD","EILENE","DEON","DELOISE","DEEDEE","DANNIE","CONCEPTION","CLORA","CHERILYN",
"CHANG","CALANDRA","BERRY","ARMANDINA","ANISA","ULA","TIMOTHY","TIERA","THERESSA","STEPHANIA","SIMA","SHYLA","SHONTA","SHERA",
"SHAQUITA","SHALA","SAMMY","ROSSANA","NOHEMI","NERY","MORIAH","MELITA","MELIDA","MELANI","MARYLYNN","MARISHA","MARIETTE","MALORIE",
"MADELENE","LUDIVINA","LORIA","LORETTE","LORALEE","LIANNE","LEON","LAVENIA","LAURINDA","LASHON","KIT","KIMI","KEILA","KATELYNN",
"KAI","JONE","JOANE","JI","JAYNA","JANELLA","JA","HUE","HERTHA","FRANCENE","ELINORE","DESPINA","DELSIE","DEEDRA","CLEMENCIA",
"CARRY","CAROLIN","CARLOS","BULAH","BRITTANIE","BOK","BLONDELL","BIBI","BEAULAH","BEATA","ANNITA","AGRIPINA","VIRGEN","VALENE",
"UN","TWANDA","TOMMYE","TOI","TARRA","TARI","TAMMERA","SHAKIA","SADYE","RUTHANNE","ROCHEL","RIVKA","PURA","NENITA","NATISHA",
"MING","MERRILEE","MELODEE","MARVIS","LUCILLA","LEENA","LAVETA","LARITA","LANIE","KEREN","ILEEN","GEORGEANN","GENNA","GENESIS",
"FRIDA","EWA","EUFEMIA","EMELY","ELA","EDYTH","DEONNA","DEADRA","DARLENA","CHANELL","CHAN","CATHERN","CASSONDRA","CASSAUNDRA",
"BERNARDA","BERNA","ARLINDA","ANAMARIA","ALBERT","WESLEY","VERTIE","VALERI","TORRI","TATYANA","STASIA","SHERISE","SHERILL",
"SEASON","SCOTTIE","SANDA","RUTHE","ROSY","ROBERTO","ROBBI","RANEE","QUYEN","PEARLY","PALMIRA","ONITA","NISHA","NIESHA","NIDA",
"NEVADA","NAM","MERLYN","MAYOLA","MARYLOUISE","MARYLAND","MARX","MARTH","MARGENE","MADELAINE","LONDA","LEONTINE","LEOMA","LEIA",
"LAWRENCE","LAURALEE","LANORA","LAKITA","KIYOKO","KETURAH","KATELIN","KAREEN","JONIE","JOHNETTE","JENEE","JEANETT","IZETTA",
"HIEDI","HEIKE","HASSIE","HAROLD","GIUSEPPINA","GEORGANN","FIDELA","FERNANDE","ELWANDA","ELLAMAE","ELIZ","DUSTI","DOTTY","CYNDY",
"CORALIE","CELESTA","ARGENTINA","ALVERTA","XENIA","WAVA","VANETTA","TORRIE","TASHINA","TANDY","TAMBRA","TAMA","STEPANIE","SHILA",
"SHAUNTA","SHARAN","SHANIQUA","SHAE","SETSUKO","SERAFINA","SANDEE","ROSAMARIA","PRISCILA","OLINDA","NADENE","MUOI","MICHELINA",
"MERCEDEZ","MARYROSE","MARIN","MARCENE","MAO","MAGALI","MAFALDA","LOGAN","LINN","LANNIE","KAYCE","KAROLINE","KAMILAH","KAMALA",
"JUSTA","JOLINE","JENNINE","JACQUETTA","IRAIDA","GERALD","GEORGEANNA","FRANCHESCA","FAIRY","EMELINE","ELANE","EHTEL","EARLIE",
"DULCIE","DALENE","CRIS","CLASSIE","CHERE","CHARIS","CAROYLN","CARMINA","CARITA","BRIAN","BETHANIE","AYAKO","ARICA","AN","ALYSA",
"ALESSANDRA","AKILAH","ADRIEN","ZETTA","YOULANDA","YELENA","YAHAIRA","XUAN","WENDOLYN","VICTOR","TIJUANA","TERRELL","TERINA",
"TERESIA","SUZI","SUNDAY","SHERELL","SHAVONDA","SHAUNTE","SHARDA","SHAKITA","SENA","RYANN","RUBI","RIVA","REGINIA","REA","RACHAL",
"PARTHENIA","PAMULA","MONNIE","MONET","MICHAELE","MELIA","MARINE","MALKA","MAISHA","LISANDRA","LEO","LEKISHA","LEAN","LAURENCE",
"LAKENDRA","KRYSTIN","KORTNEY","KIZZIE","KITTIE","KERA","KENDAL","KEMBERLY","KANISHA","JULENE","JULE","JOSHUA","JOHANNE","JEFFREY",
"JAMEE","HAN","HALLEY","GIDGET","GALINA","FREDRICKA","FLETA","FATIMAH","EUSEBIA","ELZA","ELEONORE","DORTHEY","DORIA","DONELLA",
"DINORAH","DELORSE","CLARETHA","CHRISTINIA","CHARLYN","BONG","BELKIS","AZZIE","ANDERA","AIKO","ADENA","YER","YAJAIRA","WAN",
"VANIA","ULRIKE","TOSHIA","TIFANY","STEFANY","SHIZUE","SHENIKA","SHAWANNA","SHAROLYN","SHARILYN","SHAQUANA","SHANTAY","SEE",
"ROZANNE","ROSELEE","RICKIE","REMONA","REANNA","RAELENE","QUINN","PHUNG","PETRONILA","NATACHA","NANCEY","MYRL","MIYOKO","MIESHA",
"MERIDETH","MARVELLA","MARQUITTA","MARHTA","MARCHELLE","LIZETH","LIBBIE","LAHOMA","LADAWN","KINA","KATHELEEN","KATHARYN","KARISA",
"KALEIGH","JUNIE","JULIEANN","JOHNSIE","JANEAN","JAIMEE","JACKQUELINE","HISAKO","HERMA","HELAINE","GWYNETH","GLENN","GITA",
"EUSTOLIA","EMELINA","ELIN","EDRIS","DONNETTE","DONNETTA","DIERDRE","DENAE","DARCEL","CLAUDE","CLARISA","CINDERELLA","CHIA",
"CHARLESETTA","CHARITA","CELSA","CASSY","CASSI","CARLEE","BRUNA","BRITTANEY","BRANDE","BILLI","BAO","ANTONETTA","ANGLA","ANGELYN",
"ANALISA","ALANE","WENONA","WENDIE","VERONIQUE","VANNESA","TOBIE","TEMPIE","SUMIKO","SULEMA","SPARKLE","SOMER","SHEBA","SHAYNE",
"SHARICE","SHANEL","SHALON","SAGE","ROY","ROSIO","ROSELIA","RENAY","REMA","REENA","PORSCHE","PING","PEG","OZIE","ORETHA","ORALEE",
"ODA","NU","NGAN","NAKESHA","MILLY","MARYBELLE","MARLIN","MARIS","MARGRETT","MARAGARET","MANIE","LURLENE","LILLIA","LIESELOTTE",
"LAVELLE","LASHAUNDA","LAKEESHA","KEITH","KAYCEE","KALYN","JOYA","JOETTE","JENAE","JANIECE","ILLA","GRISEL","GLAYDS","GENEVIE",
"GALA","FREDDA","FRED","ELMER","ELEONOR","DEBERA","DEANDREA","DAN","CORRINNE","CORDIA","CONTESSA","COLENE","CLEOTILDE","CHARLOTT",
"CHANTAY","CECILLE","BEATRIS","AZALEE","ARLEAN","ARDATH","ANJELICA","ANJA","ALFREDIA","ALEISHA","ADAM","ZADA","YUONNE","XIAO",
"WILLODEAN","WHITLEY","VENNIE","VANNA","TYISHA","TOVA","TORIE","TONISHA","TILDA","TIEN","TEMPLE","SIRENA","SHERRIL","SHANTI",
"SHAN","SENAIDA","SAMELLA","ROBBYN","RENDA","REITA","PHEBE","PAULITA","NOBUKO","NGUYET","NEOMI","MOON","MIKAELA","MELANIA",
"MAXIMINA","MARG","MAISIE","LYNNA","LILLI","LAYNE","LASHAUN","LAKENYA","LAEL","KIRSTIE","KATHLINE","KASHA","KARLYN","KARIMA",
"JOVAN","JOSEFINE","JENNELL","JACQUI","JACKELYN","HYO","HIEN","GRAZYNA","FLORRIE","FLORIA","ELEONORA","DWANA","DORLA","DONG",
"DELMY","DEJA","DEDE","DANN","CRYSTA","CLELIA","CLARIS","CLARENCE","CHIEKO","CHERLYN","CHERELLE","CHARMAIN","CHARA","CAMMY","BEE",
"ARNETTE","ARDELLE","ANNIKA","AMIEE","AMEE","ALLENA","YVONE","YUKI","YOSHIE","YEVETTE","YAEL","WILLETTA","VONCILE","VENETTA",
"TULA","TONETTE","TIMIKA","TEMIKA","TELMA","TEISHA","TAREN","TA","STACEE","SHIN","SHAWNTA","SATURNINA","RICARDA","POK","PASTY",
"ONIE","NUBIA","MORA","MIKE","MARIELLE","MARIELLA","MARIANELA","MARDELL","MANY","LUANNA","LOISE","LISABETH","LINDSY","LILLIANA",
"LILLIAM","LELAH","LEIGHA","LEANORA","LANG","KRISTEEN","KHALILAH","KEELEY","KANDRA","JUNKO","JOAQUINA","JERLENE","JANI","JAMIKA",
"JAME","HSIU","HERMILA","GOLDEN","GENEVIVE","EVIA","EUGENA","EMMALINE","ELFREDA","ELENE","DONETTE","DELCIE","DEEANNA","DARCEY",
"CUC","CLARINDA","CIRA","CHAE","CELINDA","CATHERYN","CATHERIN","CASIMIRA","CARMELIA","CAMELLIA","BREANA","BOBETTE","BERNARDINA",
"BEBE","BASILIA","ARLYNE","AMAL","ALAYNA","ZONIA","ZENIA","YURIKO","YAEKO","WYNELL","WILLOW","WILLENA","VERNIA","TU","TRAVIS",
"TORA","TERRILYN","TERICA","TENESHA","TAWNA","TAJUANA","TAINA","STEPHNIE","SONA","SOL","SINA","SHONDRA","SHIZUKO","SHERLENE",
"SHERICE","SHARIKA","ROSSIE","ROSENA","RORY","RIMA","RIA","RHEBA","RENNA","PETER","NATALYA","NANCEE","MELODI","MEDA","MAXIMA",
"MATHA","MARKETTA","MARICRUZ","MARCELENE","MALVINA","LUBA","LOUETTA","LEIDA","LECIA","LAURAN","LASHAWNA","LAINE","KHADIJAH",
"KATERINE","KASI","KALLIE","JULIETTA","JESUSITA","JESTINE","JESSIA","JEREMY","JEFFIE","JANYCE","ISADORA","GEORGIANNE","FIDELIA",
"EVITA","EURA","EULAH","ESTEFANA","ELSY","ELIZABET","ELADIA","DODIE","DION","DIA","DENISSE","DELORAS","DELILA","DAYSI","DAKOTA",
"CURTIS","CRYSTLE","CONCHA","COLBY","CLARETTA","CHU","CHRISTIA","CHARLSIE","CHARLENA","CARYLON","BETTYANN","ASLEY","ASHLEA",
"AMIRA","AI","AGUEDA","AGNUS","YUETTE","VINITA","VICTORINA","TYNISHA","TREENA","TOCCARA","TISH","THOMASENA","TEGAN","SOILA",
"SHILOH","SHENNA","SHARMAINE","SHANTAE","SHANDI","SEPTEMBER","SARAN","SARAI","SANA","SAMUEL","SALLEY","ROSETTE","ROLANDE","REGINE",
"OTELIA","OSCAR","OLEVIA","NICHOLLE","NECOLE","NAIDA","MYRTA","MYESHA","MITSUE","MINTA","MERTIE","MARGY","MAHALIA","MADALENE",
"LOVE","LOURA","LOREAN","LEWIS","LESHA","LEONIDA","LENITA","LAVONE","LASHELL","LASHANDRA","LAMONICA","KIMBRA","KATHERINA","KARRY",
"KANESHA","JULIO","JONG","JENEVA","JAQUELYN","HWA","GILMA","GHISLAINE","GERTRUDIS","FRANSISCA","FERMINA","ETTIE","ETSUKO","ELLIS",
"ELLAN","ELIDIA","EDRA","DORETHEA","DOREATHA","DENYSE","DENNY","DEETTA","DAINE","CYRSTAL","CORRIN","CAYLA","CARLITA","CAMILA",
"BURMA","BULA","BUENA","BLAKE","BARABARA","AVRIL","AUSTIN","ALAINE","ZANA","WILHEMINA","WANETTA","VIRGIL","VI","VERONIKA","VERNON",
"VERLINE","VASILIKI","TONITA","TISA","TEOFILA","TAYNA","TAUNYA","TANDRA","TAKAKO","SUNNI","SUANNE","SIXTA","SHARELL","SEEMA",
"RUSSELL","ROSENDA","ROBENA","RAYMONDE","PEI","PAMILA","OZELL","NEIDA","NEELY","MISTIE","MICHA","MERISSA","MAURITA","MARYLN",
"MARYETTA","MARSHALL","MARCELL","MALENA","MAKEDA","MADDIE","LOVETTA","LOURIE","LORRINE","LORILEE","LESTER","LAURENA","LASHAY",
"LARRAINE","LAREE","LACRESHA","KRISTLE","KRISHNA","KEVA","KEIRA","KAROLE","JOIE","JINNY","JEANNETTA","JAMA","HEIDY","GILBERTE",
"GEMA","FAVIOLA","EVELYNN","ENDA","ELLI","ELLENA","DIVINA","DAGNY","COLLENE","CODI","CINDIE","CHASSIDY","CHASIDY","CATRICE",
"CATHERINA","CASSEY","CAROLL","CARLENA","CANDRA","CALISTA","BRYANNA","BRITTENY","BEULA","BARI","AUDRIE","AUDRIA","ARDELIA",
"ANNELLE","ANGILA","ALONA","ALLYN","DOUGLAS","ROGER","JONATHAN","RALPH","NICHOLAS","BENJAMIN","BRUCE","HARRY","WAYNE","STEVE",
"HOWARD","ERNEST","PHILLIP","TODD","CRAIG","ALAN","PHILIP","EARL","DANNY","BRYAN","STANLEY","LEONARD","NATHAN","MANUEL","RODNEY",
"MARVIN","VINCENT","JEFFERY","JEFF","CHAD","JACOB","ALFRED","BRADLEY","HERBERT","FREDERICK","EDWIN","DON","RICKY","RANDALL",
"BARRY","BERNARD","LEROY","MARCUS","THEODORE","CLIFFORD","MIGUEL","JIM","TOM","CALVIN","BILL","LLOYD","DEREK","WARREN","DARRELL",
"JEROME","FLOYD","ALVIN","TIM","GORDON","GREG","JORGE","DUSTIN","PEDRO","DERRICK","ZACHARY","HERMAN","GLEN","HECTOR","RICARDO",
"RICK","BRENT","RAMON","GILBERT","MARC","REGINALD","RUBEN","NATHANIEL","RAFAEL","EDGAR","MILTON","RAUL","BEN","CHESTER","DUANE",
"FRANKLIN","BRAD","RON","ROLAND","ARNOLD","HARVEY","JARED","ERIK","DARRYL","NEIL","JAVIER","FERNANDO","CLINTON","TED","MATHEW",
"TYRONE","DARREN","LANCE","KURT","ALLAN","NELSON","GUY","CLAYTON","HUGH","MAX","DWAYNE","DWIGHT","ARMANDO","FELIX","EVERETT",
"IAN","WALLACE","KEN","BOB","ALFREDO","ALBERTO","DAVE","IVAN","BYRON","ISAAC","MORRIS","CLIFTON","WILLARD","ROSS","ANDY",
"SALVADOR","KIRK","SERGIO","SETH","KENT","TERRANCE","EDUARDO","TERRENCE","ENRIQUE","WADE","STUART","FREDRICK","ARTURO","ALEJANDRO",
"NICK","LUTHER","WENDELL","JEREMIAH","JULIUS","OTIS","TREVOR","OLIVER","LUKE","HOMER","GERARD","DOUG","KENNY","HUBERT","LYLE",
"MATT","ALFONSO","ORLANDO","REX","CARLTON","ERNESTO","NEAL","PABLO","LORENZO","OMAR","WILBUR","GRANT","HORACE","RODERICK",
"ABRAHAM","WILLIS","RICKEY","ANDRES","CESAR","JOHNATHAN","MALCOLM","RUDOLPH","DAMON","KELVIN","PRESTON","ALTON","ARCHIE","MARCO",
"WM","PETE","RANDOLPH","GARRY","GEOFFREY","JONATHON","FELIPE","GERARDO","ED","DOMINIC","DELBERT","COLIN","GUILLERMO","EARNEST",
"LUCAS","BENNY","SPENCER","RODOLFO","MYRON","EDMUND","GARRETT","SALVATORE","CEDRIC","LOWELL","GREGG","SHERMAN","WILSON",
"SYLVESTER","ROOSEVELT","ISRAEL","JERMAINE","FORREST","WILBERT","LELAND","SIMON","CLARK","IRVING","BRYANT","OWEN","RUFUS",
"WOODROW","KRISTOPHER","MACK","LEVI","MARCOS","GUSTAVO","JAKE","LIONEL","GILBERTO","CLINT","NICOLAS","ISMAEL","ORVILLE","ERVIN",
"DEWEY","AL","WILFRED","JOSH","HUGO","IGNACIO","CALEB","TOMAS","SHELDON","ERICK","STEWART","DOYLE","DARREL","ROGELIO","TERENCE",
"SANTIAGO","ALONZO","ELIAS","BERT","ELBERT","RAMIRO","CONRAD","NOAH","GRADY","PHIL","CORNELIUS","LAMAR","ROLANDO","CLAY","PERCY",
"DEXTER","BRADFORD","DARIN","AMOS","MOSES","IRVIN","SAUL","ROMAN","RANDAL","TIMMY","DARRIN","WINSTON","BRENDAN","ABEL","DOMINICK",
"BOYD","EMILIO","ELIJAH","DOMINGO","EMMETT","MARLON","EMANUEL","JERALD","EDMOND","EMIL","DEWAYNE","WILL","OTTO","TEDDY",
"REYNALDO","BRET","JESS","TRENT","HUMBERTO","EMMANUEL","STEPHAN","VICENTE","LAMONT","GARLAND","MILES","EFRAIN","HEATH","RODGER",
"HARLEY","ETHAN","ELDON","ROCKY","PIERRE","JUNIOR","FREDDY","ELI","BRYCE","ANTOINE","STERLING","CHASE","GROVER","ELTON",
"CLEVELAND","DYLAN","CHUCK","DAMIAN","REUBEN","STAN","AUGUST","LEONARDO","JASPER","RUSSEL","ERWIN","BENITO","HANS","MONTE",
"BLAINE","ERNIE","CURT","QUENTIN","AGUSTIN","MURRAY","JAMAL","ADOLFO","HARRISON","TYSON","BURTON","BRADY","ELLIOTT","WILFREDO",
"BART","JARROD","VANCE","DENIS","DAMIEN","JOAQUIN","HARLAN","DESMOND","ELLIOT","DARWIN","GREGORIO","BUDDY","XAVIER","KERMIT",
"ROSCOE","ESTEBAN","ANTON","SOLOMON","SCOTTY","NORBERT","ELVIN","WILLIAMS","NOLAN","ROD","QUINTON","HAL","BRAIN","ROB","ELWOOD",
"KENDRICK","DARIUS","MOISES","FIDEL","THADDEUS","CLIFF","MARCEL","JACKSON","RAPHAEL","BRYON","ARMAND","ALVARO","JEFFRY","DANE",
"JOESPH","THURMAN","NED","RUSTY","MONTY","FABIAN","REGGIE","MASON","GRAHAM","ISAIAH","VAUGHN","GUS","LOYD","DIEGO","ADOLPH",
"NORRIS","MILLARD","ROCCO","GONZALO","DERICK","RODRIGO","WILEY","RIGOBERTO","ALPHONSO","TY","NOE","VERN","REED","JEFFERSON",
"ELVIS","BERNARDO","MAURICIO","HIRAM","DONOVAN","BASIL","RILEY","NICKOLAS","MAYNARD","SCOT","VINCE","QUINCY","EDDY","SEBASTIAN",
"FEDERICO","ULYSSES","HERIBERTO","DONNELL","COLE","DAVIS","GAVIN","EMERY","WARD","ROMEO","JAYSON","DANTE","CLEMENT","COY",
"MAXWELL","JARVIS","BRUNO","ISSAC","DUDLEY","BROCK","SANFORD","CARMELO","BARNEY","NESTOR","STEFAN","DONNY","ART","LINWOOD","BEAU",
"WELDON","GALEN","ISIDRO","TRUMAN","DELMAR","JOHNATHON","SILAS","FREDERIC","DICK","IRWIN","MERLIN","CHARLEY","MARCELINO","HARRIS",
"CARLO","TRENTON","KURTIS","HUNTER","AURELIO","WINFRED","VITO","COLLIN","DENVER","CARTER","LEONEL","EMORY","PASQUALE","MOHAMMAD",
"MARIANO","DANIAL","LANDON","DIRK","BRANDEN","ADAN","BUFORD","GERMAN","WILMER","EMERSON","ZACHERY","FLETCHER","JACQUES","ERROL",
"DALTON","MONROE","JOSUE","EDWARDO","BOOKER","WILFORD","SONNY","SHELTON","CARSON","THERON","RAYMUNDO","DAREN","HOUSTON","ROBBY",
"LINCOLN","GENARO","BENNETT","OCTAVIO","CORNELL","HUNG","ARRON","ANTONY","HERSCHEL","GIOVANNI","GARTH","CYRUS","CYRIL","RONNY",
"LON","FREEMAN","DUNCAN","KENNITH","CARMINE","ERICH","CHADWICK","WILBURN","RUSS","REID","MYLES","ANDERSON","MORTON","JONAS",
"FOREST","MITCHEL","MERVIN","ZANE","RICH","JAMEL","LAZARO","ALPHONSE","RANDELL","MAJOR","JARRETT","BROOKS","ABDUL","LUCIANO",
"SEYMOUR","EUGENIO","MOHAMMED","VALENTIN","CHANCE","ARNULFO","LUCIEN","FERDINAND","THAD","EZRA","ALDO","RUBIN","ROYAL","MITCH",
"EARLE","ABE","WYATT","MARQUIS","LANNY","KAREEM","JAMAR","BORIS","ISIAH","EMILE","ELMO","ARON","LEOPOLDO","EVERETTE","JOSEF",
"ELOY","RODRICK","REINALDO","LUCIO","JERROD","WESTON","HERSHEL","BARTON","PARKER","LEMUEL","BURT","JULES","GIL","ELISEO","AHMAD",
"NIGEL","EFREN","ANTWAN","ALDEN","MARGARITO","COLEMAN","DINO","OSVALDO","LES","DEANDRE","NORMAND","KIETH","TREY","NORBERTO",
"NAPOLEON","JEROLD","FRITZ","ROSENDO","MILFORD","CHRISTOPER","ALFONZO","LYMAN","JOSIAH","BRANT","WILTON","RICO","JAMAAL","DEWITT",
"BRENTON","OLIN","FOSTER","FAUSTINO","CLAUDIO","JUDSON","GINO","EDGARDO","ALEC","TANNER","JARRED","DONN","TAD","PRINCE","PORFIRIO",
"ODIS","LENARD","CHAUNCEY","TOD","MEL","MARCELO","KORY","AUGUSTUS","KEVEN","HILARIO","BUD","SAL","ORVAL","MAURO","ZACHARIAH",
"OLEN","ANIBAL","MILO","JED","DILLON","AMADO","NEWTON","LENNY","RICHIE","HORACIO","BRICE","MOHAMED","DELMER","DARIO","REYES","MAC",
"JONAH","JERROLD","ROBT","HANK","RUPERT","ROLLAND","KENTON","DAMION","ANTONE","WALDO","FREDRIC","BRADLY","KIP","BURL","WALKER",
"TYREE","JEFFEREY","AHMED","WILLY","STANFORD","OREN","NOBLE","MOSHE","MIKEL","ENOCH","BRENDON","QUINTIN","JAMISON","FLORENCIO",
"DARRICK","TOBIAS","HASSAN","GIUSEPPE","DEMARCUS","CLETUS","TYRELL","LYNDON","KEENAN","WERNER","GERALDO","COLUMBUS","CHET",
"BERTRAM","MARKUS","HUEY","HILTON","DWAIN","DONTE","TYRON","OMER","ISAIAS","HIPOLITO","FERMIN","ADALBERTO","BO","BARRETT",
"TEODORO","MCKINLEY","MAXIMO","GARFIELD","RALEIGH","LAWERENCE","ABRAM","RASHAD","KING","EMMITT","DARON","SAMUAL","MIQUEL",
"EUSEBIO","DOMENIC","DARRON","BUSTER","WILBER","RENATO","JC","HOYT","HAYWOOD","EZEKIEL","CHAS","FLORENTINO","ELROY","CLEMENTE",
"ARDEN","NEVILLE","EDISON","DESHAWN","NATHANIAL","JORDON","DANILO","CLAUD","SHERWOOD","RAYMON","RAYFORD","CRISTOBAL","AMBROSE",
"TITUS","HYMAN","FELTON","EZEQUIEL","ERASMO","STANTON","LONNY","LEN","IKE","MILAN","LINO","JAROD","HERB","ANDREAS","WALTON",
"RHETT","PALMER","DOUGLASS","CORDELL","OSWALDO","ELLSWORTH","VIRGILIO","TONEY","NATHANAEL","DEL","BENEDICT","MOSE","JOHNSON",
"ISREAL","GARRET","FAUSTO","ASA","ARLEN","ZACK","WARNER","MODESTO","FRANCESCO","MANUAL","GAYLORD","GASTON","FILIBERTO","DEANGELO",
"MICHALE","GRANVILLE","WES","MALIK","ZACKARY","TUAN","ELDRIDGE","CRISTOPHER","CORTEZ","ANTIONE","MALCOM","LONG","KOREY","JOSPEH",
"COLTON","WAYLON","VON","HOSEA","SHAD","SANTO","RUDOLF","ROLF","REY","RENALDO","MARCELLUS","LUCIUS","KRISTOFER","BOYCE","BENTON",
"HAYDEN","HARLAND","ARNOLDO","RUEBEN","LEANDRO","KRAIG","JERRELL","JEROMY","HOBERT","CEDRICK","ARLIE","WINFORD","WALLY","LUIGI",
"KENETH","JACINTO","GRAIG","FRANKLYN","EDMUNDO","SID","PORTER","LEIF","JERAMY","BUCK","WILLIAN","VINCENZO","SHON","LYNWOOD","JERE",
"HAI","ELDEN","DORSEY","DARELL","BRODERICK","ALONSO"));
//Instance variables
private ArrayList<Long> sums; //Holds the score based on the sum of the characters in the name
private ArrayList<Long> prod; //Holds the score based on the sum of the characters and the location in alphabetical order
private long sum; //Holds the sum of the scores
//Functions
//Constructor
public Problem22(){
super("What is the total of all the name scores in this file?");
sums = new ArrayList<Long>();
prod = new ArrayList<Long>();
sum = 0;
}
//Operational functions
//Solve the problem
@Override
public void solve(){
//If the problem has already been solved do nothing and end the function
if(solved){
return;
}
//Start the timer
timer.start();
//Sort all the names
Collections.sort(names);
//Step through every name adding up the values of the characters
for(int nameCnt = 0;nameCnt < names.size();++nameCnt){
//Step through every character in the current name adding up the value of the characters
sums.add(0L);
for(int charCnt = 0;charCnt < names.get(nameCnt).length();++charCnt){
//A = 65 so subtracting 64 means A - 1. This will only work correctly if all letters are capitalized
sums.set(nameCnt, sums.get(nameCnt) + names.get(nameCnt).charAt(charCnt) - 64);
}
}
//Get the product for all numbers
for(int cnt = 0;cnt < sums.size();++cnt){
prod.add(sums.get(cnt) * (cnt + 1));
}
//Get the sum of all the numbers
sum = ArrayAlgorithms.getLongSum(prod);
//Stop the timer
timer.stop();
//Throw 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();
sums.clear();
prod.clear();
sum = 0;
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("The answer to the question is %d", sum);
}
//Returns the vector of the names being scored
public static ArrayList<String> getNames(){
return names;
}
//Returns the sum of the names scores
public long getNameScoreSum(){
solvedCheck("score of the names");
return sum;
}
}
/* Results:
The answer to the question is 871198282
It took an average of 2.609 milliseconds to run this problem through 100 iterations
*/

147
src/main/java/com/mattrixwv/project_euler/problems/Problem23.java Normal file
View File

@@ -0,0 +1,147 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem23.java
//Matthew Ellison
// Created: 03-22-19
//Modified: 08-20-22
//Find the sum of all the positive integers which cannot be written as the sum of two abundant numbers
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import com.mattrixwv.ArrayAlgorithms;
import com.mattrixwv.NumberAlgorithms;
import java.util.ArrayList;
import java.util.List;
public class Problem23 extends Problem{
//Variables
//Static variables
private static final int MAX_NUM = 28123; //The largest number to be checked
//Instance variables
private ArrayList<Integer> divisorSums; //This gives the sum of the divisors at subscripts
private long sum; //The sum of all the numbers we are looking for
//Functions
//Constructor
public Problem23(){
super("Find the sum of all the positive integers which cannot be written as the sum of two abundant numbers");
divisorSums = new ArrayList<>();
reserveArray();
sum = 0;
}
//Operational functions
//Reserve the size of the array to speed up insertion
private void reserveArray(){
divisorSums.ensureCapacity(MAX_NUM); //It is faster to reserve the appropriate amount of ram now
//Make sure every element has a 0 in it's location
while(divisorSums.size() <= MAX_NUM){
divisorSums.add(0);
}
}
//Solve the problem
@Override
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 the sum of the divisors of all numbers < MAX_NUM
for(int cnt = 1;cnt < MAX_NUM;++cnt){
List<Integer> div = NumberAlgorithms.getDivisors(cnt);
//Remove the last element, which is the number itself. This gives us the propper divisors
if(div.size() > 1){
div.remove(div.size() - 1);
}
divisorSums.set(cnt, ArrayAlgorithms.getSum(div));
}
//Get the abundant numbers
ArrayList<Integer> abund = new ArrayList<>();
for(int cnt = 0;cnt < divisorSums.size();++cnt){
if(divisorSums.get(cnt) > cnt){
abund.add(cnt);
}
}
//Check if each number can be the sum of 2 abundant numbers and add to the sum if no
for(int cnt = 1;cnt < MAX_NUM;++cnt){
if(!isSum(abund, cnt)){
sum += cnt;
}
}
//Stop the timer
timer.stop();
//Throw a flag to show the problem is solved
solved = true;
}
//A function that returns true if num can be created by adding two elements from abund and false if it cannot
private boolean isSum(final ArrayList<Integer> abund, int num){
int tempSum = 0;
//Pick a number for the first part of the sum
for(int firstNum = 0;firstNum < abund.size();++firstNum){
//Pick a number for the second part of the sum
for(int secondNum = firstNum;secondNum < abund.size();++secondNum){
tempSum = abund.get(firstNum) + abund.get(secondNum);
if(tempSum == num){
return true;
}
else if(tempSum > num){
break;
}
}
}
//If you have run through the entire list and did not find a sum then it is false
return false;
}
//Reset the problem so it can be run again
@Override
public void reset(){
super.reset();
divisorSums.clear();
reserveArray();
sum = 0;
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("The answer is %d", sum);
}
//Returns the sum of the numbers asked for
public long getSum(){
solvedCheck("sum");
return sum;
}
}
/* Results:
The answer is 4179871
It took an average of 15.048 seconds to run this problem through 100 iterations
*/

98
src/main/java/com/mattrixwv/project_euler/problems/Problem24.java Normal file
View File

@@ -0,0 +1,98 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem24.java
//Matthew Ellison
// Created: 03-24-19
//Modified: 08-20-22
//What is the millionth lexicographic permutation of the digits 0, 1, 2, 3, 4, 5, 6, 7, 8 and 9?
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import com.mattrixwv.StringAlgorithms;
import java.util.ArrayList;
import java.util.List;
public class Problem24 extends Problem{
//Variables
//Static variables
private static final int NEEDED_PERM = 1000000; //The number of the permutation that you need
private static String nums = "0123456789"; //All of the characters that we need to get the permutations of
//Instance variables
private List<String> permutations; //Holds all of the permutations of the string nums
//Functions
//Constructor
public Problem24(){
super(String.format("What is the millionth lexicographic permutation of the digits %s?", nums));
permutations = new ArrayList<>();
}
//Operational functions
//Solve the problems
@Override
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 the permutations of the string
permutations = StringAlgorithms.getPermutations(nums);
//Stop the timer
timer.stop();
//Throw 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();
permutations.clear();
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("The 1 millionth permutation is %s", permutations.get(NEEDED_PERM - 1));
}
//Returns an ArrayList with all of the permutations
public List<String> getPermutationsList(){
solvedCheck("permutations");
return permutations;
}
//Returns the requested permutation
public String getPermutation(){
solvedCheck("1,000,000th permutation");
return permutations.get(NEEDED_PERM - 1);
}
}
/* Results
The 1 millionth permutation is 2783915460
It took an average of 1.140 seconds to run this problem through 100 iterations
*/

118
src/main/java/com/mattrixwv/project_euler/problems/Problem25.java Normal file
View File

@@ -0,0 +1,118 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem25.java
//Matthew Ellison
// Created: 03-25-19
//Modified: 08-20-22
//What is the index of the first term in the Fibonacci sequence to contain 1000 digits?
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import com.mattrixwv.NumberAlgorithms;
import java.math.BigInteger;
public class Problem25 extends Problem{
//Variables
//Static variables
private static final int NUM_DIGITS = 1000; //The number of digits to calculate up to
//Instance variables
private BigInteger number; //The current Fibonacci number
private BigInteger index; //The index of the current Fibonacci number just calculated
//Functions
//Constructor
public Problem25(){
super(String.format("What is the index of the first term in the Fibonacci sequence to contain %d digits?", NUM_DIGITS));
number = BigInteger.ZERO;
index = BigInteger.TWO;
}
//Operational functions
//Solve the problem
@Override
public void solve(){
//If the problem has already been solved do nothing and end the function
if(solved){
return;
}
//Start the timer
timer.start();
//Move through all Fibonacci numbers until you reach the one with at least NUM_DIGITS digits
while(number.toString().length() < NUM_DIGITS){
index = index.add(BigInteger.ONE); //Increase the index number. Doing this at the beginning keeps the index correct at the end of the loop
number = NumberAlgorithms.getFib(index); //Calculate the number
}
//Stop the timer
timer.stop();
//Throw 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();
number = BigInteger.ZERO;
index = BigInteger.TWO;
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("The first Fibonacci number with %d digits is %s%nIts index is %d", NUM_DIGITS, number.toString(), index);
}
//Returns the Fibonacci number asked for
public BigInteger getNumber(){
solvedCheck("fibonacci number");
return number;
}
//Returns the Fibonacci number asked for as a string
public String getNumberString(){
solvedCheck("fibonacci number as a string");
return number.toString(10);
}
//Returns the index of the requested Fibonacci number
public BigInteger getIndex(){
solvedCheck("index of the fibonacci number");
return index;
}
//Returns the index of the requested Fibonacci number as a string
public String getIndexString(){
solvedCheck("index of the fibonacci number as a string");
return index.toString(10);
}
//Returns the index of the requested Fibonacci number as a long
public long getIndexInt(){
solvedCheck("index of the fibonacci number as an int");
return index.longValue();
}
}
/* Results:
The first Fibonacci number with 1000 digits is 1070066266382758936764980584457396885083683896632151665013235203375314520604694040621889147582489792657804694888177591957484336466672569959512996030461262748092482186144069433051234774442750273781753087579391666192149259186759553966422837148943113074699503439547001985432609723067290192870526447243726117715821825548491120525013201478612965931381792235559657452039506137551467837543229119602129934048260706175397706847068202895486902666185435124521900369480641357447470911707619766945691070098024393439617474103736912503231365532164773697023167755051595173518460579954919410967778373229665796581646513903488154256310184224190259846088000110186255550245493937113651657039447629584714548523425950428582425306083544435428212611008992863795048006894330309773217834864543113205765659868456288616808718693835297350643986297640660000723562917905207051164077614812491885830945940566688339109350944456576357666151619317753792891661581327159616877487983821820492520348473874384736771934512787029218636250627816
Its index is 4782
It took an average of 662.517 milliseconds to run this problem through 100 iterations
*/

130
src/main/java/com/mattrixwv/project_euler/problems/Problem26.java Normal file
View File

@@ -0,0 +1,130 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem26.java
//Matthew Ellison
// Created: 07-28-19
//Modified: 08-20-22
//Find the value of d < 1000 for which 1/d contains the longest recurring cycle in its decimal fraction part.
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import java.util.ArrayList;
public class Problem26 extends Problem{
//Variables
//Static variables
private static final int TOP_NUM = 999; //The largest denominator to test
//Instance variables
private int longestCycle; //The length of the longest cycle
private int longestNumber; //The starting denominator of the longest cycle
//Functions
//Constructor
public Problem26(){
super(String.format("Find the value of d <= %d for which 1/d contains the longest recurring cycle in its decimal fraction part.", TOP_NUM));
longestCycle = 0;
longestNumber = 1;
}
//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/2 and find out how long the longest cycle is by checking the remainders
//Loop through every number from 2-999 and use it for the denominator
for(int denominator = 2;denominator <= TOP_NUM;++denominator){
ArrayList<Integer> denomList = new ArrayList<Integer>();
boolean endFound = false; //A flag for when we have found an end to the number (either a cycle or a 0 for remainder)
boolean cycleFound = false; //A flag to indicate a cycle was detected
int numerator = 1; //The numerator that will be divided. Always starts at 1
while(!endFound){
//Get the remainder after the division
int remainder = numerator % denominator;
//Check if the remainder is 0 and set the flag
if(remainder == 0){
endFound = true;
}
//Check if the remainder is in the list and set the appropriate flags
else if(denomList.contains(remainder)){
endFound = true;
cycleFound = true;
}
//Else add it to the list
else{
denomList.add(remainder);
}
//Multiply the remainder by 10 to continue finding the next remainder
numerator = remainder * 10;
}
//If a cycle was found check the size of the list against the largest cycle
if(cycleFound){
//If it is larger than the largest, set it as the new largest
if(denomList.size() > longestCycle){
longestCycle = denomList.size();
longestNumber = denominator;
}
}
}
//Stop the timer
timer.stop();
//Throw 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();
longestCycle = 0;
longestNumber = 1;
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("The longest cycle is %d digits long%nIt started with the number %d", longestCycle, longestNumber);
}
//Returns the length of the longest cycle
public int getLongestCycle(){
solvedCheck("length of the longest cycle");
return longestCycle;
}
//Returns the denominator that starts the longest cycle
public int getLongestNumber(){
solvedCheck("denominator that starts the longest cycle");
return longestNumber;
}
}
/* Results:
The longest cycle is 982 digits long
It started with the number 983
It took an average of 12.182 milliseconds to run this problem through 100 iterations
*/

132
src/main/java/com/mattrixwv/project_euler/problems/Problem27.java Normal file
View File

@@ -0,0 +1,132 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem27.java
//Matthew Ellison
// Created: 09-15-19
//Modified: 08-20-22
//Find the product of the coefficients, |a| < 1000 and |b| <= 1000, for the quadratic expression that produces the maximum number of primes for consecutive values of n, starting with n=0.
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import com.mattrixwv.NumberAlgorithms;
public class Problem27 extends Problem{
//Variables
//Static varibles
private static final int LARGEST_POSSIBLE_A = 999;
private static final int LARGEST_POSSIBLE_B = 1000;
//Instance variables
private int topA; //The A for the most n's generated
private int topB; //The B for the most n's generated
private int topN; //The most n's generated
//Functions
//Constructor
public Problem27(){
super(String.format("Find the product of the coefficients, |a| <= %d and |b| <= %d, for the quadratic expression that produces the maximum number of primes for consecutive values of n, starting with n=0", LARGEST_POSSIBLE_A, LARGEST_POSSIBLE_B));
topA = 0;
topB = 0;
topN = 0;
}
//Operational functions
//Solve the problem
@Override
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 the lowest possible A and check all possibilities after that
for(int a = -LARGEST_POSSIBLE_A;a <= LARGEST_POSSIBLE_A;++a){
//Start with the lowest possible B and check all possibilities after that
for(int b = -LARGEST_POSSIBLE_B;b <= LARGEST_POSSIBLE_B;++b){
//Start with n=0 and check the formula to see how many primes you can get with concecutive n's
int n = 0;
int quadratic = (n * n) + (a * n) + b;
while(NumberAlgorithms.isPrime(quadratic)){
++n;
quadratic = (n * n) + (a * n) + b;
}
--n; //Negate an n because the last formula failed
//Set all the largest numbers if this created more primes than any other
if(n > topN){
topN = n;
topB = b;
topA = a;
}
}
}
//Stop the timer
timer.stop();
//Throw 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();
topA = 0;
topB = 0;
topN = 0;
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("The greatest number of primes found is %d%nIt was found with A = %d, B = %d%nThe product of A and B is %d", topN, topA, topB, topA * topB);
}
//Returns the top A that was generated
public int getTopA(){
solvedCheck("largest A");
return topA;
}
//Returns the top B that was generated
public int getTopB(){
solvedCheck("largest B");
return topB;
}
//Returns the top N that was generated
public int getTopN(){
solvedCheck("largest N");
return topN;
}
//Resuts the product of A and B for the answer
public int getProduct(){
solvedCheck("product of A and B");
return topA * topB;
}
}
/* Results:
The greatest number of primes found is 70
It was found with A = -61, B = 971
The product of A and B is -59231
It took an average of 18.835 milliseconds to run this problem through 100 iterations
*/

169
src/main/java/com/mattrixwv/project_euler/problems/Problem28.java Normal file
View File

@@ -0,0 +1,169 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem28.java
//Matthew Ellison
// Created: 09-22-19
//Modified: 08-20-22
//What is the sum of the numbers on the diagonals in a 1001 by 1001 spiral formed by starting with the number 1 and moving to the right in a clockwise direction a 5 by 5 spiral
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import java.util.ArrayList;
public class Problem28 extends Problem{
//Variables
//Instance variables
private ArrayList<ArrayList<Integer>> grid; //Holds the grid that we will be filling and searching
private int sumOfDiagonals; //Holds the sum of the diagonals of the grid
//Functions
//Constructor
public Problem28(){
super("What is the sum of the numbers on the diagonals in a 1001 by 1001 spiral formed by starting with the number 1 and moving to the right in a clockwise direction?");
sumOfDiagonals = 0;
}
//Operational functions
//Sets up the grid
private void setupGrid(){
grid = new ArrayList<>();
//Fill the grid with 0's
for(int cnt = 0;cnt < 1001;++cnt){
//Add a blank ArrayList
grid.add(new ArrayList<>());
for(int cnt2 = 0;cnt2 < 1001;++cnt2){
grid.get(cnt).add(0);
}
}
boolean finalLocation = false; //A flag to indicate if the final location to be filled has been reached
//Set the number that is going to be put at each location
int currentNum = 1;
//Start with the middle location and set it correctly and advance the tracker to the next number
int xLocation = 500;
int yLocation = 500;
grid.get(yLocation).set(xLocation, currentNum++);
//Move right the first time
++xLocation;
//Move in a circular pattern until you reach the final location
while(!finalLocation){
//Move down until you reach a blank location on the left
while(!grid.get(yLocation).get(xLocation - 1).equals(0)){
grid.get(yLocation).set(xLocation, currentNum++);
++yLocation;
}
//Move left until you reach a blank location above
while(!grid.get(yLocation - 1).get(xLocation).equals(0)){
grid.get(yLocation).set(xLocation, currentNum++);
--xLocation;
}
//Move up until you reach a blank location to the right
while(!grid.get(yLocation).get(xLocation + 1).equals(0)){
grid.get(yLocation).set(xLocation, currentNum++);
--yLocation;
}
//Move right until you reach a blank location below
while(!grid.get(yLocation + 1).get(xLocation).equals(0)){
grid.get(yLocation).set(xLocation, currentNum++);
++xLocation;
//Check if you are at the final location and break the loop if you are
if(xLocation == grid.size()){
finalLocation = true;
break;
}
}
}
}
//Finds the sum of the diagonals in the grid
private void findSum(){
//Start at the top corners and work your way down moving toward the opposite side
int leftSide = 0;
int rightSide = grid.size() - 1;
int row = 0;
while(row < grid.size()){
//This ensures the middle location is only counted once
if(leftSide == rightSide){
sumOfDiagonals += grid.get(row).get(leftSide);
}
else{
sumOfDiagonals += grid.get(row).get(leftSide);
sumOfDiagonals += grid.get(row).get(rightSide);
}
++row;
++leftSide;
--rightSide;
}
}
//Solve the problem
@Override
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 the grid
setupGrid();
//Find the sum of the diagonals in the grid
findSum();
//Stop the timer
timer.stop();
//Throw 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();
sumOfDiagonals = 0;
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("The sum of the diagonals in the given grid is %d", sumOfDiagonals);
}
//Returns the grid
public ArrayList<ArrayList<Integer>> getGrid(){
solvedCheck("grid");
return grid;
}
//Returns the sum of the diagonals
public int getSum(){
solvedCheck("sum");
return sumOfDiagonals;
}
}
/* Results:
The sum of the diagonals in the given grid is 669171001
It took an average of 17.307 milliseconds to run this problem through 100 iterations
*/

124
src/main/java/com/mattrixwv/project_euler/problems/Problem29.java Normal file
View File

@@ -0,0 +1,124 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem29.java
//Matthew Ellison
// Created: 10-09-19
//Modified: 08-20-22
//How many distinct terms are in the sequence generated by a^b for 2 <= a <= 100 and 2 <= b <= 100?
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import java.math.BigInteger;
import java.util.ArrayList;
public class Problem29 extends Problem{
//Variables
//Static variables
private static final int BOTTOM_A = 2; //The lowest possible value for a
private static final int TOP_A = 100; //The highest possible value for a
private static final int BOTTOM_B = 2; //The lowest possible value for b
private static final int TOP_B = 100; //The highest possible value for b
//Instance variables
private ArrayList<BigInteger> unique; //Holds all unique values generated
//Functions
//Constructor
public Problem29(){
super(String.format("How many distinct terms are in the sequence generated by a^b for %d <= a <= %d and %d <= b <= %d?", BOTTOM_A, TOP_A, BOTTOM_B, TOP_B));
unique = new ArrayList<BigInteger>();
}
//Operational functions
//Solve the problem
@Override
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 the first A and move towards the top
for(int currentA = BOTTOM_A;currentA <= TOP_A;++currentA){
//Start with the first B and move towards the top
for(int currentB = BOTTOM_B;currentB <= TOP_B;++currentB){
//Get the new number
BigInteger currentNum = BigInteger.valueOf(currentA).pow(currentB);
//If the current number is not in the array add it
if(!unique.contains(currentNum)){
unique.add(currentNum);
}
}
}
//Stop the timer
timer.stop();
//Throw 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();
unique.clear();
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("The number of unique values generated by a^b for %d <= a <= %d and %d <= b <= %d is %d", BOTTOM_A, TOP_A, BOTTOM_B, TOP_B, unique.size());
}
//Returns the lowest possible value for a
public static int getBottomA(){
return BOTTOM_A;
}
//Returns the highest possible value for a
public static int getTopA(){
return TOP_A;
}
//Returns the lowest possible value for b
public static int getBottomB(){
return BOTTOM_B;
}
//Returns the highest possible value for b
public static int getTopB(){
return TOP_B;
}
//Returns a vector of all the unique values for a^b
public ArrayList<BigInteger> getUnique(){
solvedCheck("unique values for a^b");
return unique;
}
//Returns the number of unique values for a^b
public int getNumUnique(){
solvedCheck("number of unique values for a^b");
return unique.size();
}
}
/* Results:
The number of unique values generated by a^b for 2 <= a <= 100 and 2 <= b <= 100 is 9183
It took an average of 118.773 milliseconds to run this problem through 100 iterations
*/

103
src/main/java/com/mattrixwv/project_euler/problems/Problem3.java Normal file
View File

@@ -0,0 +1,103 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem3.java
//Matthew Ellison
// Created: 03-01-19
//Modified: 08-20-22
//The largest prime factor of 600851475143
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import java.util.ArrayList;
import java.util.List;
import com.mattrixwv.NumberAlgorithms;
import com.mattrixwv.exceptions.InvalidResult;
public class Problem3 extends Problem{
//Variables
//Static variables
private static final long GOAL_NUMBER = 600851475143L; //The number that needs factored
//Instance variables
private List<Long> factors; //Holds the factors of goalNumber
//Functions
//Constructor
public Problem3(){
super(String.format("What is the largest prime factor of %d?", GOAL_NUMBER));
factors = new ArrayList<>();
}
//Operational functions
//Solve the problem
@Override
public void solve() throws InvalidResult{
//If the problem has already been solved do nothing and end the function
if(solved){
return;
}
//Start the timer
timer.start();
//Get all the factors of the number
factors = NumberAlgorithms.getFactors(GOAL_NUMBER);
//The last element should be the largest factor
//Stop the timer
timer.stop();
//Throw 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();
factors.clear();
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("The largest factor of the number %d is %d", GOAL_NUMBER, factors.get(factors.size() - 1));
}
//Returns the list of factors of the number
public List<Long> getFactors(){
solvedCheck("factors");
return factors;
}
//Returns the largest factor of the number
public long getLargestFactor(){
solvedCheck("largest factor");
return factors.get(factors.size() - 1);
}
//Returns the number for which we are getting the factor
public static long getGoalNumber(){
return GOAL_NUMBER;
}
}
/* Results:
The largest factor of the number 600851475143 is 6857
It took an average of 48.209 milliseconds to run this problem through 100 iterations
*/

134
src/main/java/com/mattrixwv/project_euler/problems/Problem30.java Normal file
View File

@@ -0,0 +1,134 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem30.java
//Matthew Ellison
// Created: 10-27-19
//Modified: 08-20-22
//Find the sum of all the numbers that can be written as the sum of the fifth powers of their digits.
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import java.util.ArrayList;
import com.mattrixwv.ArrayAlgorithms;
public class Problem30 extends Problem{
//Variables
//Static variables
private static final long TOP_NUM = 1000000; //This is the largest number that will be checked
private static final long BOTTOM_NUM = 2; //Starts with 2 because 0 and 1 don't count
private static final long POWER_RAISED = 5; //This is the power that the digits are raised to
//Instance variables
private ArrayList<Long> sumOfFifthNumbers; //This is an ArrayList of the numbers that are the sum of the fifth power of their digits
private long sum; //This is the sum of the sumOfFifthNumbers array
//Functions
//Operational functions
public Problem30(){
super("Find the sum of all the numbers that can be written as the sum of the fifth powers of their digits.");
sumOfFifthNumbers = new ArrayList<Long>();
sum = 0;
}
//Operational functions
//Returns an ArrayList with the individual digits of the number passed to it
private ArrayList<Long> getDigits(long num){
ArrayList<Long> listOfDigits = new ArrayList<Long>(); //This ArrayList holds the individual digits of num
//The easiest way to get the individual digits of a number is by converting it to a string
String digits = Long.toString(num);
//Start with the first digit, convert it to an integer, store it in the ArrayList, and move to the next digit
for(int cnt = 0;cnt < digits.length();++cnt){
listOfDigits.add(Long.valueOf(digits.substring(cnt, cnt + 1)));
}
//Return the list of digits
return listOfDigits;
}
//Solve the problem
@Override
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 the lowest number and increment until you reach the largest number
for(long currentNum = BOTTOM_NUM;currentNum <= TOP_NUM;++currentNum){
//Get the digits of the number
ArrayList<Long> digits = getDigits(currentNum);
//Get the sum of the powers
long sumOfPowers = 0L;
for(long num : digits){
sumOfPowers += Math.round(Math.pow(num, POWER_RAISED));
}
//Check if the sum of the powers is the same as the number
//If it is add it to the list, otherwise continue to the next number
if(sumOfPowers == currentNum){
sumOfFifthNumbers.add(currentNum);
}
}
//Get the sum of the numbers
sum = ArrayAlgorithms.getLongSum(sumOfFifthNumbers);
//Stop the timer
timer.stop();
//Throw 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();
sumOfFifthNumbers.clear();
sum = 0;
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("The sum of all the numbers that can be written as the sum of the fifth powers of their digits is %d", sum);
}
//This returns the top number to be checked
public long getTopNum(){
solvedCheck("largest number checked");
return TOP_NUM;
}
//This returns a copy of the vector holding all the numbers that are the sum of the fifth power of their digits
public ArrayList<Long> getListOfSumOfFifths(){
solvedCheck("list of all numbers that are the sum of the 5th power of their digits");
return sumOfFifthNumbers;
}
//This returns the sum of all entries in sumOfFifthNumbers
public long getSumOfList(){
solvedCheck("sum of all numbers that are the sum of the 5th power of their digits");
return sum;
}
}
/* Results:
The sum of all the numbers that can be written as the sum of the fifth powers of their digits is 443839
It took an average of 240.500 milliseconds to run this problem through 100 iterations
*/

99
src/main/java/com/mattrixwv/project_euler/problems/Problem31.java Normal file
View File

@@ -0,0 +1,99 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem31.java
//Matthew Ellison
// Created: 06-19-20
//Modified: 08-20-22
//How many different ways can £2 be made using any number of coins?
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
public class Problem31 extends Problem{
//Variables
//Static variables
private static final int DESIRED_VALUE = 200; //The value of coins we want
//Instance variables
private int permutations; //The number of permutations that are found
//Functions
//Constructor
public Problem31(){
super("How many different ways can 2 pounds be made using any number of coins?");
permutations = 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();
//Start with 200p and remove the necessary coins with each loop
for(int pound2 = DESIRED_VALUE; pound2 >= 0;pound2 -= 200){
for(int pound1 = pound2;pound1 >= 0;pound1 -= 100){
for(int pence50 = pound1;pence50 >= 0;pence50 -= 50){
for(int pence20 = pence50;pence20 >= 0;pence20 -= 20){
for(int pence10 = pence20;pence10 >= 0;pence10 -= 10){
for(int pence5 = pence10;pence5 >= 0;pence5 -= 5){
for (int pence2 = pence5; pence2 >= 0; pence2 -= 2){
++permutations;
}
}
}
}
}
}
}
//Stop the timer
timer.stop();
//Throw 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();
permutations = 0;
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("There are %d ways to make 2 pounds with the given denominations of coins", permutations);
}
//Returns the number of correct permutations of the coins
public int getPermutations(){
solvedCheck("number of correct permutations of the coins");
return permutations;
}
}
/* Results:
There are 73682 ways to make 2 pounds with the given denominations of coins
It took an average of 19.175 microseconds to run this problem through 100 iterations
*/

174
src/main/java/com/mattrixwv/project_euler/problems/Problem32.java Normal file
View File

@@ -0,0 +1,174 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem32.java
//Matthew Ellison
// Created: 07-27-20
//Modified: 08-20-22
//Find the sum of all products whose multiplicand/multiplier/product identity can be written as a 1 through 9 pandigital.
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import java.util.ArrayList;
import com.mattrixwv.StringAlgorithms;
public class Problem32 extends Problem{
//Structures
//Holds the set of numbers that make a product
private class ProductSet{
private int multiplicand;
private int multiplier;
public ProductSet(int multiplicand, int multiplier){
this.multiplicand = multiplicand;
this.multiplier = multiplier;
}
@SuppressWarnings("unused")
public int getMultiplicand(){
return multiplicand;
}
@SuppressWarnings("unused")
public int getMultiplier(){
return multiplier;
}
public int getProduct(){
return (multiplicand * multiplier);
}
@Override
public boolean equals(Object o){
//If an object is compared to itself return true
if(o == this){
return true;
}
//Check that the object is the correct type
if(!(o instanceof ProductSet)){
return false;
}
ProductSet secondSet = (ProductSet)o;
//Return true if the products are the same
return (getProduct() == secondSet.getProduct());
}
@Override
public String toString(){
return String.format("%d%d%d", multiplicand, multiplier, getProduct());
}
}
//Variables
//Static variables
private static final int TOP_MULTIPLICAND = 99; //The largest multiplicand to check
private static final int TOP_MULTIPLIER = 4999; //The largest multiplier to check
//Instance variables
ArrayList<ProductSet> listOfProducts; //The list of unique products that are 1-9 pandigital
long sumOfPandigitals; //The sum of the products of the pandigital numbers
//Functions
//Constructor
public Problem32(){
super("Find the sum of all products whose multiplicand/multiplier/product identity can be written as a 1 through 9 pandigital.");
listOfProducts = new ArrayList<>();
sumOfPandigitals = 0;
}
//Operational functions
//Solve the problem
@Override
public void solve(){
//If the problem has already been solved do nothing and end the function
if(solved){
return;
}
//Start the timer
timer.start();
//Create the multiplicand and start working your way up
for(int multiplicand = 1;multiplicand <= TOP_MULTIPLICAND;++multiplicand){
//Run through all possible multipliers
for(int multiplier = multiplicand;multiplier <= TOP_MULTIPLIER;++multiplier){
ProductSet currentProductSet = new ProductSet(multiplicand, multiplier);
//If the product is too long move on to the next possible number
if(currentProductSet.toString().length() > 9){
break;
}
//If the current number is a pandigital that doesn't already exist in the list add it to the list
if(isPandigital(currentProductSet)){
if(!listOfProducts.contains(currentProductSet)){
listOfProducts.add(currentProductSet);
}
}
}
}
//Get the sum of the products of the pandigitals
for(ProductSet prod : listOfProducts){
sumOfPandigitals += prod.getProduct();
}
//Stop the timer
timer.stop();
//Throw a flag to show the problem is solved
solved = true;
}
//Returns true if the passed productset is 1-9 pandigital
private boolean isPandigital(ProductSet currentSet){
//Get the numbers out of the object and put them into a string
String numberString = currentSet.toString();
//Make sure the string is the correct length
if(numberString.length() != 9){
return false;
}
//Make sure every number from 1-9 is contained exactly once
for(int panNumber = 1;panNumber <= 9;++panNumber){
//Make sure there is exactly one of this number contained in the string
final int tempNum = panNumber; //This is here because forDigit() wanted a final variable
if(StringAlgorithms.findNumOccurrence(numberString, Character.forDigit(tempNum, 10)) != 1){
return false;
}
}
//If all numbers were found in the string return true
return true;
}
//Reset the problem so it can be run again
@Override
public void reset(){
super.reset();
listOfProducts.clear();
sumOfPandigitals = 0;
}
//Gets
@Override
public String getResult(){
solvedCheck("result");
return String.format("There are %d unique 1-9 pandigitals%nThe sum of the products of these pandigitals is %d", listOfProducts.size(), sumOfPandigitals);
}
//Returns the sum of the pandigitals
public long getSumOfPandigitals(){
solvedCheck("sum of the pandigitals");
return sumOfPandigitals;
}
}
/* Results:
There are 7 unique 1-9 pandigitals
The sum of the products of these pandigitals is 45228
It took an average of 63.456 milliseconds to run this problem through 100 iterations
*/

158
src/main/java/com/mattrixwv/project_euler/problems/Problem33.java Normal file
View File

@@ -0,0 +1,158 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem33.java
//Matthew Ellison
// Created: 02-05-21
//Modified: 08-20-22
/*
The fraction 49/98 is a curious fraction, as an inexperienced mathematician in attempting to simplify it may incorrectly believe that 49/98 = 4/8, which is correct, is obtained by cancelling the 9s
We shall consider fractions like, 30/50 = 3/5, to be trivial examples
There are exactly four non-trivial examples of this type of fraction, less than one in value, and containing two digits in the numerator and denominator
If the product of these four fractions is given in its lowest common terms, find the value of the denominator
*/
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import java.util.ArrayList;
import java.util.List;
import com.mattrixwv.ArrayAlgorithms;
import com.mattrixwv.NumberAlgorithms;
public class Problem33 extends Problem{
//Variables
//Static variables
private static final int MIN_NUMERATOR = 10; //The lowest the numerator can be
private static final int MAX_NUMERATOR = 98; //The highest the numerator can be
private static final int MIN_DENOMINATOR = 11; //The lowest the denominator can be
private static final int MAX_DENOMINATOR = 99; //The highest the denominator can be
//Instance variables
private ArrayList<Integer> numerators; //Holds the numerators that were found
private ArrayList<Integer> denominators; //Holds the denominators that were found
private int prodDenominator; //Holds the answer to the question
//Functions
//Constructor
public Problem33(){
super("If the product of these four fractions is given in its lowest common terms, find the value of the denominator");
prodDenominator = 1;
numerators = new ArrayList<>();
denominators = new ArrayList<>();
}
//Operational functions
//Solve the problem
@Override
public void solve(){
//If the problem has already been solved do nothing and end the function
if(solved){
return;
}
//Start the timer
timer.start();
//Search every possible numerator/denominator pair
for(int denominator = MIN_DENOMINATOR;denominator <= MAX_DENOMINATOR;++denominator){
for(int numerator = MIN_NUMERATOR;(numerator < denominator) && (numerator <= MAX_NUMERATOR);++numerator){
String denom = Integer.toString(denominator);
String num = Integer.toString(numerator);
int tempNum = 0;
int tempDenom = 1;
//Check that this isn't a trivial example
if((num.charAt(1) == '0') && (denom.charAt(1) == '0')){
continue;
}
//Remove the offending digits if they exist
else if(num.charAt(0) == denom.charAt(0)){
tempNum = num.charAt(1) - 48;
tempDenom = denom.charAt(1) - 48;
}
else if(num.charAt(0) == denom.charAt(1)){
tempNum = num.charAt(1) - 48;
tempDenom = denom.charAt(0) - 48;
}
else if(num.charAt(1) == denom.charAt(0)){
tempNum = num.charAt(0) - 48;
tempDenom = denom.charAt(1) - 48;
}
else if(num.charAt(1) == denom.charAt(1)){
tempNum = num.charAt(0) - 48;
tempDenom = denom.charAt(0) - 48;
}
//Test if the new fraction is the same as the old one
if(((double)tempNum / (double)tempDenom) == ((double)numerator / (double)denominator)){
numerators.add(numerator);
denominators.add(denominator);
}
}
}
//Get the product of the numbers
int numProd = ArrayAlgorithms.getProd(numerators);
int denomProd = ArrayAlgorithms.getProd(denominators);
//Get the gcd to reduce to lowest terms
int gcd = NumberAlgorithms.gcd(numProd, denomProd);
//Save the denominator
prodDenominator = denomProd / gcd;
//Stop the timer
timer.stop();
//Throw 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();
numerators.clear();
denominators.clear();
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("The denominator of the product is %d", prodDenominator);
}
//Returns the list of numerators
public List<Integer> getNumerators(){
solvedCheck("list of numerators");
return numerators;
}
//Returns the list of denominators
public List<Integer> getDenominators(){
solvedCheck("list of denominators");
return denominators;
}
//Returns the answer to the question
public int getProdDenominator(){
solvedCheck("denominator");
return prodDenominator;
}
}
/* Results:
The denominator of the product is 100
It took an average of 522.671 microseconds to run this problem through 100 iterations
*/

122
src/main/java/com/mattrixwv/project_euler/problems/Problem34.java Normal file
View File

@@ -0,0 +1,122 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem34.java
//Matthew Ellison
// Created: 02-05-21
//Modified: 08-20-22
//Find the sum of all numbers which are equal to the sum of the factorial of their digits
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import java.util.ArrayList;
import java.util.List;
import com.mattrixwv.NumberAlgorithms;
public class Problem34 extends Problem{
//Variables
//Static variables
private static final int MAX_NUM = 1499999; //The largest num that can be the sum of its own digits
//Instance variables
private ArrayList<Integer> factorials; //Holds the pre-computed factorials of the numbers 0-9
private int sum; //Holds the sum of all numbers equal to the sum of their digit's factorials
//Functions
//Constructor
public Problem34(){
super("Find the sum of all numbers which are equal to the sum of the factorial of their digits");
sum = 0;
factorials = new ArrayList<>();
for(int cnt = 0;cnt <= 9;++cnt){
factorials.add(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();
//Pre-compute the possible factorials from 0! to 9!
for(int cnt = 0;cnt <= 9;++cnt){
factorials.set(cnt, NumberAlgorithms.factorial(cnt));
}
//Run through all possible numbers from 3-MAX_NUM and see if they equal the sum of their digit's factorials
for(int cnt = 3;cnt < MAX_NUM;++cnt){
//Split the number into its digits and add each one to the sum
String numString = "" + cnt;
int currentSum = 0;
for(int charCnt = 0;charCnt < numString.length();++charCnt){
Character digit = numString.charAt(charCnt);
int tempNum = Integer.parseInt(digit.toString());
currentSum += factorials.get(tempNum);
}
//If the number is equal to the sum add the sum to the running sum
if(currentSum == cnt){
sum += currentSum;
}
}
//Stop the timer
timer.stop();
//Throw 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();
sum = 0;
factorials = new ArrayList<>();
for(int cnt = 0;cnt <= 9;++cnt){
factorials.add(0);
}
}
//Gets
//Returns a string witht he solution to the problem
public String getResult(){
solvedCheck("result");
return String.format("The sum of all numbers that are the sum of their digit's factorials is %d", sum);
}
//Returns the list of factorials from 0-9
public List<Integer> getFactorials(){
solvedCheck("list of factorials");
return factorials;
}
//Returns the sum of all numbers equal to the sum of their digit's factorials
public int getSum(){
solvedCheck("sum");
return sum;
}
}
/* Results:
The sum of all numbers that are the sum of their digit's factorials is 40730
It took an average of 78.889 milliseconds to run this problem through 100 iterations
*/

129
src/main/java/com/mattrixwv/project_euler/problems/Problem35.java Normal file
View File

@@ -0,0 +1,129 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem35.java
//Matthew Ellison
// Created: 06-05-21
//Modified: 08-20-22
//How many circular primes are there below one million?
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import java.util.ArrayList;
import java.util.List;
import com.mattrixwv.NumberAlgorithms;
public class Problem35 extends Problem{
//Variables
//Static variables
private static final int MAX_NUM = 999999; //The largest number that we are checking for primes
//Instance variables
private List<Integer> primes; //The primes below MAX_NUM
private ArrayList<Integer> circularPrimes; //The circular primes below MAX_NUM
//Functions
//Returns a list of all rotations of a string passed to it
private ArrayList<String> getRotations(String str){
ArrayList<String> rotations = new ArrayList<>();
rotations.add(str);
for(int cnt = 1;cnt < str.length();++cnt){
str = str.substring(1) + str.substring(0, 1);
rotations.add(str);
}
return rotations;
}
//Constructor
public Problem35(){
super("How many circular primes are there below one million?");
primes = new ArrayList<>();
circularPrimes = new ArrayList<>();
}
//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 primes under 1,000,000
primes = NumberAlgorithms.getPrimes(MAX_NUM);
//Go through all primes, get all their rotations, and check if those numbers are also primes
for(int prime : primes){
boolean allRotationsPrime = true;
//Get all of the rotations of the prime and see if they are also prime
ArrayList<String> rotations = getRotations(Integer.toString(prime));
for(String rotation : rotations){
int p = Integer.parseInt(rotation);
if(!primes.contains(p)){
allRotationsPrime = false;
break;
}
}
//If all rotations are prime add it to the list of circular primes
if(allRotationsPrime){
circularPrimes.add(prime);
}
}
//Stop the timer
timer.stop();
//Throw 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();
primes.clear();
circularPrimes.clear();
}
//Gets
//Returns a string with the solution to the problem
public String getResult(){
solvedCheck("result");
return String.format("The number of all circular prime numbers under %d is %d", MAX_NUM, circularPrimes.size());
}
//Returns the ArrayList of primes < MAX_NUM
public List<Integer> getPrimes(){
solvedCheck("list of primes");
return primes;
}
//Returns the ArrayList of circular primes < MAX_NUM
public List<Integer> getCircularPrimes(){
solvedCheck("list of circular primes");
return circularPrimes;
}
//Returns the number of circular primes
public int getNumCircularPrimes(){
solvedCheck("number of circular primes");
return circularPrimes.size();
}
}
/* Results:
The number of all circular prime numbers under 999999 is 55
It took an average of 5.255 seconds to run this problem through 100 iterations
*/

112
src/main/java/com/mattrixwv/project_euler/problems/Problem36.java Normal file
View File

@@ -0,0 +1,112 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem36.java
//Matthew Ellison
// Created: 06-29-21
//Modified: 08-20-22
//Find the sum of all numbers, less than one million, which are palindromic in base 10 and base 2.
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import java.util.ArrayList;
import java.util.List;
import com.mattrixwv.ArrayAlgorithms;
import com.mattrixwv.NumberAlgorithms;
import com.mattrixwv.StringAlgorithms;
public class Problem36 extends Problem{
//Variables
//Static variables
private static final int MAX_NUM = 999999; //The largest number that will be checked
//Instance variables
private ArrayList<Integer> palindromes; //All numbers that are palindromes in base 10 and 2
private int sum; //The sum of all elements in the list of palindromes
//Functions
//Constructor
public Problem36(){
super("Find the sum of all numbers, less than one million, which are palindromic in base 10 and base 2.");
palindromes = new ArrayList<>();
sum = 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();
//Start with 1, check if it is a palindrome in base 10 and 2, and continue to MAX_NUM
for(int num = 1;num < MAX_NUM;++num){
//Check if num is a palindrome
if(StringAlgorithms.isPalindrome(Integer.toString(num))){
//Convert num to base 2 and see if that is a palindrome
String binNum = NumberAlgorithms.toBin(num);
if(StringAlgorithms.isPalindrome(binNum)){
//Add num to the list of palindromes
palindromes.add(num);
}
}
}
//Get the sum of all palindromes in the list
sum = ArrayAlgorithms.getSum(palindromes);
//Stop the timer
timer.stop();
//Throw 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();
palindromes.clear();
sum = 0;
}
//Gets
//Returns a string with the solution to the problem
public String getResult(){
solvedCheck("result");
return String.format("The sum of all base 10 and base 2 palindromic numbers < %d is %d", MAX_NUM, sum);
}
//Return the List of palindromes < MAX_NUM
public List<Integer> getPalindromes(){
solvedCheck("list of palindromes");
return palindromes;
}
//Return the sum of all elements in the List of palindromes
public int getSumOfPalindromes(){
solvedCheck("sum of all palindromes");
return sum;
}
}
/* Results:
The sum of all base 10 and base 2 palindromic numbers < 999999 is 872187
It took an average of 39.606 milliseconds to run this problem through 100 iterations
*/

160
src/main/java/com/mattrixwv/project_euler/problems/Problem37.java Normal file
View File

@@ -0,0 +1,160 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem37.java
//Matthew Ellison
// Created: 07-01-21
//Modified: 08-20-22
//Find the sum of the only eleven primes that are both truncatable from left to right and right to left (2, 3, 5, and 7 are not counted).
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import java.util.ArrayList;
import java.util.List;
import com.mattrixwv.ArrayAlgorithms;
import com.mattrixwv.NumberAlgorithms;
import com.mattrixwv.generators.SieveOfEratosthenes;
public class Problem37 extends Problem{
//Variables
//Static variables
private static final long LAST_PRIME_BEFORE_CHECK = 7; //The last prime before 11 since single digit primes aren't checked
//Instance variables
private ArrayList<Long> truncPrimes; //All numbers that are truncatable primes
private long sum; //The sum of all elements in truncPrimes
//Functions
//Constructor
public Problem37(){
super("Find the sum of the only eleven primes that are both truncatable from left to right and right to left (2, 3, 5, and 7 are not counted).");
truncPrimes = new ArrayList<>();
sum = 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();
//Create the sieve and get the first prime number
SieveOfEratosthenes sieve = new SieveOfEratosthenes();
long currentPrime = sieve.next();
//Loop through the sieve until you get to LAST_PRIME_BEFORE_CHECK
while(currentPrime < LAST_PRIME_BEFORE_CHECK){
currentPrime = sieve.next();
}
//Loop until truncPrimes contains 11 elements
while(truncPrimes.size() < 11){
boolean isTruncPrime = true;
//Get the next prime
currentPrime = sieve.next();
//Convert the prime to a string
String primeString = Long.toString(currentPrime);
//If the string contains an even digit move to the next prime
for(int strLoc = 0;(strLoc < primeString.length()) && (isTruncPrime);++strLoc){
//Allow 2 to be the first digit
if((strLoc == 0) && (primeString.charAt(strLoc) == '2')){
continue;
}
switch(primeString.charAt(strLoc)){
case '0' :
case '2' :
case '4' :
case '6' :
case '8' : isTruncPrime = false; break;
}
}
//Start removing digits from the left and see if the number stays prime
if(isTruncPrime){
for(int truncLoc = 1;truncLoc < primeString.length();++truncLoc){
//Create a substring of the prime, removing the needed digits from the left
String primeSubstring = primeString.substring(truncLoc);
//Convert the string to an int and see if the number is still prime
long newPrime = Long.parseLong(primeSubstring);
if(!NumberAlgorithms.isPrime(newPrime)){
isTruncPrime = false;
break;
}
}
}
//Start removing digits from the right and see if the number stays prime
if(isTruncPrime){
for(int truncLoc = 1;truncLoc < primeString.length();++truncLoc){
//Create a substring of the prime, removing the needed digits from the right
String primeSubstring = primeString.substring(0, primeString.length() - truncLoc);
//Convert the string to an int and see if the number is still prime
long newPrime = Long.parseLong(primeSubstring);
if(!NumberAlgorithms.isPrime(newPrime)){
isTruncPrime = false;
break;
}
}
}
//If the number remained prime through all operations add it to the vector
if(isTruncPrime){
truncPrimes.add(currentPrime);
}
}
//Get the sum of all elements in the truncPrimes vector
sum = ArrayAlgorithms.getLongSum(truncPrimes);
//Stop the timer
timer.stop();
//Throw 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();
truncPrimes.clear();
sum = 0;
}
//Gets
//Returns a string with the solution to the problem
public String getResult(){
solvedCheck("result");
return String.format("The sum of all left and right truncatable primes is %d", sum);
}
//Returns the list of primes that can be truncated
public List<Long> getTruncatablePrimes(){
solvedCheck("list of truncatable primes");
return truncPrimes;
}
//Return the sum of all primes in truncPrimes
public long getSumOfPrimes(){
solvedCheck("sum of truncatable primes");
return sum;
}
}
/* Results:
The sum of all left and right truncatable primes is 748317
It took an average of 103.829 milliseconds to run this problem through 100 iterations
*/

118
src/main/java/com/mattrixwv/project_euler/problems/Problem38.java Normal file
View File

@@ -0,0 +1,118 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem37.java
//Matthew Ellison
// Created: 10-11-21
//Modified: 08-20-22
//What is the largest 1-9 pandigital number that can be formed as the concatenated product of an integer with 1, 2, ... n where n > 1
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import com.mattrixwv.StringAlgorithms;
public class Problem38 extends Problem{
//Variables
//Static variables
private static final long HIGHEST_POSSIBLE_NUM = 9999; //The highest number that needs to be checked for a 1-9 pandigital
//Instance variables
private long largestNum; //The number passed to the executeFormula function that returns the largest pandigital
private long pandigital; //The largest pandigital number found
//Functions
//Constructor
public Problem38(){
super("What is the largest 1-9 pandigital number that can be formed as the concatenated product of an integer with 1, 2, ... n where n > 1");
largestNum = 0;
pandigital = 0;
}
//Operational functions
//Take the number and add its multiples to a string to return
private String executeFormula(int num){
//Turn the current number into a string
StringBuilder numStr = new StringBuilder();
numStr.append(Integer.toString(num));
int cnt = 2;
//Multiply the number and append the product to the string until you have one long enough
do{
numStr.append(Integer.toString(num * cnt));
++cnt;
}while(numStr.length() < 9);
return numStr.toString();
}
//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();
//Loop from 1 -> HIGHEST_POSSIBLE_NUM checking for pandigitals
for(int cnt = 1;cnt <= HIGHEST_POSSIBLE_NUM;++cnt){
//Get the string from the formula
String numStr = executeFormula(cnt);
long panNum = Long.parseLong(numStr);
//If the number is pandigital save it as the highest number
if(StringAlgorithms.isPandigital(numStr) && (panNum > pandigital)){
largestNum = cnt;
pandigital = panNum;
}
}
//Stop the timer
timer.stop();
//Throw a flag to show the problem is solved
solved = true;
}
//Reset the prblem so it can be run again
@Override
public void reset(){
super.reset();
largestNum = 0;
pandigital = 0;
}
//Gets
//Returns a string with the solution to the problem
public String getResult(){
solvedCheck("results");
return String.format("The largest appended product pandigital is %d", pandigital);
}
//Returns the largest number
public long getLargestNum(){
solvedCheck("largest number");
return largestNum;
}
//Returns the pandigital of the number
public long getPandigital(){
solvedCheck("pandigital");
return pandigital;
}
}
/* Results:
The largest appended product pandigital is 932718654
It took 16.947 milliseconds to solve this problem.
*/

114
src/main/java/com/mattrixwv/project_euler/problems/Problem4.java Normal file
View File

@@ -0,0 +1,114 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem4.java
//Matthew Ellison
// Created: 03-01-19
//Modified: 08-20-22
//Find the largest palindrome made from the product of two 3-digit numbers
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import java.util.ArrayList;
import java.util.Collections;
public class Problem4 extends Problem{
//Variables
//Static variables
private static final int START_NUM = 100; //The first number to be multiplied
private static final int END_NUM = 999; //The last number to be multiplied
//Instance variables
private ArrayList<Integer> palindromes; //Holds all numbers that turn out to be palindromes
//Constructor
public Problem4(){
super("Find the largest palindrome made from the product of two 3-digit numbers");
palindromes = new ArrayList<Integer>();
}
//Operational functions
//Solve the problem
@Override
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 at the first 3-digit number and check every one up to the last 3-digit number
for(int firstNum = START_NUM;firstNum <= END_NUM;++firstNum){
//You can start at the location of the first number because everything before that has already been tested. (100 * 101 == 101 * 100)
for(int secondNum = firstNum;secondNum < END_NUM;++secondNum){
//Get the product
int product = firstNum * secondNum;
//Change the number into a string
String productString = Integer.toString(product);
//Reverse the string
String reverseString = new StringBuilder(productString).reverse().toString();
//If the number and it's reverse are the same it is a palindrome so add it to the list
if(productString.equals(reverseString)){
palindromes.add(product);
}
//If it's not a palindrome ignore it and move to the next number
}
}
//Sort the palindromes so that the last one is the largest
Collections.sort(palindromes);
//Stop the timer
timer.stop();
//Throw 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();
palindromes.clear();
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("The largest palindrome is %d", palindromes.get(palindromes.size() - 1));
}
//Returns the list of all palindromes
public ArrayList<Integer> getPalindromes(){
solvedCheck("palindromes");
return palindromes;
}
//Returns the largest palindrome
public int getLargestPalindrome(){
solvedCheck("largest palindrome");
return palindromes.get(palindromes.size() - 1);
}
}
/* Results:
The largest palindrome is 906609
It took an average of 16.926 milliseconds to run this problem through 100 iterations
*/

103
src/main/java/com/mattrixwv/project_euler/problems/Problem5.java Normal file
View File

@@ -0,0 +1,103 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem5.java
//Matthew Ellison
// Created: 03-01-19
//Modified: 08-20-22
//What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20?
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
public class Problem5 extends Problem{
//Variables
//Instance variables
private int smallestNum; //The smallest number that is found
//Functions
//Constructor
public Problem5(){
super("What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20?");
smallestNum = 0;
}
//Operational functions
//Solve the problem
@Override
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 at 20 because it must at least be divisible by 20. Increment by 2 because it must be an even number to be divisible by 2
boolean numFound = false; //A flag for finding the divisible number
int currentNum = 20; //The number that it is currently checking against
while((currentNum > 0) && (!numFound)){
//Start by assuming you found the number (because we throw a flag if we didn't find it)
numFound = true;
//Step through every number from 1-20 seeing if the current number is divisible by it
for(int divisor = 1;divisor <= 20;++divisor){
//If it is not divisible then throw a flag and start looking at the next number
if((currentNum % divisor) != 0){
numFound = false;
break;
}
}
//If you didn't find the correct number then increment by 2
if(!numFound){
currentNum += 2;
}
}
//Save the current number as the smallest
smallestNum = currentNum;
//Stop the timer
timer.stop();
//Throw 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();
smallestNum = 0;
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("The smallest positive number evenly divisible by all numbers 1-20 is %d", smallestNum);
}
//Returns the requested number
public int getNumber(){
solvedCheck("number");
return smallestNum;
}
}
/* Results:
The smallest positive number evenly divisible by all numbers 1-20 is 232792560
It took an average of 213.942 milliseconds to run this problem through 100 iterations
*/

105
src/main/java/com/mattrixwv/project_euler/problems/Problem6.java Normal file
View File

@@ -0,0 +1,105 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem6.java
//Matthew Ellison
// Created: 03-01-19
//Modified: 08-20-22
//Find the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum.
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
public class Problem6 extends Problem{
//Variables
//Static variables
private static final int START_NUM = 1; //The first number that needs to be counted
private static final int END_NUM = 100; //The last number that needs to be counted
//Instance variables
private long sumOfSquares; //Holds the sum of the squares of all the numbers
private long squareOfSum; //Holds the square of the sum of all the numbers
//Functions
//Constructor
public Problem6(){
super(String.format("Find the difference between the sum of the squares and the square of the sum of the numbers %d-%d.", START_NUM, END_NUM));
sumOfSquares = 0;
squareOfSum = 0;
}
//Operational functions
//Solve the problem
@Override
public void solve(){
//If the problem has already been solved do nothing and end the function
if(solved){
return;
}
//Start the timer
timer.start();
//Run through all numbers and add them to the appropriate sums
for(int currentNum = START_NUM;currentNum <= END_NUM;++currentNum){
sumOfSquares += (currentNum * currentNum); //Add the square to the correct variable
squareOfSum += currentNum; //Add the number to the correct variable to squaring later
}
//Squaring the sum that needs it
squareOfSum *= squareOfSum;
//Stop the timer
timer.stop();
//Throw 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();
squareOfSum = 0;
sumOfSquares = 0;
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("The difference between the sum of the squares and the square of the sum of all numbers from 1-100 is %d", Math.abs(sumOfSquares - squareOfSum));
}
//Returns the sum of all the squares
public long getSumOfSquares(){
solvedCheck("sum of the squares");
return sumOfSquares;
}
//Returns the square of all of the sums
public long getSquareOfSum(){
solvedCheck("square of the sums");
return squareOfSum;
}
//Returns the requested difference
public long getDifference(){
solvedCheck("difference between the two numbers");
return Math.abs(sumOfSquares - squareOfSum);
}
}
/* Results:
The difference between the sum of the squares and the square of the sum of all numbers from 1-100 is 25164150
It took an average of 2.669 microseconds to run this problem through 100 iterations
*/

246
src/main/java/com/mattrixwv/project_euler/problems/Problem67.java Normal file
View File

@@ -0,0 +1,246 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem67.java
//Matthew Ellison
// Created: 03-26-19
//Modified: 07-03-21
//Find the maximum total from top to bottom
/*
59
73 41
52 40 09
26 53 06 34
10 51 87 86 81
61 95 66 57 25 68
90 81 80 38 92 67 73
30 28 51 76 81 18 75 44
84 14 95 87 62 81 17 78 58
21 46 71 58 02 79 62 39 31 09
56 34 35 53 78 31 81 18 90 93 15
78 53 04 21 84 93 32 13 97 11 37 51
45 03 81 79 05 18 78 86 13 30 63 99 95
39 87 96 28 03 38 42 17 82 87 58 07 22 57
06 17 51 17 07 93 09 07 75 97 95 78 87 08 53
67 66 59 60 88 99 94 65 55 77 55 34 27 53 78 28
76 40 41 04 87 16 09 42 75 69 23 97 30 60 10 79 87
12 10 44 26 21 36 32 84 98 60 13 12 36 16 63 31 91 35
70 39 06 05 55 27 38 48 28 22 34 35 62 62 15 14 94 89 86
66 56 68 84 96 21 34 34 34 81 62 40 65 54 62 05 98 03 02 60
38 89 46 37 99 54 34 53 36 14 70 26 02 90 45 13 31 61 83 73 47
36 10 63 96 60 49 41 05 37 42 14 58 84 93 96 17 09 43 05 43 06 59
66 57 87 57 61 28 37 51 84 73 79 15 39 95 88 87 43 39 11 86 77 74 18
54 42 05 79 30 49 99 73 46 37 50 02 45 09 54 52 27 95 27 65 19 45 26 45
71 39 17 78 76 29 52 90 18 99 78 19 35 62 71 19 23 65 93 85 49 33 75 09 02
33 24 47 61 60 55 32 88 57 55 91 54 46 57 07 77 98 52 80 99 24 25 46 78 79 05
92 09 13 55 10 67 26 78 76 82 63 49 51 31 24 68 05 57 07 54 69 21 67 43 17 63 12
24 59 06 08 98 74 66 26 61 60 13 03 09 09 24 30 71 08 88 70 72 70 29 90 11 82 41 34
66 82 67 04 36 60 92 77 91 85 62 49 59 61 30 90 29 94 26 41 89 04 53 22 83 41 09 74 90
48 28 26 37 28 52 77 26 51 32 18 98 79 36 62 13 17 08 19 54 89 29 73 68 42 14 08 16 70 37
37 60 69 70 72 71 09 59 13 60 38 13 57 36 09 30 43 89 30 39 15 02 44 73 05 73 26 63 56 86 12
55 55 85 50 62 99 84 77 28 85 03 21 27 22 19 26 82 69 54 04 13 07 85 14 01 15 70 59 89 95 10 19
04 09 31 92 91 38 92 86 98 75 21 05 64 42 62 84 36 20 73 42 21 23 22 51 51 79 25 45 85 53 03 43 22
75 63 02 49 14 12 89 14 60 78 92 16 44 82 38 30 72 11 46 52 90 27 08 65 78 03 85 41 57 79 39 52 33 48
78 27 56 56 39 13 19 43 86 72 58 95 39 07 04 34 21 98 39 15 39 84 89 69 84 46 37 57 59 35 59 50 26 15 93
42 89 36 27 78 91 24 11 17 41 05 94 07 69 51 96 03 96 47 90 90 45 91 20 50 56 10 32 36 49 04 53 85 92 25 65
52 09 61 30 61 97 66 21 96 92 98 90 06 34 96 60 32 69 68 33 75 84 18 31 71 50 84 63 03 03 19 11 28 42 75 45 45
61 31 61 68 96 34 49 39 05 71 76 59 62 67 06 47 96 99 34 21 32 47 52 07 71 60 42 72 94 56 82 83 84 40 94 87 82 46
01 20 60 14 17 38 26 78 66 81 45 95 18 51 98 81 48 16 53 88 37 52 69 95 72 93 22 34 98 20 54 27 73 61 56 63 60 34 63
93 42 94 83 47 61 27 51 79 79 45 01 44 73 31 70 83 42 88 25 53 51 30 15 65 94 80 44 61 84 12 77 02 62 02 65 94 42 14 94
32 73 09 67 68 29 74 98 10 19 85 48 38 31 85 67 53 93 93 77 47 67 39 72 94 53 18 43 77 40 78 32 29 59 24 06 02 83 50 60 66
32 01 44 30 16 51 15 81 98 15 10 62 86 79 50 62 45 60 70 38 31 85 65 61 64 06 69 84 14 22 56 43 09 48 66 69 83 91 60 40 36 61
92 48 22 99 15 95 64 43 01 16 94 02 99 19 17 69 11 58 97 56 89 31 77 45 67 96 12 73 08 20 36 47 81 44 50 64 68 85 40 81 85 52 09
91 35 92 45 32 84 62 15 19 64 21 66 06 01 52 80 62 59 12 25 88 28 91 50 40 16 22 99 92 79 87 51 21 77 74 77 07 42 38 42 74 83 02 05
46 19 77 66 24 18 05 32 02 84 31 99 92 58 96 72 91 36 62 99 55 29 53 42 12 37 26 58 89 50 66 19 82 75 12 48 24 87 91 85 02 07 03 76 86
99 98 84 93 07 17 33 61 92 20 66 60 24 66 40 30 67 05 37 29 24 96 03 27 70 62 13 04 45 47 59 88 43 20 66 15 46 92 30 04 71 66 78 70 53 99
67 60 38 06 88 04 17 72 10 99 71 07 42 25 54 05 26 64 91 50 45 71 06 30 67 48 69 82 08 56 80 67 18 46 66 63 01 20 08 80 47 07 91 16 03 79 87
18 54 78 49 80 48 77 40 68 23 60 88 58 80 33 57 11 69 55 53 64 02 94 49 60 92 16 35 81 21 82 96 25 24 96 18 02 05 49 03 50 77 06 32 84 27 18 38
68 01 50 04 03 21 42 94 53 24 89 05 92 26 52 36 68 11 85 01 04 42 02 45 15 06 50 04 53 73 25 74 81 88 98 21 67 84 79 97 99 20 95 04 40 46 02 58 87
94 10 02 78 88 52 21 03 88 60 06 53 49 71 20 91 12 65 07 49 21 22 11 41 58 99 36 16 09 48 17 24 52 36 23 15 72 16 84 56 02 99 43 76 81 71 29 39 49 17
64 39 59 84 86 16 17 66 03 09 43 06 64 18 63 29 68 06 23 07 87 14 26 35 17 12 98 41 53 64 78 18 98 27 28 84 80 67 75 62 10 11 76 90 54 10 05 54 41 39 66
43 83 18 37 32 31 52 29 95 47 08 76 35 11 04 53 35 43 34 10 52 57 12 36 20 39 40 55 78 44 07 31 38 26 08 15 56 88 86 01 52 62 10 24 32 05 60 65 53 28 57 99
03 50 03 52 07 73 49 92 66 80 01 46 08 67 25 36 73 93 07 42 25 53 13 96 76 83 87 90 54 89 78 22 78 91 73 51 69 09 79 94 83 53 09 40 69 62 10 79 49 47 03 81 30
71 54 73 33 51 76 59 54 79 37 56 45 84 17 62 21 98 69 41 95 65 24 39 37 62 03 24 48 54 64 46 82 71 78 33 67 09 16 96 68 52 74 79 68 32 21 13 78 96 60 09 69 20 36
73 26 21 44 46 38 17 83 65 98 07 23 52 46 61 97 33 13 60 31 70 15 36 77 31 58 56 93 75 68 21 36 69 53 90 75 25 82 39 50 65 94 29 30 11 33 11 13 96 02 56 47 07 49 02
76 46 73 30 10 20 60 70 14 56 34 26 37 39 48 24 55 76 84 91 39 86 95 61 50 14 53 93 64 67 37 31 10 84 42 70 48 20 10 72 60 61 84 79 69 65 99 73 89 25 85 48 92 56 97 16
03 14 80 27 22 30 44 27 67 75 79 32 51 54 81 29 65 14 19 04 13 82 04 91 43 40 12 52 29 99 07 76 60 25 01 07 61 71 37 92 40 47 99 66 57 01 43 44 22 40 53 53 09 69 26 81 07
49 80 56 90 93 87 47 13 75 28 87 23 72 79 32 18 27 20 28 10 37 59 21 18 70 04 79 96 03 31 45 71 81 06 14 18 17 05 31 50 92 79 23 47 09 39 47 91 43 54 69 47 42 95 62 46 32 85
37 18 62 85 87 28 64 05 77 51 47 26 30 65 05 70 65 75 59 80 42 52 25 20 44 10 92 17 71 95 52 14 77 13 24 55 11 65 26 91 01 30 63 15 49 48 41 17 67 47 03 68 20 90 98 32 04 40 68
90 51 58 60 06 55 23 68 05 19 76 94 82 36 96 43 38 90 87 28 33 83 05 17 70 83 96 93 06 04 78 47 80 06 23 84 75 23 87 72 99 14 50 98 92 38 90 64 61 58 76 94 36 66 87 80 51 35 61 38
57 95 64 06 53 36 82 51 40 33 47 14 07 98 78 65 39 58 53 06 50 53 04 69 40 68 36 69 75 78 75 60 03 32 39 24 74 47 26 90 13 40 44 71 90 76 51 24 36 50 25 45 70 80 61 80 61 43 90 64 11
18 29 86 56 68 42 79 10 42 44 30 12 96 18 23 18 52 59 02 99 67 46 60 86 43 38 55 17 44 93 42 21 55 14 47 34 55 16 49 24 23 29 96 51 55 10 46 53 27 92 27 46 63 57 30 65 43 27 21 20 24 83
81 72 93 19 69 52 48 01 13 83 92 69 20 48 69 59 20 62 05 42 28 89 90 99 32 72 84 17 08 87 36 03 60 31 36 36 81 26 97 36 48 54 56 56 27 16 91 08 23 11 87 99 33 47 02 14 44 73 70 99 43 35 33
90 56 61 86 56 12 70 59 63 32 01 15 81 47 71 76 95 32 65 80 54 70 34 51 40 45 33 04 64 55 78 68 88 47 31 47 68 87 03 84 23 44 89 72 35 08 31 76 63 26 90 85 96 67 65 91 19 14 17 86 04 71 32 95
37 13 04 22 64 37 37 28 56 62 86 33 07 37 10 44 52 82 52 06 19 52 57 75 90 26 91 24 06 21 14 67 76 30 46 14 35 89 89 41 03 64 56 97 87 63 22 34 03 79 17 45 11 53 25 56 96 61 23 18 63 31 37 37 47
77 23 26 70 72 76 77 04 28 64 71 69 14 85 96 54 95 48 06 62 99 83 86 77 97 75 71 66 30 19 57 90 33 01 60 61 14 12 90 99 32 77 56 41 18 14 87 49 10 14 90 64 18 50 21 74 14 16 88 05 45 73 82 47 74 44
22 97 41 13 34 31 54 61 56 94 03 24 59 27 98 77 04 09 37 40 12 26 87 09 71 70 07 18 64 57 80 21 12 71 83 94 60 39 73 79 73 19 97 32 64 29 41 07 48 84 85 67 12 74 95 20 24 52 41 67 56 61 29 93 35 72 69
72 23 63 66 01 11 07 30 52 56 95 16 65 26 83 90 50 74 60 18 16 48 43 77 37 11 99 98 30 94 91 26 62 73 45 12 87 73 47 27 01 88 66 99 21 41 95 80 02 53 23 32 61 48 32 43 43 83 14 66 95 91 19 81 80 67 25 88
08 62 32 18 92 14 83 71 37 96 11 83 39 99 05 16 23 27 10 67 02 25 44 11 55 31 46 64 41 56 44 74 26 81 51 31 45 85 87 09 81 95 22 28 76 69 46 48 64 87 67 76 27 89 31 11 74 16 62 03 60 94 42 47 09 34 94 93 72
56 18 90 18 42 17 42 32 14 86 06 53 33 95 99 35 29 15 44 20 49 59 25 54 34 59 84 21 23 54 35 90 78 16 93 13 37 88 54 19 86 67 68 55 66 84 65 42 98 37 87 56 33 28 58 38 28 38 66 27 52 21 81 15 08 22 97 32 85 27
91 53 40 28 13 34 91 25 01 63 50 37 22 49 71 58 32 28 30 18 68 94 23 83 63 62 94 76 80 41 90 22 82 52 29 12 18 56 10 08 35 14 37 57 23 65 67 40 72 39 93 39 70 89 40 34 07 46 94 22 20 05 53 64 56 30 05 56 61 88 27
23 95 11 12 37 69 68 24 66 10 87 70 43 50 75 07 62 41 83 58 95 93 89 79 45 39 02 22 05 22 95 43 62 11 68 29 17 40 26 44 25 71 87 16 70 85 19 25 59 94 90 41 41 80 61 70 55 60 84 33 95 76 42 63 15 09 03 40 38 12 03 32
09 84 56 80 61 55 85 97 16 94 82 94 98 57 84 30 84 48 93 90 71 05 95 90 73 17 30 98 40 64 65 89 07 79 09 19 56 36 42 30 23 69 73 72 07 05 27 61 24 31 43 48 71 84 21 28 26 65 65 59 65 74 77 20 10 81 61 84 95 08 52 23 70
47 81 28 09 98 51 67 64 35 51 59 36 92 82 77 65 80 24 72 53 22 07 27 10 21 28 30 22 48 82 80 48 56 20 14 43 18 25 50 95 90 31 77 08 09 48 44 80 90 22 93 45 82 17 13 96 25 26 08 73 34 99 06 49 24 06 83 51 40 14 15 10 25 01
54 25 10 81 30 64 24 74 75 80 36 75 82 60 22 69 72 91 45 67 03 62 79 54 89 74 44 83 64 96 66 73 44 30 74 50 37 05 09 97 70 01 60 46 37 91 39 75 75 18 58 52 72 78 51 81 86 52 08 97 01 46 43 66 98 62 81 18 70 93 73 08 32 46 34
96 80 82 07 59 71 92 53 19 20 88 66 03 26 26 10 24 27 50 82 94 73 63 08 51 33 22 45 19 13 58 33 90 15 22 50 36 13 55 06 35 47 82 52 33 61 36 27 28 46 98 14 73 20 73 32 16 26 80 53 47 66 76 38 94 45 02 01 22 52 47 96 64 58 52 39
88 46 23 39 74 63 81 64 20 90 33 33 76 55 58 26 10 46 42 26 74 74 12 83 32 43 09 02 73 55 86 54 85 34 28 23 29 79 91 62 47 41 82 87 99 22 48 90 20 05 96 75 95 04 43 28 81 39 81 01 28 42 78 25 39 77 90 57 58 98 17 36 73 22 63 74 51
29 39 74 94 95 78 64 24 38 86 63 87 93 06 70 92 22 16 80 64 29 52 20 27 23 50 14 13 87 15 72 96 81 22 08 49 72 30 70 24 79 31 16 64 59 21 89 34 96 91 48 76 43 53 88 01 57 80 23 81 90 79 58 01 80 87 17 99 86 90 72 63 32 69 14 28 88 69
37 17 71 95 56 93 71 35 43 45 04 98 92 94 84 96 11 30 31 27 31 60 92 03 48 05 98 91 86 94 35 90 90 08 48 19 33 28 68 37 59 26 65 96 50 68 22 07 09 49 34 31 77 49 43 06 75 17 81 87 61 79 52 26 27 72 29 50 07 98 86 01 17 10 46 64 24 18 56
51 30 25 94 88 85 79 91 40 33 63 84 49 67 98 92 15 26 75 19 82 05 18 78 65 93 61 48 91 43 59 41 70 51 22 15 92 81 67 91 46 98 11 11 65 31 66 10 98 65 83 21 05 56 05 98 73 67 46 74 69 34 08 30 05 52 07 98 32 95 30 94 65 50 24 63 28 81 99 57
19 23 61 36 09 89 71 98 65 17 30 29 89 26 79 74 94 11 44 48 97 54 81 55 39 66 69 45 28 47 13 86 15 76 74 70 84 32 36 33 79 20 78 14 41 47 89 28 81 05 99 66 81 86 38 26 06 25 13 60 54 55 23 53 27 05 89 25 23 11 13 54 59 54 56 34 16 24 53 44 06
13 40 57 72 21 15 60 08 04 19 11 98 34 45 09 97 86 71 03 15 56 19 15 44 97 31 90 04 87 87 76 08 12 30 24 62 84 28 12 85 82 53 99 52 13 94 06 65 97 86 09 50 94 68 69 74 30 67 87 94 63 07 78 27 80 36 69 41 06 92 32 78 37 82 30 05 18 87 99 72 19 99
44 20 55 77 69 91 27 31 28 81 80 27 02 07 97 23 95 98 12 25 75 29 47 71 07 47 78 39 41 59 27 76 13 15 66 61 68 35 69 86 16 53 67 63 99 85 41 56 08 28 33 40 94 76 90 85 31 70 24 65 84 65 99 82 19 25 54 37 21 46 33 02 52 99 51 33 26 04 87 02 08 18 96
54 42 61 45 91 06 64 79 80 82 32 16 83 63 42 49 19 78 65 97 40 42 14 61 49 34 04 18 25 98 59 30 82 72 26 88 54 36 21 75 03 88 99 53 46 51 55 78 22 94 34 40 68 87 84 25 30 76 25 08 92 84 42 61 40 38 09 99 40 23 29 39 46 55 10 90 35 84 56 70 63 23 91 39
52 92 03 71 89 07 09 37 68 66 58 20 44 92 51 56 13 71 79 99 26 37 02 06 16 67 36 52 58 16 79 73 56 60 59 27 44 77 94 82 20 50 98 33 09 87 94 37 40 83 64 83 58 85 17 76 53 02 83 52 22 27 39 20 48 92 45 21 09 42 24 23 12 37 52 28 50 78 79 20 86 62 73 20 59
54 96 80 15 91 90 99 70 10 09 58 90 93 50 81 99 54 38 36 10 30 11 35 84 16 45 82 18 11 97 36 43 96 79 97 65 40 48 23 19 17 31 64 52 65 65 37 32 65 76 99 79 34 65 79 27 55 33 03 01 33 27 61 28 66 08 04 70 49 46 48 83 01 45 19 96 13 81 14 21 31 79 93 85 50 05
92 92 48 84 59 98 31 53 23 27 15 22 79 95 24 76 05 79 16 93 97 89 38 89 42 83 02 88 94 95 82 21 01 97 48 39 31 78 09 65 50 56 97 61 01 07 65 27 21 23 14 15 80 97 44 78 49 35 33 45 81 74 34 05 31 57 09 38 94 07 69 54 69 32 65 68 46 68 78 90 24 28 49 51 45 86 35
41 63 89 76 87 31 86 09 46 14 87 82 22 29 47 16 13 10 70 72 82 95 48 64 58 43 13 75 42 69 21 12 67 13 64 85 58 23 98 09 37 76 05 22 31 12 66 50 29 99 86 72 45 25 10 28 19 06 90 43 29 31 67 79 46 25 74 14 97 35 76 37 65 46 23 82 06 22 30 76 93 66 94 17 96 13 20 72
63 40 78 08 52 09 90 41 70 28 36 14 46 44 85 96 24 52 58 15 87 37 05 98 99 39 13 61 76 38 44 99 83 74 90 22 53 80 56 98 30 51 63 39 44 30 91 91 04 22 27 73 17 35 53 18 35 45 54 56 27 78 48 13 69 36 44 38 71 25 30 56 15 22 73 43 32 69 59 25 93 83 45 11 34 94 44 39 92
12 36 56 88 13 96 16 12 55 54 11 47 19 78 17 17 68 81 77 51 42 55 99 85 66 27 81 79 93 42 65 61 69 74 14 01 18 56 12 01 58 37 91 22 42 66 83 25 19 04 96 41 25 45 18 69 96 88 36 93 10 12 98 32 44 83 83 04 72 91 04 27 73 07 34 37 71 60 59 31 01 54 54 44 96 93 83 36 04 45
30 18 22 20 42 96 65 79 17 41 55 69 94 81 29 80 91 31 85 25 47 26 43 49 02 99 34 67 99 76 16 14 15 93 08 32 99 44 61 77 67 50 43 55 87 55 53 72 17 46 62 25 50 99 73 05 93 48 17 31 70 80 59 09 44 59 45 13 74 66 58 94 87 73 16 14 85 38 74 99 64 23 79 28 71 42 20 37 82 31 23
51 96 39 65 46 71 56 13 29 68 53 86 45 33 51 49 12 91 21 21 76 85 02 17 98 15 46 12 60 21 88 30 92 83 44 59 42 50 27 88 46 86 94 73 45 54 23 24 14 10 94 21 20 34 23 51 04 83 99 75 90 63 60 16 22 33 83 70 11 32 10 50 29 30 83 46 11 05 31 17 86 42 49 01 44 63 28 60 07 78 95 40
44 61 89 59 04 49 51 27 69 71 46 76 44 04 09 34 56 39 15 06 94 91 75 90 65 27 56 23 74 06 23 33 36 69 14 39 05 34 35 57 33 22 76 46 56 10 61 65 98 09 16 69 04 62 65 18 99 76 49 18 72 66 73 83 82 40 76 31 89 91 27 88 17 35 41 35 32 51 32 67 52 68 74 85 80 57 07 11 62 66 47 22 67
65 37 19 97 26 17 16 24 24 17 50 37 64 82 24 36 32 11 68 34 69 31 32 89 79 93 96 68 49 90 14 23 04 04 67 99 81 74 70 74 36 96 68 09 64 39 88 35 54 89 96 58 66 27 88 97 32 14 06 35 78 20 71 06 85 66 57 02 58 91 72 05 29 56 73 48 86 52 09 93 22 57 79 42 12 01 31 68 17 59 63 76 07 77
73 81 14 13 17 20 11 09 01 83 08 85 91 70 84 63 62 77 37 07 47 01 59 95 39 69 39 21 99 09 87 02 97 16 92 36 74 71 90 66 33 73 73 75 52 91 11 12 26 53 05 26 26 48 61 50 90 65 01 87 42 47 74 35 22 73 24 26 56 70 52 05 48 41 31 18 83 27 21 39 80 85 26 08 44 02 71 07 63 22 05 52 19 08 20
17 25 21 11 72 93 33 49 64 23 53 82 03 13 91 65 85 02 40 05 42 31 77 42 05 36 06 54 04 58 07 76 87 83 25 57 66 12 74 33 85 37 74 32 20 69 03 97 91 68 82 44 19 14 89 28 85 85 80 53 34 87 58 98 88 78 48 65 98 40 11 57 10 67 70 81 60 79 74 72 97 59 79 47 30 20 54 80 89 91 14 05 33 36 79 39
60 85 59 39 60 07 57 76 77 92 06 35 15 72 23 41 45 52 95 18 64 79 86 53 56 31 69 11 91 31 84 50 44 82 22 81 41 40 30 42 30 91 48 94 74 76 64 58 74 25 96 57 14 19 03 99 28 83 15 75 99 01 89 85 79 50 03 95 32 67 44 08 07 41 62 64 29 20 14 76 26 55 48 71 69 66 19 72 44 25 14 01 48 74 12 98 07
64 66 84 24 18 16 27 48 20 14 47 69 30 86 48 40 23 16 61 21 51 50 26 47 35 33 91 28 78 64 43 68 04 79 51 08 19 60 52 95 06 68 46 86 35 97 27 58 04 65 30 58 99 12 12 75 91 39 50 31 42 64 70 04 46 07 98 73 98 93 37 89 77 91 64 71 64 65 66 21 78 62 81 74 42 20 83 70 73 95 78 45 92 27 34 53 71 15
30 11 85 31 34 71 13 48 05 14 44 03 19 67 23 73 19 57 06 90 94 72 57 69 81 62 59 68 88 57 55 69 49 13 07 87 97 80 89 05 71 05 05 26 38 40 16 62 45 99 18 38 98 24 21 26 62 74 69 04 85 57 77 35 58 67 91 79 79 57 86 28 66 34 72 51 76 78 36 95 63 90 08 78 47 63 45 31 22 70 52 48 79 94 15 77 61 67 68
23 33 44 81 80 92 93 75 94 88 23 61 39 76 22 03 28 94 32 06 49 65 41 34 18 23 08 47 62 60 03 63 33 13 80 52 31 54 73 43 70 26 16 69 57 87 83 31 03 93 70 81 47 95 77 44 29 68 39 51 56 59 63 07 25 70 07 77 43 53 64 03 94 42 95 39 18 01 66 21 16 97 20 50 90 16 70 10 95 69 29 06 25 61 41 26 15 59 63 35
*/
//This is done using a breadth first search
//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses
/*
Copyright (C) 2021 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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import java.util.ArrayList;
import java.util.Arrays;
public class Problem67 extends Problem18{
//Setup the list of numbers to check
static{
list = new ArrayList<ArrayList<Integer>>(
Arrays.asList(
new ArrayList<Integer>(Arrays.asList(59)),
new ArrayList<Integer>(Arrays.asList(73, 41)),
new ArrayList<Integer>(Arrays.asList(52, 40, 9)),
new ArrayList<Integer>(Arrays.asList(26, 53, 06, 34)),
new ArrayList<Integer>(Arrays.asList(10, 51, 87, 86, 81)),
new ArrayList<Integer>(Arrays.asList(61, 95, 66, 57, 25, 68)),
new ArrayList<Integer>(Arrays.asList(90, 81, 80, 38, 92, 67, 73)),
new ArrayList<Integer>(Arrays.asList(30, 28, 51, 76, 81, 18, 75, 44)),
new ArrayList<Integer>(Arrays.asList(84, 14, 95, 87, 62, 81, 17, 78, 58)),
new ArrayList<Integer>(Arrays.asList(21, 46, 71, 58, 02, 79, 62, 39, 31, 9)),
new ArrayList<Integer>(Arrays.asList(56, 34, 35, 53, 78, 31, 81, 18, 90, 93, 15)),
new ArrayList<Integer>(Arrays.asList(78, 53, 04, 21, 84, 93, 32, 13, 97, 11, 37, 51)),
new ArrayList<Integer>(Arrays.asList(45, 03, 81, 79, 05, 18, 78, 86, 13, 30, 63, 99, 95)),
new ArrayList<Integer>(Arrays.asList(39, 87, 96, 28, 03, 38, 42, 17, 82, 87, 58, 07, 22, 57)),
new ArrayList<Integer>(Arrays.asList(06, 17, 51, 17, 07, 93, 9, 07, 75, 97, 95, 78, 87, 8, 53)),
new ArrayList<Integer>(Arrays.asList(67, 66, 59, 60, 88, 99, 94, 65, 55, 77, 55, 34, 27, 53, 78, 28)),
new ArrayList<Integer>(Arrays.asList(76, 40, 41, 04, 87, 16, 9, 42, 75, 69, 23, 97, 30, 60, 10, 79, 87)),
new ArrayList<Integer>(Arrays.asList(12, 10, 44, 26, 21, 36, 32, 84, 98, 60, 13, 12, 36, 16, 63, 31, 91, 35)),
new ArrayList<Integer>(Arrays.asList(70, 39, 06, 05, 55, 27, 38, 48, 28, 22, 34, 35, 62, 62, 15, 14, 94, 89, 86)),
new ArrayList<Integer>(Arrays.asList(66, 56, 68, 84, 96, 21, 34, 34, 34, 81, 62, 40, 65, 54, 62, 05, 98, 03, 02, 60)),
new ArrayList<Integer>(Arrays.asList(38, 89, 46, 37, 99, 54, 34, 53, 36, 14, 70, 26, 02, 90, 45, 13, 31, 61, 83, 73, 47)),
new ArrayList<Integer>(Arrays.asList(36, 10, 63, 96, 60, 49, 41, 05, 37, 42, 14, 58, 84, 93, 96, 17, 9, 43, 05, 43, 06, 59)),
new ArrayList<Integer>(Arrays.asList(66, 57, 87, 57, 61, 28, 37, 51, 84, 73, 79, 15, 39, 95, 88, 87, 43, 39, 11, 86, 77, 74, 18)),
new ArrayList<Integer>(Arrays.asList(54, 42, 05, 79, 30, 49, 99, 73, 46, 37, 50, 02, 45, 9, 54, 52, 27, 95, 27, 65, 19, 45, 26, 45)),
new ArrayList<Integer>(Arrays.asList(71, 39, 17, 78, 76, 29, 52, 90, 18, 99, 78, 19, 35, 62, 71, 19, 23, 65, 93, 85, 49, 33, 75, 9, 02)),
new ArrayList<Integer>(Arrays.asList(33, 24, 47, 61, 60, 55, 32, 88, 57, 55, 91, 54, 46, 57, 07, 77, 98, 52, 80, 99, 24, 25, 46, 78, 79, 05)),
new ArrayList<Integer>(Arrays.asList(92, 9, 13, 55, 10, 67, 26, 78, 76, 82, 63, 49, 51, 31, 24, 68, 05, 57, 07, 54, 69, 21, 67, 43, 17, 63, 12)),
new ArrayList<Integer>(Arrays.asList(24, 59, 06, 8, 98, 74, 66, 26, 61, 60, 13, 03, 9, 9, 24, 30, 71, 8, 88, 70, 72, 70, 29, 90, 11, 82, 41, 34)),
new ArrayList<Integer>(Arrays.asList(66, 82, 67, 04, 36, 60, 92, 77, 91, 85, 62, 49, 59, 61, 30, 90, 29, 94, 26, 41, 89, 04, 53, 22, 83, 41, 9, 74, 90)),
new ArrayList<Integer>(Arrays.asList(48, 28, 26, 37, 28, 52, 77, 26, 51, 32, 18, 98, 79, 36, 62, 13, 17, 8, 19, 54, 89, 29, 73, 68, 42, 14, 8, 16, 70, 37)),
new ArrayList<Integer>(Arrays.asList(37, 60, 69, 70, 72, 71, 9, 59, 13, 60, 38, 13, 57, 36, 9, 30, 43, 89, 30, 39, 15, 02, 44, 73, 05, 73, 26, 63, 56, 86, 12)),
new ArrayList<Integer>(Arrays.asList(55, 55, 85, 50, 62, 99, 84, 77, 28, 85, 03, 21, 27, 22, 19, 26, 82, 69, 54, 04, 13, 07, 85, 14, 01, 15, 70, 59, 89, 95, 10, 19)),
new ArrayList<Integer>(Arrays.asList(04, 9, 31, 92, 91, 38, 92, 86, 98, 75, 21, 05, 64, 42, 62, 84, 36, 20, 73, 42, 21, 23, 22, 51, 51, 79, 25, 45, 85, 53, 03, 43, 22)),
new ArrayList<Integer>(Arrays.asList(75, 63, 02, 49, 14, 12, 89, 14, 60, 78, 92, 16, 44, 82, 38, 30, 72, 11, 46, 52, 90, 27, 8, 65, 78, 03, 85, 41, 57, 79, 39, 52, 33, 48)),
new ArrayList<Integer>(Arrays.asList(78, 27, 56, 56, 39, 13, 19, 43, 86, 72, 58, 95, 39, 07, 04, 34, 21, 98, 39, 15, 39, 84, 89, 69, 84, 46, 37, 57, 59, 35, 59, 50, 26, 15, 93)),
new ArrayList<Integer>(Arrays.asList(42, 89, 36, 27, 78, 91, 24, 11, 17, 41, 05, 94, 07, 69, 51, 96, 03, 96, 47, 90, 90, 45, 91, 20, 50, 56, 10, 32, 36, 49, 04, 53, 85, 92, 25, 65)),
new ArrayList<Integer>(Arrays.asList(52, 9, 61, 30, 61, 97, 66, 21, 96, 92, 98, 90, 06, 34, 96, 60, 32, 69, 68, 33, 75, 84, 18, 31, 71, 50, 84, 63, 03, 03, 19, 11, 28, 42, 75, 45, 45)),
new ArrayList<Integer>(Arrays.asList(61, 31, 61, 68, 96, 34, 49, 39, 05, 71, 76, 59, 62, 67, 06, 47, 96, 99, 34, 21, 32, 47, 52, 07, 71, 60, 42, 72, 94, 56, 82, 83, 84, 40, 94, 87, 82, 46)),
new ArrayList<Integer>(Arrays.asList(01, 20, 60, 14, 17, 38, 26, 78, 66, 81, 45, 95, 18, 51, 98, 81, 48, 16, 53, 88, 37, 52, 69, 95, 72, 93, 22, 34, 98, 20, 54, 27, 73, 61, 56, 63, 60, 34, 63)),
new ArrayList<Integer>(Arrays.asList(93, 42, 94, 83, 47, 61, 27, 51, 79, 79, 45, 01, 44, 73, 31, 70, 83, 42, 88, 25, 53, 51, 30, 15, 65, 94, 80, 44, 61, 84, 12, 77, 02, 62, 02, 65, 94, 42, 14, 94)),
new ArrayList<Integer>(Arrays.asList(32, 73, 9, 67, 68, 29, 74, 98, 10, 19, 85, 48, 38, 31, 85, 67, 53, 93, 93, 77, 47, 67, 39, 72, 94, 53, 18, 43, 77, 40, 78, 32, 29, 59, 24, 06, 02, 83, 50, 60, 66)),
new ArrayList<Integer>(Arrays.asList(32, 01, 44, 30, 16, 51, 15, 81, 98, 15, 10, 62, 86, 79, 50, 62, 45, 60, 70, 38, 31, 85, 65, 61, 64, 06, 69, 84, 14, 22, 56, 43, 9, 48, 66, 69, 83, 91, 60, 40, 36, 61)),
new ArrayList<Integer>(Arrays.asList(92, 48, 22, 99, 15, 95, 64, 43, 01, 16, 94, 02, 99, 19, 17, 69, 11, 58, 97, 56, 89, 31, 77, 45, 67, 96, 12, 73, 8, 20, 36, 47, 81, 44, 50, 64, 68, 85, 40, 81, 85, 52, 9)),
new ArrayList<Integer>(Arrays.asList(91, 35, 92, 45, 32, 84, 62, 15, 19, 64, 21, 66, 06, 01, 52, 80, 62, 59, 12, 25, 88, 28, 91, 50, 40, 16, 22, 99, 92, 79, 87, 51, 21, 77, 74, 77, 07, 42, 38, 42, 74, 83, 02, 05)),
new ArrayList<Integer>(Arrays.asList(46, 19, 77, 66, 24, 18, 05, 32, 02, 84, 31, 99, 92, 58, 96, 72, 91, 36, 62, 99, 55, 29, 53, 42, 12, 37, 26, 58, 89, 50, 66, 19, 82, 75, 12, 48, 24, 87, 91, 85, 02, 07, 03, 76, 86)),
new ArrayList<Integer>(Arrays.asList(99, 98, 84, 93, 07, 17, 33, 61, 92, 20, 66, 60, 24, 66, 40, 30, 67, 05, 37, 29, 24, 96, 03, 27, 70, 62, 13, 04, 45, 47, 59, 88, 43, 20, 66, 15, 46, 92, 30, 04, 71, 66, 78, 70, 53, 99)),
new ArrayList<Integer>(Arrays.asList(67, 60, 38, 06, 88, 04, 17, 72, 10, 99, 71, 07, 42, 25, 54, 05, 26, 64, 91, 50, 45, 71, 06, 30, 67, 48, 69, 82, 8, 56, 80, 67, 18, 46, 66, 63, 01, 20, 8, 80, 47, 07, 91, 16, 03, 79, 87)),
new ArrayList<Integer>(Arrays.asList(18, 54, 78, 49, 80, 48, 77, 40, 68, 23, 60, 88, 58, 80, 33, 57, 11, 69, 55, 53, 64, 02, 94, 49, 60, 92, 16, 35, 81, 21, 82, 96, 25, 24, 96, 18, 02, 05, 49, 03, 50, 77, 06, 32, 84, 27, 18, 38)),
new ArrayList<Integer>(Arrays.asList(68, 01, 50, 04, 03, 21, 42, 94, 53, 24, 89, 05, 92, 26, 52, 36, 68, 11, 85, 01, 04, 42, 02, 45, 15, 06, 50, 04, 53, 73, 25, 74, 81, 88, 98, 21, 67, 84, 79, 97, 99, 20, 95, 04, 40, 46, 02, 58, 87)),
new ArrayList<Integer>(Arrays.asList(94, 10, 02, 78, 88, 52, 21, 03, 88, 60, 06, 53, 49, 71, 20, 91, 12, 65, 07, 49, 21, 22, 11, 41, 58, 99, 36, 16, 9, 48, 17, 24, 52, 36, 23, 15, 72, 16, 84, 56, 02, 99, 43, 76, 81, 71, 29, 39, 49, 17)),
new ArrayList<Integer>(Arrays.asList(64, 39, 59, 84, 86, 16, 17, 66, 03, 9, 43, 06, 64, 18, 63, 29, 68, 06, 23, 07, 87, 14, 26, 35, 17, 12, 98, 41, 53, 64, 78, 18, 98, 27, 28, 84, 80, 67, 75, 62, 10, 11, 76, 90, 54, 10, 05, 54, 41, 39, 66)),
new ArrayList<Integer>(Arrays.asList(43, 83, 18, 37, 32, 31, 52, 29, 95, 47, 8, 76, 35, 11, 04, 53, 35, 43, 34, 10, 52, 57, 12, 36, 20, 39, 40, 55, 78, 44, 07, 31, 38, 26, 8, 15, 56, 88, 86, 01, 52, 62, 10, 24, 32, 05, 60, 65, 53, 28, 57, 99)),
new ArrayList<Integer>(Arrays.asList(03, 50, 03, 52, 07, 73, 49, 92, 66, 80, 01, 46, 8, 67, 25, 36, 73, 93, 07, 42, 25, 53, 13, 96, 76, 83, 87, 90, 54, 89, 78, 22, 78, 91, 73, 51, 69, 9, 79, 94, 83, 53, 9, 40, 69, 62, 10, 79, 49, 47, 03, 81, 30)),
new ArrayList<Integer>(Arrays.asList(71, 54, 73, 33, 51, 76, 59, 54, 79, 37, 56, 45, 84, 17, 62, 21, 98, 69, 41, 95, 65, 24, 39, 37, 62, 03, 24, 48, 54, 64, 46, 82, 71, 78, 33, 67, 9, 16, 96, 68, 52, 74, 79, 68, 32, 21, 13, 78, 96, 60, 9, 69, 20, 36)),
new ArrayList<Integer>(Arrays.asList(73, 26, 21, 44, 46, 38, 17, 83, 65, 98, 07, 23, 52, 46, 61, 97, 33, 13, 60, 31, 70, 15, 36, 77, 31, 58, 56, 93, 75, 68, 21, 36, 69, 53, 90, 75, 25, 82, 39, 50, 65, 94, 29, 30, 11, 33, 11, 13, 96, 02, 56, 47, 07, 49, 02)),
new ArrayList<Integer>(Arrays.asList(76, 46, 73, 30, 10, 20, 60, 70, 14, 56, 34, 26, 37, 39, 48, 24, 55, 76, 84, 91, 39, 86, 95, 61, 50, 14, 53, 93, 64, 67, 37, 31, 10, 84, 42, 70, 48, 20, 10, 72, 60, 61, 84, 79, 69, 65, 99, 73, 89, 25, 85, 48, 92, 56, 97, 16)),
new ArrayList<Integer>(Arrays.asList(03, 14, 80, 27, 22, 30, 44, 27, 67, 75, 79, 32, 51, 54, 81, 29, 65, 14, 19, 04, 13, 82, 04, 91, 43, 40, 12, 52, 29, 99, 07, 76, 60, 25, 01, 07, 61, 71, 37, 92, 40, 47, 99, 66, 57, 01, 43, 44, 22, 40, 53, 53, 9, 69, 26, 81, 07)),
new ArrayList<Integer>(Arrays.asList(49, 80, 56, 90, 93, 87, 47, 13, 75, 28, 87, 23, 72, 79, 32, 18, 27, 20, 28, 10, 37, 59, 21, 18, 70, 04, 79, 96, 03, 31, 45, 71, 81, 06, 14, 18, 17, 05, 31, 50, 92, 79, 23, 47, 9, 39, 47, 91, 43, 54, 69, 47, 42, 95, 62, 46, 32, 85)),
new ArrayList<Integer>(Arrays.asList(37, 18, 62, 85, 87, 28, 64, 05, 77, 51, 47, 26, 30, 65, 05, 70, 65, 75, 59, 80, 42, 52, 25, 20, 44, 10, 92, 17, 71, 95, 52, 14, 77, 13, 24, 55, 11, 65, 26, 91, 01, 30, 63, 15, 49, 48, 41, 17, 67, 47, 03, 68, 20, 90, 98, 32, 04, 40, 68)),
new ArrayList<Integer>(Arrays.asList(90, 51, 58, 60, 06, 55, 23, 68, 05, 19, 76, 94, 82, 36, 96, 43, 38, 90, 87, 28, 33, 83, 05, 17, 70, 83, 96, 93, 06, 04, 78, 47, 80, 06, 23, 84, 75, 23, 87, 72, 99, 14, 50, 98, 92, 38, 90, 64, 61, 58, 76, 94, 36, 66, 87, 80, 51, 35, 61, 38)),
new ArrayList<Integer>(Arrays.asList(57, 95, 64, 06, 53, 36, 82, 51, 40, 33, 47, 14, 07, 98, 78, 65, 39, 58, 53, 06, 50, 53, 04, 69, 40, 68, 36, 69, 75, 78, 75, 60, 03, 32, 39, 24, 74, 47, 26, 90, 13, 40, 44, 71, 90, 76, 51, 24, 36, 50, 25, 45, 70, 80, 61, 80, 61, 43, 90, 64, 11)),
new ArrayList<Integer>(Arrays.asList(18, 29, 86, 56, 68, 42, 79, 10, 42, 44, 30, 12, 96, 18, 23, 18, 52, 59, 02, 99, 67, 46, 60, 86, 43, 38, 55, 17, 44, 93, 42, 21, 55, 14, 47, 34, 55, 16, 49, 24, 23, 29, 96, 51, 55, 10, 46, 53, 27, 92, 27, 46, 63, 57, 30, 65, 43, 27, 21, 20, 24, 83)),
new ArrayList<Integer>(Arrays.asList(81, 72, 93, 19, 69, 52, 48, 01, 13, 83, 92, 69, 20, 48, 69, 59, 20, 62, 05, 42, 28, 89, 90, 99, 32, 72, 84, 17, 8, 87, 36, 03, 60, 31, 36, 36, 81, 26, 97, 36, 48, 54, 56, 56, 27, 16, 91, 8, 23, 11, 87, 99, 33, 47, 02, 14, 44, 73, 70, 99, 43, 35, 33)),
new ArrayList<Integer>(Arrays.asList(90, 56, 61, 86, 56, 12, 70, 59, 63, 32, 01, 15, 81, 47, 71, 76, 95, 32, 65, 80, 54, 70, 34, 51, 40, 45, 33, 04, 64, 55, 78, 68, 88, 47, 31, 47, 68, 87, 03, 84, 23, 44, 89, 72, 35, 8, 31, 76, 63, 26, 90, 85, 96, 67, 65, 91, 19, 14, 17, 86, 04, 71, 32, 95)),
new ArrayList<Integer>(Arrays.asList(37, 13, 04, 22, 64, 37, 37, 28, 56, 62, 86, 33, 07, 37, 10, 44, 52, 82, 52, 06, 19, 52, 57, 75, 90, 26, 91, 24, 06, 21, 14, 67, 76, 30, 46, 14, 35, 89, 89, 41, 03, 64, 56, 97, 87, 63, 22, 34, 03, 79, 17, 45, 11, 53, 25, 56, 96, 61, 23, 18, 63, 31, 37, 37, 47)),
new ArrayList<Integer>(Arrays.asList(77, 23, 26, 70, 72, 76, 77, 04, 28, 64, 71, 69, 14, 85, 96, 54, 95, 48, 06, 62, 99, 83, 86, 77, 97, 75, 71, 66, 30, 19, 57, 90, 33, 01, 60, 61, 14, 12, 90, 99, 32, 77, 56, 41, 18, 14, 87, 49, 10, 14, 90, 64, 18, 50, 21, 74, 14, 16, 88, 05, 45, 73, 82, 47, 74, 44)),
new ArrayList<Integer>(Arrays.asList(22, 97, 41, 13, 34, 31, 54, 61, 56, 94, 03, 24, 59, 27, 98, 77, 04, 9, 37, 40, 12, 26, 87, 9, 71, 70, 07, 18, 64, 57, 80, 21, 12, 71, 83, 94, 60, 39, 73, 79, 73, 19, 97, 32, 64, 29, 41, 07, 48, 84, 85, 67, 12, 74, 95, 20, 24, 52, 41, 67, 56, 61, 29, 93, 35, 72, 69)),
new ArrayList<Integer>(Arrays.asList(72, 23, 63, 66, 01, 11, 07, 30, 52, 56, 95, 16, 65, 26, 83, 90, 50, 74, 60, 18, 16, 48, 43, 77, 37, 11, 99, 98, 30, 94, 91, 26, 62, 73, 45, 12, 87, 73, 47, 27, 01, 88, 66, 99, 21, 41, 95, 80, 02, 53, 23, 32, 61, 48, 32, 43, 43, 83, 14, 66, 95, 91, 19, 81, 80, 67, 25, 88)),
new ArrayList<Integer>(Arrays.asList( 8, 62, 32, 18, 92, 14, 83, 71, 37, 96, 11, 83, 39, 99, 05, 16, 23, 27, 10, 67, 02, 25, 44, 11, 55, 31, 46, 64, 41, 56, 44, 74, 26, 81, 51, 31, 45, 85, 87, 9, 81, 95, 22, 28, 76, 69, 46, 48, 64, 87, 67, 76, 27, 89, 31, 11, 74, 16, 62, 03, 60, 94, 42, 47, 9, 34, 94, 93, 72)),
new ArrayList<Integer>(Arrays.asList(56, 18, 90, 18, 42, 17, 42, 32, 14, 86, 06, 53, 33, 95, 99, 35, 29, 15, 44, 20, 49, 59, 25, 54, 34, 59, 84, 21, 23, 54, 35, 90, 78, 16, 93, 13, 37, 88, 54, 19, 86, 67, 68, 55, 66, 84, 65, 42, 98, 37, 87, 56, 33, 28, 58, 38, 28, 38, 66, 27, 52, 21, 81, 15, 8, 22, 97, 32, 85, 27)),
new ArrayList<Integer>(Arrays.asList(91, 53, 40, 28, 13, 34, 91, 25, 01, 63, 50, 37, 22, 49, 71, 58, 32, 28, 30, 18, 68, 94, 23, 83, 63, 62, 94, 76, 80, 41, 90, 22, 82, 52, 29, 12, 18, 56, 10, 8, 35, 14, 37, 57, 23, 65, 67, 40, 72, 39, 93, 39, 70, 89, 40, 34, 07, 46, 94, 22, 20, 05, 53, 64, 56, 30, 05, 56, 61, 88, 27)),
new ArrayList<Integer>(Arrays.asList(23, 95, 11, 12, 37, 69, 68, 24, 66, 10, 87, 70, 43, 50, 75, 07, 62, 41, 83, 58, 95, 93, 89, 79, 45, 39, 02, 22, 05, 22, 95, 43, 62, 11, 68, 29, 17, 40, 26, 44, 25, 71, 87, 16, 70, 85, 19, 25, 59, 94, 90, 41, 41, 80, 61, 70, 55, 60, 84, 33, 95, 76, 42, 63, 15, 9, 03, 40, 38, 12, 03, 32)),
new ArrayList<Integer>(Arrays.asList( 9, 84, 56, 80, 61, 55, 85, 97, 16, 94, 82, 94, 98, 57, 84, 30, 84, 48, 93, 90, 71, 05, 95, 90, 73, 17, 30, 98, 40, 64, 65, 89, 07, 79, 9, 19, 56, 36, 42, 30, 23, 69, 73, 72, 07, 05, 27, 61, 24, 31, 43, 48, 71, 84, 21, 28, 26, 65, 65, 59, 65, 74, 77, 20, 10, 81, 61, 84, 95, 8, 52, 23, 70)),
new ArrayList<Integer>(Arrays.asList(47, 81, 28, 9, 98, 51, 67, 64, 35, 51, 59, 36, 92, 82, 77, 65, 80, 24, 72, 53, 22, 07, 27, 10, 21, 28, 30, 22, 48, 82, 80, 48, 56, 20, 14, 43, 18, 25, 50, 95, 90, 31, 77, 8, 9, 48, 44, 80, 90, 22, 93, 45, 82, 17, 13, 96, 25, 26, 8, 73, 34, 99, 06, 49, 24, 06, 83, 51, 40, 14, 15, 10, 25, 01)),
new ArrayList<Integer>(Arrays.asList(54, 25, 10, 81, 30, 64, 24, 74, 75, 80, 36, 75, 82, 60, 22, 69, 72, 91, 45, 67, 03, 62, 79, 54, 89, 74, 44, 83, 64, 96, 66, 73, 44, 30, 74, 50, 37, 05, 9, 97, 70, 01, 60, 46, 37, 91, 39, 75, 75, 18, 58, 52, 72, 78, 51, 81, 86, 52, 8, 97, 01, 46, 43, 66, 98, 62, 81, 18, 70, 93, 73, 8, 32, 46, 34)),
new ArrayList<Integer>(Arrays.asList(96, 80, 82, 07, 59, 71, 92, 53, 19, 20, 88, 66, 03, 26, 26, 10, 24, 27, 50, 82, 94, 73, 63, 8, 51, 33, 22, 45, 19, 13, 58, 33, 90, 15, 22, 50, 36, 13, 55, 06, 35, 47, 82, 52, 33, 61, 36, 27, 28, 46, 98, 14, 73, 20, 73, 32, 16, 26, 80, 53, 47, 66, 76, 38, 94, 45, 02, 01, 22, 52, 47, 96, 64, 58, 52, 39)),
new ArrayList<Integer>(Arrays.asList(88, 46, 23, 39, 74, 63, 81, 64, 20, 90, 33, 33, 76, 55, 58, 26, 10, 46, 42, 26, 74, 74, 12, 83, 32, 43, 9, 02, 73, 55, 86, 54, 85, 34, 28, 23, 29, 79, 91, 62, 47, 41, 82, 87, 99, 22, 48, 90, 20, 05, 96, 75, 95, 04, 43, 28, 81, 39, 81, 01, 28, 42, 78, 25, 39, 77, 90, 57, 58, 98, 17, 36, 73, 22, 63, 74, 51)),
new ArrayList<Integer>(Arrays.asList(29, 39, 74, 94, 95, 78, 64, 24, 38, 86, 63, 87, 93, 06, 70, 92, 22, 16, 80, 64, 29, 52, 20, 27, 23, 50, 14, 13, 87, 15, 72, 96, 81, 22, 8, 49, 72, 30, 70, 24, 79, 31, 16, 64, 59, 21, 89, 34, 96, 91, 48, 76, 43, 53, 88, 01, 57, 80, 23, 81, 90, 79, 58, 01, 80, 87, 17, 99, 86, 90, 72, 63, 32, 69, 14, 28, 88, 69)),
new ArrayList<Integer>(Arrays.asList(37, 17, 71, 95, 56, 93, 71, 35, 43, 45, 04, 98, 92, 94, 84, 96, 11, 30, 31, 27, 31, 60, 92, 03, 48, 05, 98, 91, 86, 94, 35, 90, 90, 8, 48, 19, 33, 28, 68, 37, 59, 26, 65, 96, 50, 68, 22, 07, 9, 49, 34, 31, 77, 49, 43, 06, 75, 17, 81, 87, 61, 79, 52, 26, 27, 72, 29, 50, 07, 98, 86, 01, 17, 10, 46, 64, 24, 18, 56)),
new ArrayList<Integer>(Arrays.asList(51, 30, 25, 94, 88, 85, 79, 91, 40, 33, 63, 84, 49, 67, 98, 92, 15, 26, 75, 19, 82, 05, 18, 78, 65, 93, 61, 48, 91, 43, 59, 41, 70, 51, 22, 15, 92, 81, 67, 91, 46, 98, 11, 11, 65, 31, 66, 10, 98, 65, 83, 21, 05, 56, 05, 98, 73, 67, 46, 74, 69, 34, 8, 30, 05, 52, 07, 98, 32, 95, 30, 94, 65, 50, 24, 63, 28, 81, 99, 57)),
new ArrayList<Integer>(Arrays.asList(19, 23, 61, 36, 9, 89, 71, 98, 65, 17, 30, 29, 89, 26, 79, 74, 94, 11, 44, 48, 97, 54, 81, 55, 39, 66, 69, 45, 28, 47, 13, 86, 15, 76, 74, 70, 84, 32, 36, 33, 79, 20, 78, 14, 41, 47, 89, 28, 81, 05, 99, 66, 81, 86, 38, 26, 06, 25, 13, 60, 54, 55, 23, 53, 27, 05, 89, 25, 23, 11, 13, 54, 59, 54, 56, 34, 16, 24, 53, 44, 06)),
new ArrayList<Integer>(Arrays.asList(13, 40, 57, 72, 21, 15, 60, 8, 04, 19, 11, 98, 34, 45, 9, 97, 86, 71, 03, 15, 56, 19, 15, 44, 97, 31, 90, 04, 87, 87, 76, 8, 12, 30, 24, 62, 84, 28, 12, 85, 82, 53, 99, 52, 13, 94, 06, 65, 97, 86, 9, 50, 94, 68, 69, 74, 30, 67, 87, 94, 63, 07, 78, 27, 80, 36, 69, 41, 06, 92, 32, 78, 37, 82, 30, 05, 18, 87, 99, 72, 19, 99)),
new ArrayList<Integer>(Arrays.asList(44, 20, 55, 77, 69, 91, 27, 31, 28, 81, 80, 27, 02, 07, 97, 23, 95, 98, 12, 25, 75, 29, 47, 71, 07, 47, 78, 39, 41, 59, 27, 76, 13, 15, 66, 61, 68, 35, 69, 86, 16, 53, 67, 63, 99, 85, 41, 56, 8, 28, 33, 40, 94, 76, 90, 85, 31, 70, 24, 65, 84, 65, 99, 82, 19, 25, 54, 37, 21, 46, 33, 02, 52, 99, 51, 33, 26, 04, 87, 02, 8, 18, 96)),
new ArrayList<Integer>(Arrays.asList(54, 42, 61, 45, 91, 06, 64, 79, 80, 82, 32, 16, 83, 63, 42, 49, 19, 78, 65, 97, 40, 42, 14, 61, 49, 34, 04, 18, 25, 98, 59, 30, 82, 72, 26, 88, 54, 36, 21, 75, 03, 88, 99, 53, 46, 51, 55, 78, 22, 94, 34, 40, 68, 87, 84, 25, 30, 76, 25, 8, 92, 84, 42, 61, 40, 38, 9, 99, 40, 23, 29, 39, 46, 55, 10, 90, 35, 84, 56, 70, 63, 23, 91, 39)),
new ArrayList<Integer>(Arrays.asList(52, 92, 03, 71, 89, 07, 9, 37, 68, 66, 58, 20, 44, 92, 51, 56, 13, 71, 79, 99, 26, 37, 02, 06, 16, 67, 36, 52, 58, 16, 79, 73, 56, 60, 59, 27, 44, 77, 94, 82, 20, 50, 98, 33, 9, 87, 94, 37, 40, 83, 64, 83, 58, 85, 17, 76, 53, 02, 83, 52, 22, 27, 39, 20, 48, 92, 45, 21, 9, 42, 24, 23, 12, 37, 52, 28, 50, 78, 79, 20, 86, 62, 73, 20, 59)),
new ArrayList<Integer>(Arrays.asList(54, 96, 80, 15, 91, 90, 99, 70, 10, 9, 58, 90, 93, 50, 81, 99, 54, 38, 36, 10, 30, 11, 35, 84, 16, 45, 82, 18, 11, 97, 36, 43, 96, 79, 97, 65, 40, 48, 23, 19, 17, 31, 64, 52, 65, 65, 37, 32, 65, 76, 99, 79, 34, 65, 79, 27, 55, 33, 03, 01, 33, 27, 61, 28, 66, 8, 04, 70, 49, 46, 48, 83, 01, 45, 19, 96, 13, 81, 14, 21, 31, 79, 93, 85, 50, 05)),
new ArrayList<Integer>(Arrays.asList(92, 92, 48, 84, 59, 98, 31, 53, 23, 27, 15, 22, 79, 95, 24, 76, 05, 79, 16, 93, 97, 89, 38, 89, 42, 83, 02, 88, 94, 95, 82, 21, 01, 97, 48, 39, 31, 78, 9, 65, 50, 56, 97, 61, 01, 07, 65, 27, 21, 23, 14, 15, 80, 97, 44, 78, 49, 35, 33, 45, 81, 74, 34, 05, 31, 57, 9, 38, 94, 07, 69, 54, 69, 32, 65, 68, 46, 68, 78, 90, 24, 28, 49, 51, 45, 86, 35)),
new ArrayList<Integer>(Arrays.asList(41, 63, 89, 76, 87, 31, 86, 9, 46, 14, 87, 82, 22, 29, 47, 16, 13, 10, 70, 72, 82, 95, 48, 64, 58, 43, 13, 75, 42, 69, 21, 12, 67, 13, 64, 85, 58, 23, 98, 9, 37, 76, 05, 22, 31, 12, 66, 50, 29, 99, 86, 72, 45, 25, 10, 28, 19, 06, 90, 43, 29, 31, 67, 79, 46, 25, 74, 14, 97, 35, 76, 37, 65, 46, 23, 82, 06, 22, 30, 76, 93, 66, 94, 17, 96, 13, 20, 72)),
new ArrayList<Integer>(Arrays.asList(63, 40, 78, 8, 52, 9, 90, 41, 70, 28, 36, 14, 46, 44, 85, 96, 24, 52, 58, 15, 87, 37, 05, 98, 99, 39, 13, 61, 76, 38, 44, 99, 83, 74, 90, 22, 53, 80, 56, 98, 30, 51, 63, 39, 44, 30, 91, 91, 04, 22, 27, 73, 17, 35, 53, 18, 35, 45, 54, 56, 27, 78, 48, 13, 69, 36, 44, 38, 71, 25, 30, 56, 15, 22, 73, 43, 32, 69, 59, 25, 93, 83, 45, 11, 34, 94, 44, 39, 92)),
new ArrayList<Integer>(Arrays.asList(12, 36, 56, 88, 13, 96, 16, 12, 55, 54, 11, 47, 19, 78, 17, 17, 68, 81, 77, 51, 42, 55, 99, 85, 66, 27, 81, 79, 93, 42, 65, 61, 69, 74, 14, 01, 18, 56, 12, 01, 58, 37, 91, 22, 42, 66, 83, 25, 19, 04, 96, 41, 25, 45, 18, 69, 96, 88, 36, 93, 10, 12, 98, 32, 44, 83, 83, 04, 72, 91, 04, 27, 73, 07, 34, 37, 71, 60, 59, 31, 01, 54, 54, 44, 96, 93, 83, 36, 04, 45)),
new ArrayList<Integer>(Arrays.asList(30, 18, 22, 20, 42, 96, 65, 79, 17, 41, 55, 69, 94, 81, 29, 80, 91, 31, 85, 25, 47, 26, 43, 49, 02, 99, 34, 67, 99, 76, 16, 14, 15, 93, 8, 32, 99, 44, 61, 77, 67, 50, 43, 55, 87, 55, 53, 72, 17, 46, 62, 25, 50, 99, 73, 05, 93, 48, 17, 31, 70, 80, 59, 9, 44, 59, 45, 13, 74, 66, 58, 94, 87, 73, 16, 14, 85, 38, 74, 99, 64, 23, 79, 28, 71, 42, 20, 37, 82, 31, 23)),
new ArrayList<Integer>(Arrays.asList(51, 96, 39, 65, 46, 71, 56, 13, 29, 68, 53, 86, 45, 33, 51, 49, 12, 91, 21, 21, 76, 85, 02, 17, 98, 15, 46, 12, 60, 21, 88, 30, 92, 83, 44, 59, 42, 50, 27, 88, 46, 86, 94, 73, 45, 54, 23, 24, 14, 10, 94, 21, 20, 34, 23, 51, 04, 83, 99, 75, 90, 63, 60, 16, 22, 33, 83, 70, 11, 32, 10, 50, 29, 30, 83, 46, 11, 05, 31, 17, 86, 42, 49, 01, 44, 63, 28, 60, 07, 78, 95, 40)),
new ArrayList<Integer>(Arrays.asList(44, 61, 89, 59, 04, 49, 51, 27, 69, 71, 46, 76, 44, 04, 9, 34, 56, 39, 15, 06, 94, 91, 75, 90, 65, 27, 56, 23, 74, 06, 23, 33, 36, 69, 14, 39, 05, 34, 35, 57, 33, 22, 76, 46, 56, 10, 61, 65, 98, 9, 16, 69, 04, 62, 65, 18, 99, 76, 49, 18, 72, 66, 73, 83, 82, 40, 76, 31, 89, 91, 27, 88, 17, 35, 41, 35, 32, 51, 32, 67, 52, 68, 74, 85, 80, 57, 07, 11, 62, 66, 47, 22, 67)),
new ArrayList<Integer>(Arrays.asList(65, 37, 19, 97, 26, 17, 16, 24, 24, 17, 50, 37, 64, 82, 24, 36, 32, 11, 68, 34, 69, 31, 32, 89, 79, 93, 96, 68, 49, 90, 14, 23, 04, 04, 67, 99, 81, 74, 70, 74, 36, 96, 68, 9, 64, 39, 88, 35, 54, 89, 96, 58, 66, 27, 88, 97, 32, 14, 06, 35, 78, 20, 71, 06, 85, 66, 57, 02, 58, 91, 72, 05, 29, 56, 73, 48, 86, 52, 9, 93, 22, 57, 79, 42, 12, 01, 31, 68, 17, 59, 63, 76, 07, 77)),
new ArrayList<Integer>(Arrays.asList(73, 81, 14, 13, 17, 20, 11, 9, 01, 83, 8, 85, 91, 70, 84, 63, 62, 77, 37, 07, 47, 01, 59, 95, 39, 69, 39, 21, 99, 9, 87, 02, 97, 16, 92, 36, 74, 71, 90, 66, 33, 73, 73, 75, 52, 91, 11, 12, 26, 53, 05, 26, 26, 48, 61, 50, 90, 65, 01, 87, 42, 47, 74, 35, 22, 73, 24, 26, 56, 70, 52, 05, 48, 41, 31, 18, 83, 27, 21, 39, 80, 85, 26, 8, 44, 02, 71, 07, 63, 22, 05, 52, 19, 8, 20)),
new ArrayList<Integer>(Arrays.asList(17, 25, 21, 11, 72, 93, 33, 49, 64, 23, 53, 82, 03, 13, 91, 65, 85, 02, 40, 05, 42, 31, 77, 42, 05, 36, 06, 54, 04, 58, 07, 76, 87, 83, 25, 57, 66, 12, 74, 33, 85, 37, 74, 32, 20, 69, 03, 97, 91, 68, 82, 44, 19, 14, 89, 28, 85, 85, 80, 53, 34, 87, 58, 98, 88, 78, 48, 65, 98, 40, 11, 57, 10, 67, 70, 81, 60, 79, 74, 72, 97, 59, 79, 47, 30, 20, 54, 80, 89, 91, 14, 05, 33, 36, 79, 39)),
new ArrayList<Integer>(Arrays.asList(60, 85, 59, 39, 60, 07, 57, 76, 77, 92, 06, 35, 15, 72, 23, 41, 45, 52, 95, 18, 64, 79, 86, 53, 56, 31, 69, 11, 91, 31, 84, 50, 44, 82, 22, 81, 41, 40, 30, 42, 30, 91, 48, 94, 74, 76, 64, 58, 74, 25, 96, 57, 14, 19, 03, 99, 28, 83, 15, 75, 99, 01, 89, 85, 79, 50, 03, 95, 32, 67, 44, 8, 07, 41, 62, 64, 29, 20, 14, 76, 26, 55, 48, 71, 69, 66, 19, 72, 44, 25, 14, 01, 48, 74, 12, 98, 07)),
new ArrayList<Integer>(Arrays.asList(64, 66, 84, 24, 18, 16, 27, 48, 20, 14, 47, 69, 30, 86, 48, 40, 23, 16, 61, 21, 51, 50, 26, 47, 35, 33, 91, 28, 78, 64, 43, 68, 04, 79, 51, 8, 19, 60, 52, 95, 06, 68, 46, 86, 35, 97, 27, 58, 04, 65, 30, 58, 99, 12, 12, 75, 91, 39, 50, 31, 42, 64, 70, 04, 46, 07, 98, 73, 98, 93, 37, 89, 77, 91, 64, 71, 64, 65, 66, 21, 78, 62, 81, 74, 42, 20, 83, 70, 73, 95, 78, 45, 92, 27, 34, 53, 71, 15)),
new ArrayList<Integer>(Arrays.asList(30, 11, 85, 31, 34, 71, 13, 48, 05, 14, 44, 03, 19, 67, 23, 73, 19, 57, 06, 90, 94, 72, 57, 69, 81, 62, 59, 68, 88, 57, 55, 69, 49, 13, 07, 87, 97, 80, 89, 05, 71, 05, 05, 26, 38, 40, 16, 62, 45, 99, 18, 38, 98, 24, 21, 26, 62, 74, 69, 04, 85, 57, 77, 35, 58, 67, 91, 79, 79, 57, 86, 28, 66, 34, 72, 51, 76, 78, 36, 95, 63, 90, 8, 78, 47, 63, 45, 31, 22, 70, 52, 48, 79, 94, 15, 77, 61, 67, 68)),
new ArrayList<Integer>(Arrays.asList(23, 33, 44, 81, 80, 92, 93, 75, 94, 88, 23, 61, 39, 76, 22, 03, 28, 94, 32, 06, 49, 65, 41, 34, 18, 23, 8, 47, 62, 60, 03, 63, 33, 13, 80, 52, 31, 54, 73, 43, 70, 26, 16, 69, 57, 87, 83, 31, 03, 93, 70, 81, 47, 95, 77, 44, 29, 68, 39, 51, 56, 59, 63, 07, 25, 70, 07, 77, 43, 53, 64, 03, 94, 42, 95, 39, 18, 01, 66, 21, 16, 97, 20, 50, 90, 16, 70, 10, 95, 69, 29, 06, 25, 61, 41, 26, 15, 59, 63, 35))
));
}
}
/* Results:
The value of the longest path is 7273
It took an average of 187.077 milliseconds to run this problem through 100 iterations
*/

92
src/main/java/com/mattrixwv/project_euler/problems/Problem7.java Normal file
View File

@@ -0,0 +1,92 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem7.java
//Matthew Ellison
// Created: 03-01-19
//Modified: 08-20-22
//What is the 10001th prime number?
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import java.util.ArrayList;
import java.util.List;
import com.mattrixwv.NumberAlgorithms;
public class Problem7 extends Problem{
//Variables
//Static variables
private static final long NUMBER_OF_PRIMES = 10001; //The number of primes we are trying to get
//Instance variables
private List<Long> primes;
//Functions
//Constructor
public Problem7(){
super(String.format("What is the %dth prime number?", NUMBER_OF_PRIMES));
primes = new ArrayList<>();
}
//Operational functions
//Solve the problem
@Override
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 the variables
primes = NumberAlgorithms.getNumPrimes(NUMBER_OF_PRIMES); //Holds the prime numbers
//Stop the timer
timer.stop();
//Throw 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();
primes.clear();
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("The %dth prime number is %d", NUMBER_OF_PRIMES, primes.get(primes.size() - 1));
}
//Returns the requested prime number
public long getPrime(){
solvedCheck("prime");
return primes.get(primes.size() - 1);
}
}
/* Results:
The 10001th prime number is 104743
It took an average of 27.343 milliseconds to run this problem through 100 iterations
*/

126
src/main/java/com/mattrixwv/project_euler/problems/Problem8.java Normal file
View File

@@ -0,0 +1,126 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem8.java
//Matthew Ellison
// Created: 03-28-19
//Modified: 08-20-22
//Find the thirteen adjacent digits in the 1000-digit number that have the greatest product. What is the value of this product?
/*
73167176531330624919225119674426574742355349194934
96983520312774506326239578318016984801869478851843
85861560789112949495459501737958331952853208805511
12540698747158523863050715693290963295227443043557
66896648950445244523161731856403098711121722383113
62229893423380308135336276614282806444486645238749
30358907296290491560440772390713810515859307960866
70172427121883998797908792274921901699720888093776
65727333001053367881220235421809751254540594752243
52584907711670556013604839586446706324415722155397
53697817977846174064955149290862569321978468622482
83972241375657056057490261407972968652414535100474
82166370484403199890008895243450658541227588666881
16427171479924442928230863465674813919123162824586
17866458359124566529476545682848912883142607690042
24219022671055626321111109370544217506941658960408
07198403850962455444362981230987879927244284909188
84580156166097919133875499200524063689912560717606
05886116467109405077541002256983155200055935729725
71636269561882670428252483600823257530420752963450
*/
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
public class Problem8 extends Problem{
//Variables
//Static variables
//The 1000 digit number to check
private static final String NUMBER = "7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450";
//Instance variables
private String maxNums; //Holds the string of the largest product
private long maxProduct; //Holds the largest product of 13 numbers
//Functions
//Constructor
public Problem8(){
super("Find the thirteen adjacent digits in the 1000-digit number that have the greatest product. What is the value of this product?");
maxNums = "";
maxProduct = 0;
}
//Operational functions
//Solve the problem
@Override
public void solve(){
//If the problem has already been solved do nothing and end the function
if(solved){
return;
}
//Start the timer
timer.start();
//Cycle through the string of numbers looking for the maximum product
for(int cnt = 12;cnt < NUMBER.length();++cnt){
long currentProduct = Long.parseLong(NUMBER.substring(cnt - 12, cnt - 11)) * Long.parseLong(NUMBER.substring(cnt - 11, cnt - 10)) * Long.parseLong(NUMBER.substring(cnt - 10, cnt - 9)) * Long.parseLong(NUMBER.substring(cnt - 9, cnt - 8)) * Long.parseLong(NUMBER.substring(cnt - 8, cnt - 7)) * Long.parseLong(NUMBER.substring(cnt - 7, cnt - 6)) * Long.parseLong(NUMBER.substring(cnt - 6, cnt - 5)) * Long.parseLong(NUMBER.substring(cnt - 5, cnt - 4)) * Long.parseLong(NUMBER.substring(cnt - 4, cnt - 3)) * Long.parseLong(NUMBER.substring(cnt - 3, cnt - 2)) * Long.parseLong(NUMBER.substring(cnt - 2, cnt - 1)) * Long.parseLong(NUMBER.substring(cnt - 1, cnt)) * Long.parseLong(NUMBER.substring(cnt, cnt + 1));
//Check if the product is greater than the current maximum
if(currentProduct > maxProduct){
maxNums = NUMBER.substring(cnt - 12, cnt + 1);
maxProduct = currentProduct;
}
}
//Stop the timer
timer.stop();
//Throw 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();
maxNums = "";
maxProduct = 0;
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("The greatest product is %d%nThe numbers are %s", maxProduct, maxNums);
}
//Returns the string of numbers that produces the largest product
public String getLargestNums(){
solvedCheck("numbers that make the largest product");
return maxNums;
}
//Returns the requested product
public long getLargestProduct(){
solvedCheck("product of the numbers");
return maxProduct;
}
}
/* Results:
The greatest product is 23514624000
The numbers are 5576689664895
It took an average of 924.880 microseconds to run this problem through 100 iterations
*/

136
src/main/java/com/mattrixwv/project_euler/problems/Problem9.java Normal file
View File

@@ -0,0 +1,136 @@
//ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem9.java
//Matthew Ellison
// Created: 03-02-19
//Modified: 08-20-22
//There exists exactly one Pythagorean triplet for which a + b + c = 1000. Find the product abc.
//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 <https://www.gnu.org/licenses/>.
*/
package com.mattrixwv.project_euler.problems;
import com.mattrixwv.project_euler.Unsolved;
public class Problem9 extends Problem{
//Variables
//Static variables
private static int GOAL_SUM = 1000; //The number that we want the sum of a, b, and c to equal
//Instance variables
private int a; //The size of the first side
private int b; //The size of the second side
private double c; //The size of the hyp
private boolean found; //A flag to determine if we have found the solution yet
//Functions
//Constructor
public Problem9(){
super(String.format("There exists exactly one Pythagorean triplet for which a + b + c = %d. Find the product abc.", GOAL_SUM));
a = 1;
b = 0;
c = 0;
found = false;
}
//Operational functions
//Solve the problem
@Override
public void solve(){
//If the problem has already been solved do nothing and end the function
if(solved){
return;
}
//Start the timer
timer.start();
//Loop through all possible a's
while((a < GOAL_SUM) && !found){
b = a + 1; //b must be larger than a
c = Math.sqrt((a * a) + (b * b)); //Compute the hyp
//Loop through all possible b's for this a
while((a + b + c) < GOAL_SUM){
++b;
c = Math.sqrt((a * a) + (b * b));
}
//If the sum == 1000 you found the number, otherwise go to the next possible a
if((a + b + c) == GOAL_SUM){
found = true;
}
else{
++a;
}
}
//Stop the timer
timer.stop();
//Throw a flag to show the problem is solved
if(found){
solved = true;
}
else{
throw new Unsolved("The problem was not solved!");
}
}
//Reset the problem so it can be run again
@Override
public void reset(){
super.reset();
a = 1;
b = 0;
c = 0;
found = false;
}
//Gets
//Returns the result of solving the problem
@Override
public String getResult(){
solvedCheck("result");
return String.format("The Pythagorean triplet is %d + %d + %d%nThe numbers' product is %d", a, b, Math.round(c), a * b * Math.round(c));
}
//Returns the length of the first side
public int getSideA(){
solvedCheck("first side");
return a;
}
//Returns the length of the second side
public int getSideB(){
solvedCheck("second side");
return b;
}
//Returns the length of the hyp
public int getSideC(){
solvedCheck("third side");
return (int)c;
}
//Returns the product of the 3 sides
public int getProduct(){
solvedCheck("product of all three sides");
return a * b * (int)c;
}
}
/* Results:
The Pythagorean triplet is 200 + 375 + 425
The numbers' product is 31875000
It took an average of 380.920 microseconds to run this problem through 100 iterations
*/