ProjectEuler/ProjectEulerJava
1
0
Fork 0
mirror of https://bitbucket.org/Mattrixwv/projecteulerjava.git synced 2025-12-07 01:23:56 -05:00
Code Issues Packages Projects Releases Wiki Activity

Changed to maven build and added a wrapper program

Browse Source
This commit is contained in:
Mattrixwv
2020-06-07 17:01:09 -04:00
parent 32a395a2b3
commit 00890ec55d
35 changed files with 722 additions and 357 deletions
Download Patch File Download Diff File Expand all files Collapse all files

191
src/main/java/mattrixwv/ProjectEuler/Driver.java Normal file
View File

@@ -0,0 +1,191 @@
//ProjectEuler/ProjectEulerJava/src/man/java/mattrixwv/ProjectEuler/Driver.java
//Matthew Ellison
// Created: 06-07-20
//Modified: 06-07-20
//This is the driver function for the Java version of the ProjectEuler project
package mattrixwv.ProjectEuler;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
import mattrixwv.ProjectEuler.Problems.*;
public class Driver{
private static final ArrayList<Integer> PROBLEM_NUMBERS = new ArrayList<Integer>(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,
67));
private static enum SELECTIONS{SOLVE, DESCRIPTION, LIST, EXIT, SIZE};
private static final Scanner input = new Scanner(System.in);
public static void main(String[] args){
SELECTIONS selection = SELECTIONS.SIZE; //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 : listProblems(); break;
case EXIT : break;
case SIZE :
default : printErrorMessage();
}
}while(!selection.equals(SELECTIONS.EXIT));
}
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. Exit");
System.out.println();
}
private static SELECTIONS getMenuSelection(){
Integer selection = input.nextInt();
while(!isValidMenu(selection)){
System.out.println("That is an invalid option!Press Enter to continue");
printMenu();
selection = input.nextInt();
}
return getSelection(selection);
}
private static Boolean isValidMenu(Integer selection){
//Ordinal + 1 because enum starts at 0
if((selection > 0) && (selection < (SELECTIONS.SIZE.ordinal() + 1))){
return true;
}
else{
return false;
}
}
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.EXIT; break;
default : sel = SELECTIONS.SIZE;
}
return sel;
}
private static void printErrorMessage(){
System.out.println("That is an invalid selection!");
}
private static void solveMenu(){
Integer problemNumber = 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 < PROBLEM_NUMBERS.size();++problemLocation){
//Solve the problem
System.out.print(PROBLEM_NUMBERS.get(problemLocation).toString() + ". ");
solveProblem(PROBLEM_NUMBERS.get(problemLocation));
}
}
//This is if a single problem number was chosen
else{
//Solve the problem
solveProblem(PROBLEM_NUMBERS.get(problemNumber));
}
}
private static void solveProblem(Integer problemNumber){
//Get the problem
Problem problem = getProblem(problemNumber);
//Print the problem description
String description = problem.getDescription();
System.out.println(description);
//Solve the problem
problem.solve();
//Print the results
System.out.println(problem.getResult() + "\nIt took " + problem.getTime() + " to solve this problem.\n\n");
}
private 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 67 : problem = new Problem67(); break;
}
return problem;
}
private static void descriptionMenu(){
//Give some extra space to print the description
System.out.println("\n");
//Get the problem number
Integer problemNumber = 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 = PROBLEM_NUMBERS.get(1);problemLocation < PROBLEM_NUMBERS.size();++problemLocation){
//Print the problem's description
System.out.print(PROBLEM_NUMBERS.get(problemLocation) + ". ");
printDescription(problemLocation);
System.out.println();
}
}
//Otherwise print out a single problem's description
else{
printDescription(problemNumber);
}
}
private static void printDescription(Integer problemNumber){
//Get the problem
Problem problem = getProblem(problemNumber);
//Print the problem's description
System.out.println(problem.getDescription());
}
private 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;
}
private 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();
}
}

23
src/main/java/mattrixwv/ProjectEuler/Problems/Problem.java Normal file
View File

@@ -0,0 +1,23 @@
package mattrixwv.ProjectEuler.Problems;
import mattrixwv.Stopwatch;
public abstract class Problem{
protected final Stopwatch timer = new Stopwatch(); //To time how long it takes to run the algorithm
protected String result = null; //Holds the results of the problem
private final String description;
Problem(String description){
this.description = description;
}
public String getDescription(){
return description;
}
public String getTime(){
return timer.getStr();
}
public String getResult(){
return result;
}
public abstract void solve();
}

54
src/main/java/mattrixwv/ProjectEuler/Problems/Problem1.java Normal file
View File

@@ -0,0 +1,54 @@
//ProjectEuler/Java/Problem1.java
//Matthew Ellison
// Created: 03-01-19
//Modified: 03-28-19
//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) 2019 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 mattrixwv.ProjectEuler.Problems;
public class Problem1 extends Problem{
//The largest number to be checked
private static final Integer TOP_NUM = 999;
public Problem1(){
super("What is the sum of all the multiples of 3 or 5 that are less than 1000");
}
public void solve(){
Integer sum = 0; //Holds the sum of all the correct elements
//Check every number < 1000 to see if it is a multiple of 3 or 5. If it is add it to the running sum
timer.start();
for(int cnt = 1;cnt <= TOP_NUM;++cnt){
if((cnt % 3) == 0){
sum += cnt;
}
else if((cnt % 5) == 0){
sum += cnt;
}
}
timer.stop();
//Save the results
result = "The sum of all numbers < " + TOP_NUM.toString() + " is " + sum.toString();
}
}
/* Results:
The sum of all numbers < 1000 is 233168
It took 504.226 microseconds to run this algorithm
*/

53
src/main/java/mattrixwv/ProjectEuler/Problems/Problem10.java Normal file
View File

@@ -0,0 +1,53 @@
//ProjectEuler/Java/Problem10.java
//Matthew Ellison
// Created: 03-03-19
//Modified: 03-28-19
//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) 2019 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 mattrixwv.ProjectEuler.Problems;
import mattrixwv.Algorithms;
public class Problem10 extends Problem{
//The largest number to check for primes
private static final Long GOAL_NUMBER = 2000000L;
public Problem10(){
super("Find the sum of all the primes below two million");
}
public void solve(){
//Start the timer
timer.start();
//Get the sum of all prime numbers < GOAL_NUMBER
Long sum = Algorithms.getLongSum(Algorithms.getPrimes(GOAL_NUMBER - 1L)); //Subtract 1 from the number so that it is < the number
//Stop the timer
timer.stop();
//Save the results
result = String.format("The sum of all the primes < %d is %d\n", GOAL_NUMBER, sum);
}
}
/* Results:
*/

193
src/main/java/mattrixwv/ProjectEuler/Problems/Problem11.java Normal file
View File

@@ -0,0 +1,193 @@
//ProjectEuler/Java/Problem11.java
//Matthew Ellison
// Created: 03-03-19
//Modified: 03-28-19
//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) 2019 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 mattrixwv.ProjectEuler.Problems;
import java.util.ArrayList;
import mattrixwv.Algorithms;
public class Problem11 extends Problem{
//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}};;
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?");
}
public void solve(){
//Holds the largest product we have found so far
ArrayList<Integer> greatestProduct = new ArrayList<Integer>();
//Holds the numbers we are currently working on
ArrayList<Integer> currentProduct = new ArrayList<Integer>();
//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(Integer row = 0;row < 20;++row){
for(Integer 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(Algorithms.getProd(currentProduct) > Algorithms.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(Algorithms.getProd(currentProduct) > Algorithms.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(Algorithms.getProd(currentProduct) > Algorithms.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(Algorithms.getProd(currentProduct) > Algorithms.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();
//Save the resutls
result = String.format("The greatest product of 4 numbers in a line is %d\nThe numbers are %s", Algorithms.getProd(greatestProduct), greatestProduct.toString());
}
}
/* Results:
The greatest product of 4 numbers in a line is 70600674
The numbers are [89, 94, 97, 87]
It took 2.442 milliseconds to run this algorithm
*/

73
src/main/java/mattrixwv/ProjectEuler/Problems/Problem12.java Normal file
View File

@@ -0,0 +1,73 @@
//ProjectEuler/Java/Problem12.java
//Matthew Ellison
// Created: 03-04-19
//Modified: 03-28-19
//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) 2019 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 mattrixwv.ProjectEuler.Problems;
import java.util.ArrayList;
import mattrixwv.Algorithms;
public class Problem12 extends Problem{
//The minimum number of divisors that you want
private static final Long GOAL_DIVISORS = 500L;
public Problem12(){
super("What is the value of the first triangle number to have over five hundred divisors?");
}
public void solve(){
//Setup the other variables
Boolean foundNumber = false; //TO flag whether the number has been found
Long sum = 1L;
Long counter = 2L; //The next number to be added to the sum to make a triangular number
ArrayList<Long> divisors = new ArrayList<Long>();
//Start the timer
timer.start();
//Loop until you find the appropriate number
while((!foundNumber) && (sum > 0)){
divisors = Algorithms.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();
//Save the results
result = String.format("The triangulare number %d is the sum of all numbers >= %d and has %d divisors\n", sum, counter - 1, divisors.size());
}
}
/* Results:
The triangulare number 76576500 is the sum of all numbers >= 12375 and has 576 divisors
It took 758.987 milliseconds to run this algorithms
*/

261
src/main/java/mattrixwv/ProjectEuler/Problems/Problem13.java Normal file
View File

@@ -0,0 +1,261 @@
//ProjectEuler/Java/Problem13.java
//Matthew Ellison
// Created: 03-04-19
//Modified: 03-28-19
//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) 2019 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 mattrixwv.ProjectEuler.Problems;
import java.math.BigInteger;
import java.util.ArrayList;
import mattrixwv.Algorithms;
public class Problem13 extends Problem{
public Problem13(){
super("Work out the first ten digits of the sum of the one-hundred 50-digit numbers");
}
public void solve(){
ArrayList<BigInteger> nums = new ArrayList<BigInteger>(); //Holds the numbers that are being summed
//Start the timer
timer.start();
//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"));
//Get the sum of all the numbers
BigInteger sum = Algorithms.getBigSum(nums);
//Stop the timer
timer.stop();
//Save the results
result = String.format("The sum of all %d numbers is %d\nThe first 10 digits of the sum of the numbers is %s\n", nums.size(), sum, (sum.toString()).substring(0, 10));
}
}
/* Results:
The sum of all 100 numbers is 5537376230390876637302048746832985971773659831892672
The first 10 digits of the sum of the numbers is 5537376230
It took 3.185 milliseconds to run this algorithms
*/

86
src/main/java/mattrixwv/ProjectEuler/Problems/Problem14.java Normal file
View File

@@ -0,0 +1,86 @@
//ProjectEuler/Java/Problem14.java
//Matthew Ellison
// Created: 03-04-19
//Modified: 03-28-19
/*
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) 2019 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 mattrixwv.ProjectEuler.Problems;
public class Problem14 extends Problem{
//This is the top number that you will be checking against the series
private static final Long MAX_NUM = 1000000L;
public Problem14(){
super("Which starting number, under one million, produces the longest chain using the itterative sequence?");
}
public void solve(){
//This is the length of the longest chain
Long maxLength = 0L;
//This is teh starting number of the longest chain
Long maxNum = 0L;
//Start the timer
timer.start();
//Loop through all numbers less than 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();
//Save the results
result = String.format("The number %d produced a chain of %d steps\n", maxNum, maxLength);
}
//This function follows the rules of the sequence and returns its length
private static Long checkSeries(Long num){
Long length = 1L; //Start at 1 becuase 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;
}
}
/* Results:
The number 837799 produced a chain of 525 steps
It took 1.006 seconds to run this algorithm
*/

78
src/main/java/mattrixwv/ProjectEuler/Problems/Problem15.java Normal file
View File

@@ -0,0 +1,78 @@
//ProjectEuler/Java/Problem15.java
//Matthew Ellison
// Created: 03-04-19
//Modified: 03-28-19
//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
//This program has not been tested fully and has not even been run to completion because of the long time it takes to run
/*
Copyright (C) 2019 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 mattrixwv.ProjectEuler.Problems;
public class Problem15 extends Problem{
//The width of the box to traverse
private static final Integer WIDTH = 20;
//The height of the box to traverse
private static final Integer LENGTH = 20;
public Problem15(){
super("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?");
}
public void solve(){
//Setup the rest of the variables
Long numOfRoutes = 0L; //The number of routes from 0, 0, to 20, 20
Integer currentX = 0; //The current x location on the grid
Integer currentY = 0; //The current y location on the grid
//Start the timer
timer.start();
//We write this as a recursive function
//When in a location it always moves right first, then down
move(currentX, currentY, numOfRoutes);
//Stop the timer
timer.stop();
//Save the results
result = String.format("The number of routes is " + numOfRoutes.toString());
}
//This function acts as a handler for moving the position on the grid and counting the distance
//It moves right first, then down
private static void move(Integer currentX, Integer currentY, Long numOfRoutes){
//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, numOfRoutes);
}
//Move down if possible
if(currentY < LENGTH){
move(currentX, currentY + 1, numOfRoutes);
}
}
}
/* Results:
*/

69
src/main/java/mattrixwv/ProjectEuler/Problems/Problem16.java Normal file
View File

@@ -0,0 +1,69 @@
//ProjectEuler/Java/Problem16.java
//Matthew Ellison
// Created: 03-04-19
//Modified: 03-28-19
//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) 2019 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 mattrixwv.ProjectEuler.Problems;
import java.math.BigInteger;
public class Problem16 extends Problem{
//The number that is going to be raised to a power
private static final Integer NUM_TO_POWER = 2;
//The power that the number is going to be raised to
private static final Integer POWER = 1000;
public Problem16(){
super("What is the sum of the digits of the number 2^1000?");
}
public void solve(){
//Setup the other variables
BigInteger num = new BigInteger("0"); //The number to be calculated
Integer sumOfElements = 0; //The sum of all digits in the number
//Start the timer
timer.start();
//Get the number
num = BigInteger.valueOf(NUM_TO_POWER.longValue()).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();
//Save the results
result = String.format("%d^%d = %s\nThe sum of the elements is %d\n", NUM_TO_POWER, POWER, num.toString(), sumOfElements.toString());
}
}
/* Results:
2^1000 = 10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831652624386837205668069376
The sum of the elements is 1366
It took 1.104 milliseconds to run this algorithm
*/

211
src/main/java/mattrixwv/ProjectEuler/Problems/Problem17.java Normal file
View File

@@ -0,0 +1,211 @@
//ProjectEuler/Java/Problem16.java
//Matthew Ellison
// Created: 03-04-19
//Modified: 03-28-19
//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) 2019 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 mattrixwv.ProjectEuler.Problems;
public class Problem17 extends Problem{
//The first number to be
private static final Integer START_NUM = 1;
private static final Integer STOP_NUM = 1000;
public Problem17(){
super("If all the numbers from 1 to 1000 (one thousand) inclusive were written out in words, how many letters would be used?");
}
public void solve(){
//Setup the variables needed
Integer sumOfLetters = 0;
//Start the timer
timer.start();
//Start with 1 and increment
for(Integer num = START_NUM;num <= STOP_NUM;++num){
//Pass the number to a function that will create a string for the number
String currentNumString = getStringFromNum(num);
//Pass the string to ta function that will count the number of letters in it, ignoring whitespace and punctuation and add that number to the running tally
sumOfLetters += getNumberChars(currentNumString);
}
//Stop the timer
timer.stop();
//Save the results
result = String.format("The sum of all the letters in all the numbers %d-%d is %d\n", START_NUM, STOP_NUM, sumOfLetters);
}
private String getStringFromNum(Integer number){
String numberString = new String();
//Starting with the largest digit create a string based on teh number passed in
//Check for negative
if(number < 0){
numberString = numberString.concat("negative ");
}
//Check if teh number is zero
if(number == 0){
numberString = numberString.concat("zero");
}
//Start with the thousands place
if((number.doubleValue() / 1000D) >= 1D){
numberString = numberString.concat(getStringFromNum((int)Math.floor(number / 1000D)));
numberString = numberString.concat(" thousand");
number -= ((int)Math.floor(number.doubleValue() / 1000D)) * 1000;
}
//Check the hundreds place
if((number.doubleValue() / 100D) >= 1D){
numberString = numberString.concat(getStringFromNum((int)Math.floor(number.doubleValue() / 100D)));
numberString = numberString.concat(" hundred");
number -= ((int)Math.floor(number.doubleValue() / 100D)) * 100;
}
//Insert an and if there is need
if((!numberString.isBlank() && (number > 0))){
numberString = numberString.concat(" and ");
}
//Check for tens place
if((number.doubleValue() / 10D) >= 2D){
//FOr the tens you need to do something special
Integer tensPlace = (int)Math.floor(number.doubleValue() / 10D);
if(tensPlace == 9){
numberString = numberString.concat("ninety");
}
else if(tensPlace == 8){
numberString = numberString.concat("eighty");
}
else if(tensPlace == 7){
numberString = numberString.concat("seventy");
}
else if(tensPlace == 6){
numberString = numberString.concat("sixty");
}
else if(tensPlace == 5){
numberString = numberString.concat("fifty");
}
else if(tensPlace == 4){
numberString = numberString.concat("forty");
}
else if(tensPlace == 3){
numberString = numberString.concat("thirty");
}
else if(tensPlace == 2){
numberString = numberString.concat("twenty");
}
number -= (tensPlace * 10);
//If there is something left in the number you will need a dash to separate the tens and ones place
if(number > 0){
numberString = numberString.concat("-");
}
}
//Check for teens
else if((number.doubleValue() / 10D) >= 1D){
Integer onesPlace = (number % 10);
if(onesPlace == 9){
numberString = numberString.concat("nineteen");
}
else if(onesPlace == 8){
numberString = numberString.concat("eighteen");
}
else if(onesPlace == 7){
numberString = numberString.concat("seventeen");
}
else if(onesPlace == 6){
numberString = numberString.concat("sixteen");
}
else if(onesPlace == 5){
numberString = numberString.concat("fifteen");
}
else if(onesPlace == 4){
numberString = numberString.concat("fourteen");
}
else if(onesPlace == 3){
numberString = numberString.concat("thirteen");
}
else if(onesPlace == 2){
numberString = numberString.concat("twelve");
}
else if(onesPlace == 1){
numberString = numberString.concat("eleven");
}
else if(onesPlace == 0){
numberString = numberString.concat("ten");
}
//If this was hit the number was completed
number = 0;
}
//Check for the ones place
if(number >= 1){
if(number == 9){
numberString = numberString.concat("nine");
}
else if(number == 8){
numberString = numberString.concat("eight");
}
else if(number == 7){
numberString = numberString.concat("seven");
}
else if(number == 6){
numberString = numberString.concat("six");
}
else if(number == 5){
numberString = numberString.concat("five");
}
else if(number == 4){
numberString = numberString.concat("four");
}
else if(number == 3){
numberString = numberString.concat("three");
}
else if(number == 2){
numberString = numberString.concat("two");
}
else if(number == 1){
numberString = numberString.concat("one");
}
//If this was hit the number was completed
number = 0;
}
//Return the string
return numberString;
}
private Integer getNumberChars(String number){
Integer sumOfLetters = 0;
//Start at location 0 and count the number of letters, ignoring punctuation and whitespace
for(Integer location = 0;location < number.length();++location){
if(Character.isAlphabetic(number.charAt(location))){
sumOfLetters += 1;
}
}
//Return the number of letters
return sumOfLetters;
}
}
/* Results:
The sum of all the letters in all the numbers 1-1000 is 21124
It took 4.862 milliseconds to run this algorithm
*/

165
src/main/java/mattrixwv/ProjectEuler/Problems/Problem18.java Normal file
View File

@@ -0,0 +1,165 @@
//ProjectEuler/Java/Problem18.java
//Matthew Ellison
// Created: 03-11-19
//Modified: 03-28-18
//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) 2019 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 mattrixwv.ProjectEuler.Problems;
import java.util.ArrayList;
import java.util.Arrays;
public class Problem18 extends Problem{
//The number of rows in the array
private static final Integer NUM_ROWS = 15;
//Used to keep track of where the best location came from
private static class location{
public Integer xLocation;
public Integer yLocation;
public Integer total;
//Used originally for debugging so I could trace the path backwards
@SuppressWarnings("unused")
public Boolean fromRight;
location(Integer x, Integer y, Integer t, Boolean r){
xLocation = x;
yLocation = y;
total = t;
fromRight = r;
}
}
public Problem18(){
super("Find the maximum total from top to bottom");
}
//This function turns every number in the array into (100 - num) to allow you to find the largest numbers rather than the smallest
private 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
private void removeHelper(ArrayList<location> possiblePoints, final location minLoc){
possiblePoints.removeIf(loc -> ((loc.xLocation == minLoc.xLocation) && (loc.yLocation == minLoc.yLocation)));
}
public void solve(){
//Start the timer
timer.start();
//Setup the list you are trying to find a path through
ArrayList<ArrayList<Integer>> list = new ArrayList<ArrayList<Integer>>();
list.add(new ArrayList<Integer>(Arrays.asList(75)));
list.add(new ArrayList<Integer>(Arrays.asList(95, 64)));
list.add(new ArrayList<Integer>(Arrays.asList(17, 47, 82)));
list.add(new ArrayList<Integer>(Arrays.asList(18, 35, 87, 10)));
list.add(new ArrayList<Integer>(Arrays.asList(20, 04, 82, 47, 65)));
list.add(new ArrayList<Integer>(Arrays.asList(19, 01, 23, 75, 03, 34)));
list.add(new ArrayList<Integer>(Arrays.asList(88, 02, 77, 73, 07, 63, 67)));
list.add(new ArrayList<Integer>(Arrays.asList(99, 65, 04, 28, 06, 16, 70, 92)));
list.add(new ArrayList<Integer>(Arrays.asList(41, 41, 26, 56, 83, 40, 80, 70, 33)));
list.add(new ArrayList<Integer>(Arrays.asList(41, 48, 72, 33, 47, 32, 37, 16, 94, 29)));
list.add(new ArrayList<Integer>(Arrays.asList(53, 71, 44, 65, 25, 43, 91, 52, 97, 51, 14)));
list.add(new ArrayList<Integer>(Arrays.asList(70, 11, 33, 28, 77, 73, 17, 78, 39, 68, 17, 57)));
list.add(new ArrayList<Integer>(Arrays.asList(91, 71, 52, 38, 17, 14, 91, 43, 58, 50, 27, 29, 48)));
list.add(new ArrayList<Integer>(Arrays.asList(63, 66, 04, 68, 89, 53, 67, 30, 73, 16, 69, 87, 40, 31)));
list.add(new ArrayList<Integer>(Arrays.asList(04, 62, 98, 27, 23, 9, 70, 98, 73, 93, 38, 53, 60, 04, 23)));
//Invert the list
invert(list);
ArrayList<location> foundPoints = new ArrayList<location>(); //For the points that I have already found the shortest distance to
foundPoints.add(new location(0, 0, list.get(0).get(0), false)); //Add the first row as a found point because you have to go through the tip
ArrayList<location> possiblePoints = new ArrayList<location>(); //For the locations you are checking this round
//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
Integer xLoc = minLoc.xLocation;
Integer yLoc = minLoc.yLocation + 1; //Add one because you will always be moving to the next row
if(yLoc >= NUM_ROWS){
foundBottom = true;
}
else{
possiblePoints.add(new location(xLoc, yLoc, minLoc.total + list.get(yLoc).get(xLoc), true));
++xLoc; //Advance the x location to simulate going right
//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));
}
}
}
//Stop the timer
timer.stop();
//Save the results
//Get the correct total which will be the inversion of the current one
Integer actualTotal = ((100 * NUM_ROWS) - foundPoints.get(foundPoints.size() - 1).total);
result = String.format("The value of the longest path is " + actualTotal.toString());
}
}
/* Results:
The value of the longest path is 1074
It took 5.146 milliseconds to run this algorithm
*/

176
src/main/java/mattrixwv/ProjectEuler/Problems/Problem19.java Normal file
View File

@@ -0,0 +1,176 @@
//ProjectEuler/Java/Problem19.java
//Matthew Ellison
// Created: 03-13-19
//Modified: 03-28-19
//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) 2019 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 mattrixwv.ProjectEuler.Problems;
public class Problem19 extends Problem{
private static enum DAYS{SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, NUMBER_OF_DAYS, ERROR};
//The first year we are going to test
private static final Integer START_YEAR = 1901;
//The last year we are going to test
private static final Integer END_YEAR = 2000;
public Problem19(){
super("How many Sundays fell on the first of the month during the twentieth century (1 Jan 1901 to 31 Dec 2000)?");
}
public void solve(){
//The total number of sundays
Long totalSundays = 0L;
//Start the timer
timer.start();
//Run for all years 1901-2000
for(Integer year = START_YEAR;year <= END_YEAR;++year){
//Run for all months in the year
for(Integer 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();
//Save the results
result = String.format("There are %d Sundays that landed on the first of the months from %d to %d\n", totalSundays, START_YEAR, END_YEAR);
}
//Return the day of the week that the date you pass into it is on
private DAYS getDay(Integer month, Integer day, Integer year){
//Make sure the numbers are within propper bounds
if((month < 1) || (month > 12) || (day < 1) || (day > 31) || (year < 1)){
return DAYS.ERROR;
}
Integer numDays = 0;
Integer currentYear = 1;
Integer currentMonth = 1;
Integer currentDay = DAYS.SATURDAY.ordinal();
--day;
//Add teh currect 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){
//February
if(currentMonth == 2){
if(isLeapYear(currentYear)){
numDays += 29;
}
else{
numDays += 28;
}
}
//31 day months
else if((currentMonth == 1) || (currentMonth == 3) || (currentMonth == 5) || (currentMonth == 7) || (currentMonth == 8) || (currentMonth == 10) || (currentMonth == 12)){
numDays += 31;
}
else{
numDays += 30;
}
++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(Integer 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;
}
}
/* Results:
There are 171 Sundays that landed on the first of the months from 1901 to 2000
It took 67.638 milliseconds to run this algorithms
*/

61
src/main/java/mattrixwv/ProjectEuler/Problems/Problem2.java Normal file
View File

@@ -0,0 +1,61 @@
//ProjectEuler/Java/Problem2.java
//Matthew Ellison
// Created: 03-01-19
//Modified: 03-28-19
//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) 2019 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 mattrixwv.ProjectEuler.Problems;
import java.util.ArrayList;
import mattrixwv.Algorithms;
public class Problem2 extends Problem{
//The largest number that will be checked as a fibonacci number
private static final int TOP_NUM = 3999999;
public Problem2(){
super("The sum of the even Fibonacci numbers less than 4,000,000");
}
public void solve(){
timer.start();
//Get a list of all fibonacci numbers < 4,000,000
ArrayList<Integer> fibNums = Algorithms.getAllFib(TOP_NUM);
Integer sum = 0;
//Step through very element in the list checking if it is even
for(Integer num : fibNums){
//If the number is even add it to the running tally
if((num % 2) == 0){
sum += num;
}
}
timer.stop();
//Save the results
result = String.format("The sum of all even fibonacci numbers <= %d is %d\n", TOP_NUM, sum);
}
}
/* Results:
The sum of all even fibonacci numbers <= 3999999 is 4613732
It took 940.825 microseconds to run this algorithm
*/

69
src/main/java/mattrixwv/ProjectEuler/Problems/Problem20.java Normal file
View File

@@ -0,0 +1,69 @@
//ProjectEuler/Java/Problem19.java
//Matthew Ellison
// Created: 03-14-19
//Modified: 03-28-19
//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) 2019 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 mattrixwv.ProjectEuler.Problems;
import java.math.BigInteger;
public class Problem20 extends Problem{
//The largest number that will be multiplied
private static Integer TOP_NUM = 100;
public Problem20(){
super("What is the sum of the digits of 100!?");
}
public void solve(){
//The number that is being generated
BigInteger num = new BigInteger("1");
Long sum = 0L; //The sum of the digits of num
//Start the timer
timer.start();
//Run through every number from 1 to 100 and multiply it by the current num to generate 100!
for(Integer cnt = TOP_NUM;cnt > 1;--cnt){
num = num.multiply(BigInteger.valueOf(cnt));
}
//Get a string of the number because it is easier to pull appart the individucal 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(Integer cnt = 0;cnt < numString.length();++cnt){
Character temp = numString.charAt(cnt);
sum += Integer.valueOf(temp.toString());
}
//Stop the timer
timer.stop();
//Save the results
result = String.format("%d! = %s\nThe sum of the digits is: %d\n", TOP_NUM, num.toString(), sum);
}
}
/* Restuls:
100! = 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000
The sum of the digits is: 648
It took 2.667 milliseconds to run this algorithm
*/

107
src/main/java/mattrixwv/ProjectEuler/Problems/Problem21.java Normal file
View File

@@ -0,0 +1,107 @@
//ProjectEuler/Java/Problem21.java
//Matthew Ellison
// Created: 03-18-19
//Modified: 03-28-19
//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) 2019 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 mattrixwv.ProjectEuler.Problems;
import mattrixwv.Algorithms;
import java.util.ArrayList;
import java.util.Collections;
public class Problem21 extends Problem{
//The number that is > the largest number to be checked
private static final Integer LIMIT = 10000;
public Problem21(){
super("Evaluate the sum of all the amicable numbers under 10000");
}
public void solve(){
//Setup the variables
ArrayList<Integer> divisorSum = new ArrayList<Integer>(); //Holds the sum of the divisors of the subscript number
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);
}
//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){
ArrayList<Integer> divisors = Algorithms.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, Algorithms.getSum(divisors)); //Add the sum of the divisors of the vector
}
//Check every sum of divisors in the list for a matching sum
ArrayList<Integer> amicable = new ArrayList<Integer>();
for(Integer cnt = 1;cnt < divisorSum.size();++cnt){
Integer 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.compareTo(cnt) == 0){
continue;
}
//Add it to the arraylist of amicable numbers
amicable.add(cnt);
}
}
//Stop the timer
timer.stop();
//Sort the arraylist for neatness
Collections.sort(amicable);
//Save the results
result = String.format("All amicable numbers less than %d are\n", LIMIT);
for(int cnt = 0;cnt < amicable.size();++cnt){
result += amicable.get(cnt).toString() + "\n";
}
result = String.format("The sum of all of these amicable numbers is %d\n", Algorithms.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 27.645 milliseconds to run this algorithm
*/

440
src/main/java/mattrixwv/ProjectEuler/Problems/Problem22.java Normal file
View File

@@ -0,0 +1,440 @@
//ProjectEuler/Java/Problem22.java
//Matthew Ellison
// Created: 03-20-19
//Modified: 03-28-19
//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) 2019 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 mattrixwv.ProjectEuler.Problems;
import mattrixwv.Algorithms;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
public class Problem22 extends Problem{
private static 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"));
public Problem22(){
super("What is the total of all the name scores in this file?");
}
public void solve(){
//Setup the variables
ArrayList<Long> sums = new ArrayList<Long>(); //Holds the score based on the sum of the characters in the name
ArrayList<Long> prod = new ArrayList<Long>(); //Holds the score based on the sum of characters and the location in alphabetical order
//Start the timer
timer.start();
//Sort all the names
Collections.sort(names);
//Step through every name adding up the values of the characters
for(Integer 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(Integer 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(Integer cnt = 0;cnt < sums.size();++cnt){
prod.add(sums.get(cnt) * (cnt + 1));
}
//Stop the timer
timer.stop();
//Save the results
result = String.format("The answer to the question is %d\n", Algorithms.getLongSum(prod));
}
}
/* Results:
The answer to the question is 871198282
It took 14.675 milliseconds to run this algorithm
*/

106
src/main/java/mattrixwv/ProjectEuler/Problems/Problem23.java Normal file
View File

@@ -0,0 +1,106 @@
//ProjectEuler/C++/Problem23.java
//Matthew Ellison
// Created: 03-22-19
//Modified: 03-28-19
//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) 2019 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 mattrixwv.ProjectEuler.Problems;
import mattrixwv.Algorithms;
import java.util.ArrayList;
public class Problem23 extends Problem{
//The largest number to be checked
public static final Integer MAX_NUM = 28123;
public Problem23(){
super("Find the sum of all the positive integers which cannot be written as the sum of two abundant numbers");
}
public void solve(){
//Setup the variables
ArrayList<Integer> divisorSums = new ArrayList<Integer>(); //Holds the sum of all the divisors of a number
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
for(int cnt = 0;cnt < MAX_NUM;++cnt){
divisorSums.add(0);
}
divisorSums.add(0);
//Start the timer
timer.start();
//Get the sum of the divisors of all numbers < MAX_NUM
for(Integer cnt = 1;cnt.compareTo(MAX_NUM) < 0;++cnt){
ArrayList<Integer> div = Algorithms.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, Algorithms.getSum(div));
}
//Get the abundant numbers
ArrayList<Integer> abund = new ArrayList<Integer>();
for(Integer cnt = 0;cnt.compareTo(divisorSums.size()) < 0;++cnt){
if(divisorSums.get(cnt) > cnt.longValue()){
abund.add(cnt);
}
}
//Check if each number can be the sum of 2 abundant numbers and add to the sum if no
Long sum = 0L;
for(Integer cnt = 1;cnt.compareTo(MAX_NUM) < 0;++cnt){
if(!isSum(abund, cnt)){
sum += cnt.longValue();
}
}
//Stop the timer
timer.stop();
//Save the results
result = String.format("The answer is %d\n", sum);
}
//A function that returns true if num can be created by adding two elements from abund and false if it cannot
private static Boolean isSum(final ArrayList<Integer> abund, Integer num){
Integer sum = 0;
//Pick a number for the first part of the sum
for(Integer firstNum = 0;firstNum < abund.size();++firstNum){
//Pick a number for the second part of the sum
for(Integer secondNum = firstNum;secondNum < abund.size();++secondNum){
sum = abund.get(firstNum) + abund.get(secondNum);
if(sum.equals(num)){
return true;
}
else if(sum.compareTo(num) > 0){
break;
}
}
}
//If you have run through the entire list and did not find a sum then it is false
return false;
}
}
/* Results:
The answer is 4179871
It took 75.846 seconds to run this algorithm
*/

59
src/main/java/mattrixwv/ProjectEuler/Problems/Problem24.java Normal file
View File

@@ -0,0 +1,59 @@
//ProjectEuler/Java/Problem24.java
//Matthew Ellison
// Created: 03-24-19
//Modified: 03-28-19
//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) 2019 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 mattrixwv.ProjectEuler.Problems;
import mattrixwv.Algorithms;
import java.util.ArrayList;
public class Problem24 extends Problem{
//The number of the permutation I need
private static final Integer NEEDED_PERM = 1000000; //The number of the permutation that you need
public Problem24(){
super("What is the millionth lexicographic permutation of the digits 0, 1, 2, 3, 4, 5, 6, 7, 8 and 9?");
}
public void solve(){
//Setup the variables
String nums = "0123456789"; //The string that you are trying to find the permutations of
//Start the timer
timer.start();
//Get all the permutations of the string
ArrayList<String> permutations = Algorithms.getPermutations(nums);
//Stop the timer
timer.stop();
//Save the results
result = String.format("The 1 millionth permutation is %s\n", permutations.get(NEEDED_PERM - 1));
}
}
/* Results
The 1 millionth permutation is 2783915460
It took 1.503 seconds to run this algorithm
*/

64
src/main/java/mattrixwv/ProjectEuler/Problems/Problem25.java Normal file
View File

@@ -0,0 +1,64 @@
//ProjectEuler/Java/Problem25.java
//Matthew Ellison
// Created: 03-25-19
//Modified: 03-28-19
//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) 2019 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 mattrixwv.ProjectEuler.Problems;
import mattrixwv.Algorithms;
import java.math.BigInteger;
public class Problem25 extends Problem{
//The number of digits to calculate up to
private static final Integer NUM_DIGITS = 1000;
public Problem25(){
super("What is the index of the first term in the Fibonacci sequence to contain 1000 digits?");
}
public void solve(){
//Setup the variables
BigInteger number = BigInteger.ZERO; //Holds the current Fibonacci number
BigInteger index = BigInteger.valueOf(2L); //The index of the Fibonacci number just calculated
//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 = Algorithms.getFib(index); //Calculate the number
}
//Stop the timer
timer.stop();
//Save the results
result = String.format("The first Fibonacci number with %d digits is %s\nIts index is %d\n", NUM_DIGITS, number.toString(), index);
}
}
/* Results:
The first Fibonacci number with 1000 digits is 1070066266382758936764980584457396885083683896632151665013235203375314520604694040621889147582489792657804694888177591957484336466672569959512996030461262748092482186144069433051234774442750273781753087579391666192149259186759553966422837148943113074699503439547001985432609723067290192870526447243726117715821825548491120525013201478612965931381792235559657452039506137551467837543229119602129934048260706175397706847068202895486902666185435124521900369480641357447470911707619766945691070098024393439617474103736912503231365532164773697023167755051595173518460579954919410967778373229665796581646513903488154256310184224190259846088000110186255550245493937113651657039447629584714548523425950428582425306083544435428212611008992863795048006894330309773217834864543113205765659868456288616808718693835297350643986297640660000723562917905207051164077614812491885830945940566688339109350944456576357666151619317753792891661581327159616877487983821820492520348473874384736771934512787029218636250627816
Its index is 4782
It took 1.182 seconds to run this algorithm
*/

97
src/main/java/mattrixwv/ProjectEuler/Problems/Problem26.java Normal file
View File

@@ -0,0 +1,97 @@
//ProjectEuler/Java/Problem26.java
//Matthew Ellison
// Created: 07-28-19
//Modified: 07-28-19
//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) 2019 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 mattrixwv.ProjectEuler.Problems;
import mattrixwv.Algorithms;
import java.util.ArrayList;
public class Problem26 extends Problem{
//The number of digits needed in the number
private static final Integer TOP_NUM = 999;
public Problem26(){
super("What is the index of the first term in the Fibonacci sequence to contain 1000 digits?");
}
public void solve(){
//The length of the longest cycle
Integer longestCycle = 0;
//The starting denominator of the longest cycle
Integer longestNumber = 0;
//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(Integer denominator = 2;denominator <= TOP_NUM;++denominator){
ArrayList<Integer> denomList = new ArrayList<Integer>();
Boolean endFound = false; //Holds whether we have found an end to the number (either a cycle or a 0 for remainder)
Boolean cycleFound = false; //Holds whether a cycle was detected
Integer numerator = 1; //The numberator that will be divided. Always starts at 1
while(!endFound){
//Get the remainder after the division
Integer remainder = numerator % denominator;
//Check if the remainder is 0
//If it is set the flag
if(remainder.equals(0)){
endFound = true;
}
//Check if the remainder is in the list
//If it is in the list, set the appropriate flags
else if(Algorithms.isFound(denomList, 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();
//Save the restuls
result = String.format("The longest cycle is %d digits long\nIt started with the number %d\n", longestCycle, longestNumber);
}
}
/* Results:
The longest cycle is 982 digits long
It started with the number 983
It took 41.482 milliseconds to run this algorithm
*/

83
src/main/java/mattrixwv/ProjectEuler/Problems/Problem27.java Normal file
View File

@@ -0,0 +1,83 @@
//ProjectEuler/Java/Problem27.java
//Matthew Ellison
// Created: 09-15-19
//Modified: 09-15-19
//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) 2019 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 mattrixwv.ProjectEuler.Problems;
import mattrixwv.Algorithms;
import java.util.ArrayList;
public class Problem27 extends Problem{
//The A for the most n's generated
private static Integer topA = 0;
//The B for the most n's generated
private static Integer topB = 0;
//The most n's generated
private static Integer topN = 0;
//A list of all primes that could possibly be generated with this formula
private static ArrayList<Integer> primes = Algorithms.getPrimes(12000);
public Problem27(){
super("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");
}
public void solve(){
//Start the timer
timer.start();
//Start with the lowest possible A and check all possibilities after that
for(Integer a = -999;a <= 999;++a){
//Start with the lowest possible B and check all possibilities after that
for(Integer b = -1000;b <=1000;++b){
//Start with n=0 and check the formula to see how many primes you can get get with concecutive n's
Integer n = 0;
Integer quadratic = (n * n) + (a * n) + b;
while(Algorithms.isFound(primes, 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();
//Save the restuls
result = 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\n", topN, topA, topB, 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 4.765 seconds to run this algorithm
*/

131
src/main/java/mattrixwv/ProjectEuler/Problems/Problem28.java Normal file
View File

@@ -0,0 +1,131 @@
//ProjectEuler/Java/Problem28.java
//Matthew Ellison
// Created: 09-22-19
//Modified: 09-22-19
//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) 2019 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 mattrixwv.ProjectEuler.Problems;
import java.util.ArrayList;
public class Problem28 extends Problem{
//Holds the grid that we will be filling and searching
private static ArrayList<ArrayList<Integer>> grid;
//Holds the sum of the diagonals of the grid
private static Integer sumOfDiagonals = 0;
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 a 5 by 5 spiral");
}
//Sets up the grid
private void setupGrid(){
grid = new ArrayList<ArrayList<Integer>>();
//Fill the grid with 0's
for(Integer cnt = 0;cnt < 1001;++cnt){
//Add a blank ArrayList
grid.add(new ArrayList<Integer>());
for(Integer 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
Integer currentNum = 1;
//Start with the middle location and set it correctly and advance the tracker to the next number
Integer xLocation = 500;
Integer 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.equals(grid.size())){
finalLocation = true;
break;
}
}
}
}
//Finds the sum of teh diagonals in the grid
private void findSum(){
//Start at teh top corners and work your way down moving toward the opposite side
Integer leftSide = 0;
Integer rightSide = grid.size() - 1;
Integer row = 0;
while(row < grid.size()){
//This ensures the middle location is only counted once
if(Integer.compare(leftSide, rightSide) == 0){
sumOfDiagonals += grid.get(row).get(leftSide);
}
else{
sumOfDiagonals += grid.get(row).get(leftSide);
sumOfDiagonals += grid.get(row).get(rightSide);
}
++row;
++leftSide;
--rightSide;
}
}
public void solve(){
//Start the timer
timer.start();
//Setup the grid
setupGrid();
//Find the sum of the diagonals in the grid
findSum();
//Stop the timer
timer.stop();
//Print the restuls
result = String.format("The sum of the diagonals in the given grid is %d\n", sumOfDiagonals);
}
}
/* Results:
The sum of the diagonals in the given grid is 669171001
It took 158.348 milliseconds to run this algorithm
*/

76
src/main/java/mattrixwv/ProjectEuler/Problems/Problem29.java Normal file
View File

@@ -0,0 +1,76 @@
//ProjectEuler/Java/Problem29.java
//Matthew Ellison
// Created: 10-09-19
//Modified: 10-09-19
//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) 2019 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 mattrixwv.ProjectEuler.Problems;
import java.util.ArrayList;
import java.math.BigInteger;
public class Problem29 extends Problem{
//The lowest possible value for a
private static final Integer BOTTOM_A = 2;
//The highest possible value for a
private static final Integer TOP_A = 100;
//The lowest possible value for b
private static final Integer BOTTOM_B = 2;
//The highest possible value for b
private static final Integer TOP_B = 100;
//Holds all unique values generated
private static ArrayList<BigInteger> unique;
public Problem29(){
super("How many distinct terms are in the sequence generated by a^b for 2 <= a <= 100 and 2 <= b <= 100?");
}
public void solve(){
//Setup the variables
unique = new ArrayList<BigInteger>();
//Start the time
timer.start();
//Start with the first A and move towards the top
for(Integer currentA = BOTTOM_A;currentA <= TOP_A;++currentA){
//Start with the first B and move towards the top
for(Integer 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();
//Print the results
result = String.format("The number of unique values generated by a^b for %d <= a <= %d and %d <= b <= %d is %d\n", BOTTOM_A, TOP_A, BOTTOM_B, TOP_B, unique.size());
}
}
/* Results:
The number of unique values generated by a^b for 2 <= a <= 100 and 2 <= b <= 100 is 9183
It took 258.922 milliseconds to run this algorithm
*/

58
src/main/java/mattrixwv/ProjectEuler/Problems/Problem3.java Normal file
View File

@@ -0,0 +1,58 @@
//ProjectEuler/Java/Problem3.java
//Matthew Ellison
// Created: 03-01-19
//Modified: 03-28-19
//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) 2019 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 mattrixwv.ProjectEuler.Problems;
import java.math.BigInteger;
import java.util.ArrayList;
import mattrixwv.Algorithms;
public class Problem3 extends Problem{
//The number that needs factored
private static final BigInteger NUMBER = BigInteger.valueOf(600851475143L);
public Problem3(){
super("The largest prime factor of 600851475143");
}
public void solve(){
//Start the timer
timer.start();
//Get all the factors of the number
ArrayList<BigInteger> factors = Algorithms.getFactors(NUMBER);
//The last element should be the largest factor
//Stop the timer
timer.stop();
//Save the results
result = String.format("The largest factor of the number %d is %d\n", NUMBER, factors.get(factors.size() - 1));
}
}
/* Results:
The largest factor of the number 600851475143 is 6857
It took 674.398 milliseconds to run this algorithm
*/

97
src/main/java/mattrixwv/ProjectEuler/Problems/Problem30.java Normal file
View File

@@ -0,0 +1,97 @@
//ProjectEuler/Java/Problem30.java
//Matthew
// Created: 10-27-19
//Modified: 10-27-19
//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) 2019 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 mattrixwv.ProjectEuler.Problems;
import java.util.ArrayList;
public class Problem30 extends Problem{
//This is the largest number that will be checked
private static final Long TOP_NUM = 1000000L;
//Starts with 2 because 0 and 1 don't count
private static final Long BOTTOM_NUM = 2L;
//This is the power that the digits are raised to
private static final Long POWER_RAISED = 5L;
//This is an ArrayList of the numbers that are the sum of the fifth power of their digits
private static ArrayList<Long> sumOfFifthNumbers;
public Problem30(){
super("Find the sum of all the numbers that can be written as the sum of the fifth powers of their digits.");
}
//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 = num.toString();
//Start with the first digit, convert it to an integer, store it in the ArrayList, and move to the next digit
for(Integer cnt = 0;cnt < digits.length();++cnt){
listOfDigits.add(Long.valueOf(digits.substring(cnt, cnt + 1)));
}
//Return the list of Digits
return listOfDigits;
}
public Long getSumOfList(){
Long sum = 0L; //Start the sum at 0 so you can add to it
//Add every number in the ArrayList to the sum
for(Long num : sumOfFifthNumbers){
sum += num;
}
//Return the sum
return sum;
}
public void solve(){
//Sum of the power of the fifth powers of their digits
sumOfFifthNumbers = new ArrayList<Long>();
//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.equals(currentNum)){
sumOfFifthNumbers.add(currentNum);
}
}
//Stop the timer
timer.stop();
//Print the results
result = String.format("The sum of all the numbers that can be written as the sum of the fifth powers of their digits is %d\n", getSumOfList());
}
}
/* 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 478.387 milliseconds to run this algorithm
*/

78
src/main/java/mattrixwv/ProjectEuler/Problems/Problem4.java Normal file
View File

@@ -0,0 +1,78 @@
//ProjectEuler/Java/Problem4.java
//Matthew Ellison
// Created: 03-01-19
//Modified: 03-28-19
//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) 2019 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 mattrixwv.ProjectEuler.Problems;
import java.util.ArrayList;
import java.util.Collections;
public class Problem4 extends Problem{
//The first number to be multiplied
private static final Integer START_NUM = 100;
//The last number to be multiplied
private static final Integer END_NUM = 999;
public Problem4(){
super("Find the largest palindrome made from the product of two 3-digit numbers");
}
public void solve(){
//Start the timer
timer.start();
ArrayList<Integer> palindromes = new ArrayList<Integer>();
//Start at the first 3-digit number and check every one up to the last 3-digit number
for(Integer firstNum = START_NUM;firstNum <= END_NUM;++firstNum){
//You can start at the locatio of the first number because everything before that has already been tested. (100 * 101 == 101*100)
for(Integer secondNum = firstNum;secondNum < END_NUM;++secondNum){
//Get the product
Integer product = firstNum * secondNum;
//Change the number into a string
String productString = product.toString();
//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
}
}
//Stop the timer
timer.stop();
//Sort the palindromes so that the last one is the largest
Collections.sort(palindromes);
//Save the results
result = String.format("The largest palindrome is %d\n", palindromes.get(palindromes.size() - 1));
}
}
/* Results:
The largest palindrome is 906609
It took 105.376 milliseconds to run this algorithm
*/

65
src/main/java/mattrixwv/ProjectEuler/Problems/Problem5.java Normal file
View File

@@ -0,0 +1,65 @@
//ProjectEuler/Java/Problem5.java
//Matthew Ellison
// Created: 03-01-19
//Modified: 03-28-19
//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) 2019 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 mattrixwv.ProjectEuler.Problems;
public class Problem5 extends Problem{
public Problem5(){
super("What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20?");
}
public void solve(){
//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;
Integer currentNum = 20;
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(Integer 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 numbe then increment by 2
if(!numFound){
currentNum += 2;
}
}
//Stop the timer
timer.stop();
//Save the results
result = String.format("The smallest positive number evenly divisibly by all number 1-20 is " + currentNum.toString());
}
}
/* Results:
The smallest positive number evenly divisibly by all number 1-20 is 232792560
It took 1.987 seconds to run this algorithm
*/

62
src/main/java/mattrixwv/ProjectEuler/Problems/Problem6.java Normal file
View File

@@ -0,0 +1,62 @@
//ProjectEuler/Java/Problem6.java
//Matthew Ellison
// Created: 03-01-19
//Modified: 03-28-19
//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) 2019 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 mattrixwv.ProjectEuler.Problems;
public class Problem6 extends Problem{
//The first number that needs to be counted
private static final Integer START_NUM = 1;
//The last number that needs to be counted
private static final Integer END_NUM = 100;
public Problem6(){
super("Find the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum.");
}
public void solve(){
//Start the timer
timer.start();
//Setup the variables
Long sumOfSquares = 0L; //Holds the sum of the squares of all the numbers
Long squareOfSum = 0L; //Holds the square of the sum of all the numbers
//Run through all numbers and add them to the appropriate sums
for(Integer 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();
//Save the results
result = String.format("The difference between the sum of the squares and the square of the sum of all numbers from 1-100 is %d\n", 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 466.115 microseconds to run this algorithm
*/

338
src/main/java/mattrixwv/ProjectEuler/Problems/Problem67.java Normal file
View File

@@ -0,0 +1,338 @@
//ProjectEuler/Java/Problem67.java
//Matthew Ellison
// Created: 03-26-19
//Modified: 03-28-19
//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) 2019 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 mattrixwv.ProjectEuler.Problems;
import java.util.ArrayList;
import java.util.Arrays;
public class Problem67 extends Problem{
//The number of rows in the array
private static final Integer NUM_ROWS = 100;
//Setup the list you are trying to find a path through
private ArrayList<ArrayList<Integer>> list = new ArrayList<ArrayList<Integer>>();
//Used to keep track of where the best location came from
private class location{
public Integer xLocation;
public Integer yLocation;
public Integer total;
//Originally used in debugging
@SuppressWarnings("unused")
public Boolean fromRight;
location(Integer x, Integer y, Integer t, Boolean r){
xLocation = x;
yLocation = y;
total = t;
fromRight = r;
}
}
public Problem67(){
super("Find the maximum total from top to bottom");
list.ensureCapacity(NUM_ROWS);
list.add(new ArrayList<Integer>(Arrays.asList(59)));
list.add(new ArrayList<Integer>(Arrays.asList(73, 41)));
list.add(new ArrayList<Integer>(Arrays.asList(52, 40, 9)));
list.add(new ArrayList<Integer>(Arrays.asList(26, 53, 06, 34)));
list.add(new ArrayList<Integer>(Arrays.asList(10, 51, 87, 86, 81)));
list.add(new ArrayList<Integer>(Arrays.asList(61, 95, 66, 57, 25, 68)));
list.add(new ArrayList<Integer>(Arrays.asList(90, 81, 80, 38, 92, 67, 73)));
list.add(new ArrayList<Integer>(Arrays.asList(30, 28, 51, 76, 81, 18, 75, 44)));
list.add(new ArrayList<Integer>(Arrays.asList(84, 14, 95, 87, 62, 81, 17, 78, 58)));
list.add(new ArrayList<Integer>(Arrays.asList(21, 46, 71, 58, 02, 79, 62, 39, 31, 9)));
list.add(new ArrayList<Integer>(Arrays.asList(56, 34, 35, 53, 78, 31, 81, 18, 90, 93, 15)));
list.add(new ArrayList<Integer>(Arrays.asList(78, 53, 04, 21, 84, 93, 32, 13, 97, 11, 37, 51)));
list.add(new ArrayList<Integer>(Arrays.asList(45, 03, 81, 79, 05, 18, 78, 86, 13, 30, 63, 99, 95)));
list.add(new ArrayList<Integer>(Arrays.asList(39, 87, 96, 28, 03, 38, 42, 17, 82, 87, 58, 07, 22, 57)));
list.add(new ArrayList<Integer>(Arrays.asList(06, 17, 51, 17, 07, 93, 9, 07, 75, 97, 95, 78, 87, 8, 53)));
list.add(new ArrayList<Integer>(Arrays.asList(67, 66, 59, 60, 88, 99, 94, 65, 55, 77, 55, 34, 27, 53, 78, 28)));
list.add(new ArrayList<Integer>(Arrays.asList(76, 40, 41, 04, 87, 16, 9, 42, 75, 69, 23, 97, 30, 60, 10, 79, 87)));
list.add(new ArrayList<Integer>(Arrays.asList(12, 10, 44, 26, 21, 36, 32, 84, 98, 60, 13, 12, 36, 16, 63, 31, 91, 35)));
list.add(new ArrayList<Integer>(Arrays.asList(70, 39, 06, 05, 55, 27, 38, 48, 28, 22, 34, 35, 62, 62, 15, 14, 94, 89, 86)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
list.add(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)));
}
//This function turns every number in the array into (100 - num) to allow you to find the largest numbers rather than the smallest
private 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
private void removeHelper(ArrayList<location> possiblePoints, final location minLoc){
possiblePoints.removeIf(loc -> ((loc.xLocation == minLoc.xLocation) && (loc.yLocation == minLoc.yLocation)));
}
public void solve(){
//Invert the list
invert(list);
//For the points that I have already found the shortest distance to
ArrayList<location> foundPoints = new ArrayList<location>();
//Add the first row as a found point because you have to go through the tip
foundPoints.add(new location(0, 0, list.get(0).get(0), false));
//For the locations you are checking this round
ArrayList<location> possiblePoints = new ArrayList<location>();
//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
Integer xLoc = minLoc.xLocation;
Integer yLoc = minLoc.yLocation + 1; //Add one because you will always be moving to the next row
if(yLoc >= NUM_ROWS){
foundBottom = true;
}
else{
possiblePoints.add(new location(xLoc, yLoc, minLoc.total + list.get(yLoc).get(xLoc), true));
++xLoc; //Advance the x location to simulate going right
//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));
}
}
}
//Stop the timer
timer.stop();
//Print the results
//Get the correct total which will be the inversion of the current one
Integer actualTotal = ((100 * NUM_ROWS) - foundPoints.get(foundPoints.size() - 1).total);
result = "The value of the longest path is " + actualTotal.toString();
}
}
/* Results:
The value of the longest path is 7273
It took 3.736 seconds to run this algorithm
*/

57
src/main/java/mattrixwv/ProjectEuler/Problems/Problem7.java Normal file
View File

@@ -0,0 +1,57 @@
//ProjectEuler/Java/Problem7.java
//Matthew Ellison
// Created: 03-01-19
//Modified: 03-28-19
//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) 2019 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 mattrixwv.ProjectEuler.Problems;
import java.util.ArrayList;
import java.math.BigInteger;
import mattrixwv.Algorithms;
public class Problem7 extends Problem{
//The number of primes we are trying to get
private static final BigInteger NUMBER_OF_PRIMES = BigInteger.valueOf(10001);
public Problem7(){
super("What is the 10001th prime number?");
}
public void solve(){
//Start the timer
timer.start();
//Setup the variables
ArrayList<BigInteger> primes = Algorithms.getNumPrimes(NUMBER_OF_PRIMES); //Holds the prime numbers
//Stop the timer
timer.stop();
//Save the results
result = String.format("The " + NUMBER_OF_PRIMES.toString() + "th prime number is " + primes.get(primes.size() - 1));
}
}
/* Results:
The 10001th prime number is 104743
It took 142.783 milliseconds to run this algorithm
*/

86
src/main/java/mattrixwv/ProjectEuler/Problems/Problem8.java Normal file
View File

@@ -0,0 +1,86 @@
//ProjectEuler/Java/Problem8.java
//Matthew Ellison
// Created: 03-28-19
//Modified: 03-01-19
//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) 2019 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 mattrixwv.ProjectEuler.Problems;
public class Problem8 extends Problem{
//The 1000 digit number to check
private static final String NUMBER = "7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450";
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?");
}
public void solve(){
//Setup the variables
String maxNums = new String(); //Holds the string of the largest product
Long maxProduct = 0L; //Holds the largest product of 13 numbers
//Start the timer
timer.start();
//Cycle through the string of numbers looking for the maximum product
for(Integer 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();
//Save the results
result = String.format("The greatest product is " + maxProduct.toString() + "\nThe numbers are " + maxNums);
}
}
/* Results:
The greatest product is 23514624000
The numbers are 5576689664895
It took 8.069 milliseconds to run this algorithm
*/

75
src/main/java/mattrixwv/ProjectEuler/Problems/Problem9.java Normal file
View File

@@ -0,0 +1,75 @@
//ProjectEuler/Java/Problem9.java
//Matthew Ellison
// Created: 03-02-19
//Modified: 03-28-19
//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) 2019 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 mattrixwv.ProjectEuler.Problems;
public class Problem9 extends Problem{
public Problem9(){
super("There exists exactly one Pythagorean triplet for which a + b + c = 1000. Find the product abc.");
}
public void solve(){
//Setup the variables
Integer a = 1; //Holds the length of the first side
Integer b = 0; //Holds the length of the second side
Double c = 0D; //Holds the length of the hyp
Boolean found = false; //A flag to show whether the solution has been found
//Start the timer
timer.start();
//Loop through all possible a's
while((a < 1000) && !found){
b = a + 1; //b must be larger than a
c = Math.sqrt(Math.pow(a, 2) + Math.pow(b, 2)); //Compute the hyp
//Loop through all possible b's for this a
while((a + b + c) < 1000){
++b;
c = Math.sqrt(Math.pow(a, 2) + Math.pow(b, 2));
}
//If the sum == 1000 you found the number, otherwise go to the next possible a
if((a + b + c) == 1000){
found = true;
}
else{
++a;
}
}
//Stop the timer
timer.stop();
//Save the results
if(found){
result = String.format("The Pythagorean triplet is %d + %d + %d\nThe numbers' product is %d\n", a, b, c.intValue(), a * b * c.intValue());
}
else{
result = "The number was not found!";
}
}
}
/* Results:
*/