From 32a395a2b307a9370f8c29b74dbd2f4fdea429df Mon Sep 17 00:00:00 2001 From: Mattrixwv Date: Sat, 6 Jun 2020 17:08:12 -0400 Subject: [PATCH] Initial commit with existing problems --- .gitignore | 5 + LICENSE | 165 +++++++++++++++++++ Problem1.java | 53 ++++++ Problem10.java | 53 ++++++ Problem11.java | 190 +++++++++++++++++++++ Problem12.java | 71 ++++++++ Problem13.java | 262 +++++++++++++++++++++++++++++ Problem14.java | 84 ++++++++++ Problem15.java | 77 +++++++++ Problem16.java | 67 ++++++++ Problem17.java | 210 +++++++++++++++++++++++ Problem18.java | 162 ++++++++++++++++++ Problem19.java | 173 +++++++++++++++++++ Problem2.java | 58 +++++++ Problem20.java | 66 ++++++++ Problem21.java | 106 ++++++++++++ Problem22.java | 440 +++++++++++++++++++++++++++++++++++++++++++++++++ Problem23.java | 102 ++++++++++++ Problem24.java | 55 +++++++ Problem25.java | 62 +++++++ Problem26.java | 92 +++++++++++ Problem27.java | 81 +++++++++ Problem28.java | 132 +++++++++++++++ Problem29.java | 70 ++++++++ Problem3.java | 56 +++++++ Problem30.java | 91 ++++++++++ Problem4.java | 81 +++++++++ Problem5.java | 69 ++++++++ Problem6.java | 61 +++++++ Problem67.java | 334 +++++++++++++++++++++++++++++++++++++ Problem7.java | 55 +++++++ Problem8.java | 87 ++++++++++ Problem9.java | 73 ++++++++ 33 files changed, 3743 insertions(+) create mode 100644 .gitignore create mode 100644 LICENSE create mode 100644 Problem1.java create mode 100644 Problem10.java create mode 100644 Problem11.java create mode 100644 Problem12.java create mode 100644 Problem13.java create mode 100644 Problem14.java create mode 100644 Problem15.java create mode 100644 Problem16.java create mode 100644 Problem17.java create mode 100644 Problem18.java create mode 100644 Problem19.java create mode 100644 Problem2.java create mode 100644 Problem20.java create mode 100644 Problem21.java create mode 100644 Problem22.java create mode 100644 Problem23.java create mode 100644 Problem24.java create mode 100644 Problem25.java create mode 100644 Problem26.java create mode 100644 Problem27.java create mode 100644 Problem28.java create mode 100644 Problem29.java create mode 100644 Problem3.java create mode 100644 Problem30.java create mode 100644 Problem4.java create mode 100644 Problem5.java create mode 100644 Problem6.java create mode 100644 Problem67.java create mode 100644 Problem7.java create mode 100644 Problem8.java create mode 100644 Problem9.java diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..8f3eb30 --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +#Visual Studio Code +.vscode + +#Java class files +*.class diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..0a04128 --- /dev/null +++ b/LICENSE @@ -0,0 +1,165 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + + This version of the GNU Lesser General Public License incorporates +the terms and conditions of version 3 of the GNU General Public +License, supplemented by the additional permissions listed below. + + 0. Additional Definitions. + + As used herein, "this License" refers to version 3 of the GNU Lesser +General Public License, and the "GNU GPL" refers to version 3 of the GNU +General Public License. + + "The Library" refers to a covered work governed by this License, +other than an Application or a Combined Work as defined below. + + An "Application" is any work that makes use of an interface provided +by the Library, but which is not otherwise based on the Library. +Defining a subclass of a class defined by the Library is deemed a mode +of using an interface provided by the Library. + + A "Combined Work" is a work produced by combining or linking an +Application with the Library. The particular version of the Library +with which the Combined Work was made is also called the "Linked +Version". + + The "Minimal Corresponding Source" for a Combined Work means the +Corresponding Source for the Combined Work, excluding any source code +for portions of the Combined Work that, considered in isolation, are +based on the Application, and not on the Linked Version. + + The "Corresponding Application Code" for a Combined Work means the +object code and/or source code for the Application, including any data +and utility programs needed for reproducing the Combined Work from the +Application, but excluding the System Libraries of the Combined Work. + + 1. Exception to Section 3 of the GNU GPL. + + You may convey a covered work under sections 3 and 4 of this License +without being bound by section 3 of the GNU GPL. + + 2. Conveying Modified Versions. + + If you modify a copy of the Library, and, in your modifications, a +facility refers to a function or data to be supplied by an Application +that uses the facility (other than as an argument passed when the +facility is invoked), then you may convey a copy of the modified +version: + + a) under this License, provided that you make a good faith effort to + ensure that, in the event an Application does not supply the + function or data, the facility still operates, and performs + whatever part of its purpose remains meaningful, or + + b) under the GNU GPL, with none of the additional permissions of + this License applicable to that copy. + + 3. Object Code Incorporating Material from Library Header Files. + + The object code form of an Application may incorporate material from +a header file that is part of the Library. You may convey such object +code under terms of your choice, provided that, if the incorporated +material is not limited to numerical parameters, data structure +layouts and accessors, or small macros, inline functions and templates +(ten or fewer lines in length), you do both of the following: + + a) Give prominent notice with each copy of the object code that the + Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the object code with a copy of the GNU GPL and this license + document. + + 4. Combined Works. + + You may convey a Combined Work under terms of your choice that, +taken together, effectively do not restrict modification of the +portions of the Library contained in the Combined Work and reverse +engineering for debugging such modifications, if you also do each of +the following: + + a) Give prominent notice with each copy of the Combined Work that + the Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the Combined Work with a copy of the GNU GPL and this license + document. + + c) For a Combined Work that displays copyright notices during + execution, include the copyright notice for the Library among + these notices, as well as a reference directing the user to the + copies of the GNU GPL and this license document. + + d) Do one of the following: + + 0) Convey the Minimal Corresponding Source under the terms of this + License, and the Corresponding Application Code in a form + suitable for, and under terms that permit, the user to + recombine or relink the Application with a modified version of + the Linked Version to produce a modified Combined Work, in the + manner specified by section 6 of the GNU GPL for conveying + Corresponding Source. + + 1) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (a) uses at run time + a copy of the Library already present on the user's computer + system, and (b) will operate properly with a modified version + of the Library that is interface-compatible with the Linked + Version. + + e) Provide Installation Information, but only if you would otherwise + be required to provide such information under section 6 of the + GNU GPL, and only to the extent that such information is + necessary to install and execute a modified version of the + Combined Work produced by recombining or relinking the + Application with a modified version of the Linked Version. (If + you use option 4d0, the Installation Information must accompany + the Minimal Corresponding Source and Corresponding Application + Code. If you use option 4d1, you must provide the Installation + Information in the manner specified by section 6 of the GNU GPL + for conveying Corresponding Source.) + + 5. Combined Libraries. + + You may place library facilities that are a work based on the +Library side by side in a single library together with other library +facilities that are not Applications and are not covered by this +License, and convey such a combined library under terms of your +choice, if you do both of the following: + + a) Accompany the combined library with a copy of the same work based + on the Library, uncombined with any other library facilities, + conveyed under the terms of this License. + + b) Give prominent notice with the combined library that part of it + is a work based on the Library, and explaining where to find the + accompanying uncombined form of the same work. + + 6. Revised Versions of the GNU Lesser General Public License. + + The Free Software Foundation may publish revised and/or new versions +of the GNU Lesser General Public License from time to time. Such new +versions will be similar in spirit to the present version, but may +differ in detail to address new problems or concerns. + + Each version is given a distinguishing version number. If the +Library as you received it specifies that a certain numbered version +of the GNU Lesser General Public License "or any later version" +applies to it, you have the option of following the terms and +conditions either of that published version or of any later version +published by the Free Software Foundation. If the Library as you +received it does not specify a version number of the GNU Lesser +General Public License, you may choose any version of the GNU Lesser +General Public License ever published by the Free Software Foundation. + + If the Library as you received it specifies that a proxy can decide +whether future versions of the GNU Lesser General Public License shall +apply, that proxy's public statement of acceptance of any version is +permanent authorization for you to choose that version for the +Library. diff --git a/Problem1.java b/Problem1.java new file mode 100644 index 0000000..6cdcb94 --- /dev/null +++ b/Problem1.java @@ -0,0 +1,53 @@ +//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 . +*/ + + +import mattrixwv.Stopwatch; + + +public class Problem1{ + private static final Integer TOP_NUM = 1000; + public static void main(String[] argv){ + Integer sum = 0; //Holds the sum of all the correct elements + Stopwatch timer = new Stopwatch(); + //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(); + //Print the results + System.out.println("The sum of all numbers < " + TOP_NUM.toString() + " is " + sum.toString()); + System.out.println("It took " + timer.getStr() + " to run this algorithm"); + } +} + +/* Results: +The sum of all numbers < 1000 is 233168 +It took 504.226 microseconds to run this algorithm +*/ diff --git a/Problem10.java b/Problem10.java new file mode 100644 index 0000000..6815af3 --- /dev/null +++ b/Problem10.java @@ -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 . +*/ + + +import mattrixwv.Stopwatch; +import mattrixwv.Algorithms; + +import java.util.ArrayList; + + +public class Problem10{ + private static final Long GOAL_NUMBER = 2000000L; + public static void main(String[] argv){ + Stopwatch timer = new Stopwatch(); //To time the algorithm's run time + + //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(); + + //Print the results + System.out.printf("The sum of all the primes < %d is %d\n", GOAL_NUMBER, sum); + System.out.println("It took " + timer.getStr() + " to run this algorithm"); + } +} + +/* Results: + +*/ diff --git a/Problem11.java b/Problem11.java new file mode 100644 index 0000000..89a88b3 --- /dev/null +++ b/Problem11.java @@ -0,0 +1,190 @@ +//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 . +*/ + + +import mattrixwv.Stopwatch; +import mattrixwv.Algorithms; + +import java.util.ArrayList; + + +public class Problem11{ + //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 static void main(String[] argv){ + Stopwatch timer = new Stopwatch(); //Allows the program to the timed + ArrayList greatestProduct = new ArrayList(); //Holds the largest product we have found so far + ArrayList currentProduct = new ArrayList(); //Holds the numbers we are currently working on + + //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(); + + //Print the resutls + System.out.printf("The greatest product of 4 numbers in a line is %d\n", Algorithms.getProd(greatestProduct)); + System.out.println("The numbers are " + greatestProduct.toString()); + System.out.println("It took " + timer.getStr() + " to run this algorithm"); + } +} + +/* 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 +*/ diff --git a/Problem12.java b/Problem12.java new file mode 100644 index 0000000..35c5c66 --- /dev/null +++ b/Problem12.java @@ -0,0 +1,71 @@ +//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 . +*/ + + +import mattrixwv.Stopwatch; +import mattrixwv.Algorithms; + +import java.util.ArrayList; + + +public class Problem12{ + private static final Long GOAL_DIVISORS = 500L; //The minimum number of divisors that you want + public static void main(String[] argv){ + Stopwatch timer = new Stopwatch(); //Allows timing of the algorithm + + //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 divisors = new ArrayList(); + + //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(); + + //Print the results + System.out.printf("The triangulare number %d is the sum of all numbers >= %d and has %d divisors\n", sum, counter - 1, divisors.size()); + System.out.println("It took " + timer.getStr() + " to run this algorithms"); + } +} + +/* 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 +*/ diff --git a/Problem13.java b/Problem13.java new file mode 100644 index 0000000..e13aeaa --- /dev/null +++ b/Problem13.java @@ -0,0 +1,262 @@ +//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 . +*/ + + +import mattrixwv.Stopwatch; +import mattrixwv.Algorithms; + +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.Arrays; + + +public class Problem13{ + public static void main(String[] argv){ + Stopwatch timer = new Stopwatch(); //Allows the program to be timed + ArrayList nums = new ArrayList(); //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(); + + //Print the results + System.out.printf("The sum of all %d numbers is %d\n", nums.size(), sum); + System.out.printf("The first 10 digits of the sum of the numbers is %s\n", (sum.toString()).substring(0, 10)); + System.out.println("It took " + timer.getStr() + " to run this algorithms"); + } +} + +/* 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 +*/ diff --git a/Problem14.java b/Problem14.java new file mode 100644 index 0000000..3367e29 --- /dev/null +++ b/Problem14.java @@ -0,0 +1,84 @@ +//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 . +*/ + + +import mattrixwv.Stopwatch; +import mattrixwv.Algorithms; + + +public class Problem14{ + private static final Long MAX_NUM = 1000000L; //This is the top number that you will be checking against the series + public static void main(String[] argv){ + Stopwatch timer = new Stopwatch(); //This allows the run time of the algorithm to be testd + Long maxLength = 0L; //This is the length of the longest chain + Long maxNum = 0L; //This is teh starting number of the longest chain + + //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(); + + //Print the results + System.out.printf("The number %d produced a chain of %d steps\n", maxNum, maxLength); + System.out.println("It took " + timer.getStr() + " to run this algorithm"); + } + //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 +*/ diff --git a/Problem15.java b/Problem15.java new file mode 100644 index 0000000..ef1a9ac --- /dev/null +++ b/Problem15.java @@ -0,0 +1,77 @@ +//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 . +*/ + + +import mattrixwv.Stopwatch; + + +public class Problem15{ + private static final Integer WIDTH = 20; + private static final Integer LENGTH = 20; + public static void main(String[] argv){ + Stopwatch timer = new Stopwatch(); //Used to determine the algorithm's run time + + //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(); + + //Print the results + System.out.println("The number of routes is " + numOfRoutes.toString()); + System.out.println("It took " + timer.getStr() + " to run this algorithm"); + } + //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: + +*/ diff --git a/Problem16.java b/Problem16.java new file mode 100644 index 0000000..60f82c0 --- /dev/null +++ b/Problem16.java @@ -0,0 +1,67 @@ +//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 . +*/ + + +import mattrixwv.Stopwatch; + +import java.math.BigInteger; + + +public class Problem16{ + private static final Integer NUM_TO_POWER = 2; //The number that is going to be raised to a power + private static final Integer POWER = 1000; //The power that the number is going to be raised to + public static void main(String[] argv){ + Stopwatch timer = new Stopwatch(); //To time the runtime of the algorithm + //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(); + + //Print the results + System.out.printf("%d^%d = %s\n", NUM_TO_POWER, POWER, num.toString()); + System.out.println("The sum of the elements is " + sumOfElements.toString()); + System.out.println("It took " + timer.getStr() + " to run this algorithm"); + } +} + +/* Results: +2^1000 = 10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831652624386837205668069376 +The sum of the elements is 1366 +It took 1.104 milliseconds to run this algorithm +*/ diff --git a/Problem17.java b/Problem17.java new file mode 100644 index 0000000..d76e73c --- /dev/null +++ b/Problem17.java @@ -0,0 +1,210 @@ +//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 . +*/ + + +import mattrixwv.Stopwatch; + + +public class Problem17{ + private static final Integer START_NUM = 1; + private static final Integer STOP_NUM = 1000; + public static void main(String[] argv){ + Stopwatch timer = new Stopwatch(); //To time the algorithm's run time + //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(); + + //Print the results + System.out.printf("The sum of all the letters in all the numbers %d-%d is %d\n", START_NUM, STOP_NUM, sumOfLetters); + System.out.println("It took " + timer.getStr() + " to run this algorithm"); + } + private static 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 static 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 +*/ diff --git a/Problem18.java b/Problem18.java new file mode 100644 index 0000000..96d1889 --- /dev/null +++ b/Problem18.java @@ -0,0 +1,162 @@ +//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 . +*/ + + +import mattrixwv.Stopwatch; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.function.Predicate; + + +public class Problem18{ + //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; + public Boolean fromRight; + location(Integer x, Integer y, Integer t, Boolean r){ + xLocation = x; + yLocation = y; + total = t; + fromRight = r; + } + } + //This function turns every number in the array into (100 - num) to allow you to find the largest numbers rather than the smallest + private static void invert(ArrayList> 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 static void removeHelper(ArrayList possiblePoints, final location minLoc){ + possiblePoints.removeIf(loc -> ((loc.xLocation == minLoc.xLocation) && (loc.yLocation == minLoc.yLocation))); + } + public static void main(String[] argv){ + //Setup the timer + Stopwatch timer = new Stopwatch(); + timer.start(); + + //Setup the list you are trying to find a path through + ArrayList> list = new ArrayList>(); + list.add(new ArrayList(Arrays.asList(75))); + list.add(new ArrayList(Arrays.asList(95, 64))); + list.add(new ArrayList(Arrays.asList(17, 47, 82))); + list.add(new ArrayList(Arrays.asList(18, 35, 87, 10))); + list.add(new ArrayList(Arrays.asList(20, 04, 82, 47, 65))); + list.add(new ArrayList(Arrays.asList(19, 01, 23, 75, 03, 34))); + list.add(new ArrayList(Arrays.asList(88, 02, 77, 73, 07, 63, 67))); + list.add(new ArrayList(Arrays.asList(99, 65, 04, 28, 06, 16, 70, 92))); + list.add(new ArrayList(Arrays.asList(41, 41, 26, 56, 83, 40, 80, 70, 33))); + list.add(new ArrayList(Arrays.asList(41, 48, 72, 33, 47, 32, 37, 16, 94, 29))); + list.add(new ArrayList(Arrays.asList(53, 71, 44, 65, 25, 43, 91, 52, 97, 51, 14))); + list.add(new ArrayList(Arrays.asList(70, 11, 33, 28, 77, 73, 17, 78, 39, 68, 17, 57))); + list.add(new ArrayList(Arrays.asList(91, 71, 52, 38, 17, 14, 91, 43, 58, 50, 27, 29, 48))); + list.add(new ArrayList(Arrays.asList(63, 66, 04, 68, 89, 53, 67, 30, 73, 16, 69, 87, 40, 31))); + list.add(new ArrayList(Arrays.asList(04, 62, 98, 27, 23, 9, 70, 98, 73, 93, 38, 53, 60, 04, 23))); + + //Invert the list + invert(list); + + ArrayList foundPoints = new ArrayList(); //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 possiblePoints = new ArrayList(); //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(); + + //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); + + System.out.println("The value of the longest path is " + actualTotal.toString()); + System.out.println("It took " + timer.getStr() + " to run this algorithm"); + } +} + +/* Results: +The value of the longest path is 1074 +It took 5.146 milliseconds to run this algorithm +*/ diff --git a/Problem19.java b/Problem19.java new file mode 100644 index 0000000..a15f09c --- /dev/null +++ b/Problem19.java @@ -0,0 +1,173 @@ +//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 . +*/ + + +import mattrixwv.Stopwatch; + + +public class Problem19{ + private static enum DAYS{SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, NUMBER_OF_DAYS, ERROR}; + private static final Integer START_YEAR = 1901; //The first year we are going to test + private static final Integer END_YEAR = 2000; //The last year we are going to test + public static void main(String[] argv){ + Stopwatch timer = new Stopwatch(); + 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(); + + //Print the results + System.out.printf("There are %d Sundays that landed on the first of the months from %d to %d\n", totalSundays, START_YEAR, END_YEAR); + System.out.println("It took " + timer.getStr() + " to run this algorithms"); + } + //Return the day of the week that the date you pass into it is on + private static 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 static 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 +*/ diff --git a/Problem2.java b/Problem2.java new file mode 100644 index 0000000..82fea13 --- /dev/null +++ b/Problem2.java @@ -0,0 +1,58 @@ +//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 . +*/ + + +import mattrixwv.Stopwatch; +import mattrixwv.Algorithms; + +import java.util.ArrayList; + + +public class Problem2{ + private static final int TOP_NUM = 3999999; + public static void main(String[] argv){ + Stopwatch timer = new Stopwatch(); + timer.start(); + //Get a list of all fibonacci numbers < 4,000,000 + ArrayList 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(); + + //Print the results + System.out.printf("The sum of all even fibonacci numbers <= %d is %d\n", TOP_NUM, sum); + System.out.printf("It took %s to run this algorithm\n", timer.getStr()); + } +} + +/* Results: +The sum of all even fibonacci numbers <= 3999999 is 4613732 +It took 940.825 microseconds to run this algorithm +*/ diff --git a/Problem20.java b/Problem20.java new file mode 100644 index 0000000..3c5ae73 --- /dev/null +++ b/Problem20.java @@ -0,0 +1,66 @@ +//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 . +*/ + + +import mattrixwv.Stopwatch; +import java.math.BigInteger; + + +public class Problem20{ + private static Integer TOP_NUM = 100; + public static void main(String[] argv){ + Stopwatch timer = new Stopwatch(); + BigInteger num = new BigInteger("1"); //The number that is being generated + 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(); + + //Print the results + System.out.printf("%d! = %s\n", TOP_NUM, num.toString()); + System.out.printf("The sum of the digits is: %d\n", sum); + System.out.println("It took " + timer.getStr() + " to run this algorithm"); + } +} + +/* Restuls: +100! = 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000 +The sum of the digits is: 648 +It took 2.667 milliseconds to run this algorithm +*/ diff --git a/Problem21.java b/Problem21.java new file mode 100644 index 0000000..8134aaf --- /dev/null +++ b/Problem21.java @@ -0,0 +1,106 @@ +//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 . +*/ + + +import mattrixwv.Stopwatch; +import mattrixwv.Algorithms; +import java.util.ArrayList; +import java.util.Collections; + + +public class Problem21{ + private static final Integer LIMIT = 10000; + public static void main(String[] argv){ + //Setup the timer + Stopwatch timer = new Stopwatch(); + + //Setup the variables + ArrayList divisorSum = new ArrayList(); //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 + for(int cnt = 0;divisorSum.size() < LIMIT;++cnt){ + 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 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 + } + //System.out.printf("getSum(divisors) = %d\n", Algorithms.getSum(divisors)); + 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 amicable = new ArrayList(); + 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); + + //Print the results + System.out.printf("All amicable numbers less than %d are\n", LIMIT); + for(int cnt = 0;cnt < amicable.size();++cnt){ + System.out.println(amicable.get(cnt).toString()); + } + System.out.printf("The sum of all of these amicable numbers is %d\n", Algorithms.getSum(amicable)); + System.out.println("It took " + timer.getStr() + " to run this algorithm"); + } +} + +/* 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 +*/ diff --git a/Problem22.java b/Problem22.java new file mode 100644 index 0000000..4c2c1d6 --- /dev/null +++ b/Problem22.java @@ -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 . +*/ + + +import mattrixwv.Stopwatch; +import mattrixwv.Algorithms; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; + + +public class Problem22{ + private static ArrayList names = new ArrayList(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 static void main(String[] argv){ + //To allow the algorithm to be timed + Stopwatch timer = new Stopwatch(); + + //Setup the variables + ArrayList sums = new ArrayList(); //Holds the score based on the sum of the characters in the name + ArrayList prod = new ArrayList(); //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(); + + //Print the results + System.out.printf("The answer to the question is %d\n", Algorithms.getLongSum(prod)); + System.out.printf("It took %s to run this algorithm\n", timer.getStr()); + } +} + +/* Results: +The answer to the question is 871198282 +It took 14.675 milliseconds to run this algorithm +*/ diff --git a/Problem23.java b/Problem23.java new file mode 100644 index 0000000..3da730f --- /dev/null +++ b/Problem23.java @@ -0,0 +1,102 @@ +//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 . +*/ + + +import mattrixwv.Stopwatch; +import mattrixwv.Algorithms; +import java.util.ArrayList; + + +public class Problem23{ + public static final Integer MAX_NUM = 28123; + public static void main(String[] args){ + Stopwatch timer = new Stopwatch(); + //Setup the variables + ArrayList divisorSums = new ArrayList(); //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 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 abund = new ArrayList(); + 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(); + + //Print the results + System.out.printf("The answer is %d\n", sum); + System.out.printf("It took %s to run this algorithm\n", timer.getStr()); + } + //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 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 +*/ diff --git a/Problem24.java b/Problem24.java new file mode 100644 index 0000000..6944742 --- /dev/null +++ b/Problem24.java @@ -0,0 +1,55 @@ +//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 . +*/ + + +import mattrixwv.Stopwatch; +import mattrixwv.Algorithms; +import java.util.ArrayList; + + +public class Problem24{ + private static final Integer NEEDED_PERM = 1000000; //The number of the permutation that you need + public static void main(String[] args){ + //Setup the variables + Stopwatch timer = new Stopwatch(); + 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 permutations = Algorithms.getPermutations(nums); + + //Stop the timer + timer.stop(); + + //Print the results + System.out.printf("The 1 millionth permutation is %s\n", permutations.get(NEEDED_PERM - 1)); + System.out.printf("It took %s to run this algorithm\n", timer.getStr()); + } +} + +/* Results +The 1 millionth permutation is 2783915460 +It took 1.503 seconds to run this algorithm +*/ diff --git a/Problem25.java b/Problem25.java new file mode 100644 index 0000000..2566a7e --- /dev/null +++ b/Problem25.java @@ -0,0 +1,62 @@ +//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 . +*/ + + +import mattrixwv.Stopwatch; +import mattrixwv.Algorithms; + +import java.math.BigInteger; + + +public class Problem25{ + private static final Integer NUM_DIGITS = 1000; //The number of digits to calculate up to + public static void main(String[] args){ + //Setup the variables + Stopwatch timer = new Stopwatch(); + 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(); + + //Print the results + System.out.printf("The first Fibonacci number with %d digits is %s\n", NUM_DIGITS, number.toString()); + System.out.printf("Its index is %d\n", index); + System.out.printf("It took %s to run this algorithm\n", timer.getStr()); + } +} + +/* Results: +The first Fibonacci number with 1000 digits is 1070066266382758936764980584457396885083683896632151665013235203375314520604694040621889147582489792657804694888177591957484336466672569959512996030461262748092482186144069433051234774442750273781753087579391666192149259186759553966422837148943113074699503439547001985432609723067290192870526447243726117715821825548491120525013201478612965931381792235559657452039506137551467837543229119602129934048260706175397706847068202895486902666185435124521900369480641357447470911707619766945691070098024393439617474103736912503231365532164773697023167755051595173518460579954919410967778373229665796581646513903488154256310184224190259846088000110186255550245493937113651657039447629584714548523425950428582425306083544435428212611008992863795048006894330309773217834864543113205765659868456288616808718693835297350643986297640660000723562917905207051164077614812491885830945940566688339109350944456576357666151619317753792891661581327159616877487983821820492520348473874384736771934512787029218636250627816 +Its index is 4782 +It took 1.182 seconds to run this algorithm +*/ diff --git a/Problem26.java b/Problem26.java new file mode 100644 index 0000000..7ba19e1 --- /dev/null +++ b/Problem26.java @@ -0,0 +1,92 @@ +//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 . +*/ + + +import mattrixwv.Stopwatch; +import mattrixwv.Algorithms; +import java.util.ArrayList; + +public class Problem26{ + private static final Integer TOP_NUM = 999; + public static void main(String[] args){ + //Setup the variables + Stopwatch timer = new Stopwatch(); + Integer longestCycle = 0; //The length of the longest cycle + Integer longestNumber = 0; //The starting denominator of the longest cycle + + //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 denomList = new ArrayList(); + 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(); + + //Print the restuls + System.out.printf("The longest cycle is %d digits long\n", longestCycle); + System.out.printf("It started with the number %d\n", longestNumber); + System.out.println("It took " + timer.getStr() + " to run this algorithm"); + } +} + +/* Results: +The longest cycle is 982 digits long +It started with the number 983 +It took 41.482 milliseconds to run this algorithm +*/ diff --git a/Problem27.java b/Problem27.java new file mode 100644 index 0000000..6d5503d --- /dev/null +++ b/Problem27.java @@ -0,0 +1,81 @@ +//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 . +*/ + + +import mattrixwv.Stopwatch; +import mattrixwv.Algorithms; + +import java.util.ArrayList; + + +public class Problem27{ + private static Integer topA = 0; //The A for the most n's generated + private static Integer topB = 0; //The B for the most n's generated + private static Integer topN = 0; //The most n's generated + private static ArrayList primes = Algorithms.getPrimes(12000); //A list of all primes that could possibly be generated with this formula + public static void main(String[] args){ + //Setup the variables + Stopwatch timer = new Stopwatch(); + + //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(); + + //Print the restuls + System.out.printf("The greatest number of primes found is %d", topN); + System.out.printf("\nIt was found with A = %d, B = %d", topA, topB); + System.out.printf("\nThe product of A and B is %d\n", topA * topB); + System.out.println("It took " + timer.getStr() + " to run this algorithm"); + } +} + +/* 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 +*/ diff --git a/Problem28.java b/Problem28.java new file mode 100644 index 0000000..77aaf3d --- /dev/null +++ b/Problem28.java @@ -0,0 +1,132 @@ +//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 . +*/ + + +import mattrixwv.Stopwatch; + +import java.util.ArrayList; + + +public class Problem28{ + private static ArrayList> grid; //Holds the grid that we will be filling and searching + private static Integer sumOfDiagonals = 0; //Holds the sum of the diagonals of the grid + //Sets up the grid + private static void setupGrid(){ + grid = new ArrayList>(); + //Fill the grid with 0's + for(Integer cnt = 0;cnt < 1001;++cnt){ + //Add a blank ArrayList + grid.add(new ArrayList()); + 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 static 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 static void main(String args[]){ + //Setup the variables + Stopwatch timer = new Stopwatch(); + + //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 + System.out.printf("The sum of the diagonals in the given grid is %d\n", sumOfDiagonals); + System.out.println("It took " + timer.getStr() + " to run this algorithm"); + } +} + +/* Results: +The sum of the diagonals in the given grid is 669171001 +It took 158.348 milliseconds to run this algorithm +*/ diff --git a/Problem29.java b/Problem29.java new file mode 100644 index 0000000..387805f --- /dev/null +++ b/Problem29.java @@ -0,0 +1,70 @@ +//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 . +*/ + + +import mattrixwv.Stopwatch; + +import java.util.ArrayList; +import java.math.BigInteger; + + +public class Problem29{ + private static final Integer BOTTOM_A = 2; //The lowest possible value for a + private static final Integer TOP_A = 100; //The highest possible value for a + private static final Integer BOTTOM_B = 2; //The lowest possible value for b + private static final Integer TOP_B = 100; //The highest possible value for b + private static ArrayList unique; //Holds all unique values generated + public static void main(String[] args){ + //Setup the variables + Stopwatch timer = new Stopwatch(); + unique = new ArrayList(); + + //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 + System.out.printf("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()); + System.out.println("It took " + timer.getStr() + " to run this algorithm"); + } +} + +/* 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 +*/ diff --git a/Problem3.java b/Problem3.java new file mode 100644 index 0000000..1557f72 --- /dev/null +++ b/Problem3.java @@ -0,0 +1,56 @@ +//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 . +*/ + + +import mattrixwv.Stopwatch; +import mattrixwv.Algorithms; + +import java.math.BigInteger; +import java.util.ArrayList; + + +public class Problem3{ + private static final BigInteger NUMBER = BigInteger.valueOf(600851475143L); + public static void main(String[] argv){ + Stopwatch timer = new Stopwatch(); //A timer to check execution time of the algorithm + + //Start the timer + timer.start(); + + //Get all the factors of the number + ArrayList factors = Algorithms.getFactors(NUMBER); + //The last element should be the largest factor + + //Stop the timer + timer.stop(); + + //Print the results + System.out.printf("The largest factor of the number %d is %d\n", NUMBER, factors.get(factors.size() - 1)); + System.out.printf("It took %s to run this algorithm\n", timer.getStr()); + } +} + +/* Results: +The largest factor of the number 600851475143 is 6857 +It took 674.398 milliseconds to run this algorithm +*/ diff --git a/Problem30.java b/Problem30.java new file mode 100644 index 0000000..90d4a6e --- /dev/null +++ b/Problem30.java @@ -0,0 +1,91 @@ +//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 . +*/ + + +import mattrixwv.Stopwatch; + +import java.util.ArrayList; + + +public class Problem30{ + private static final Long TOP_NUM = 1000000L; //This is the largest number that will be checked + private static final Long BOTTOM_NUM = 2L; //Starts with 2 because 0 and 1 don't count + private static final Long POWER_RAISED = 5L; //This is the power that the digits are raised to + private static ArrayList sumOfFifthNumbers; //This is an ArrayList of the numbers that are the sum of the fifth power of their digits + //Returns an ArrayList with the individual digits of the number passed to it + private static ArrayList getDigits(Long num){ + ArrayList listOfDigits = new ArrayList(); //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 static 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 static void main(String[] args){ + Stopwatch timer = new Stopwatch(); + sumOfFifthNumbers = new ArrayList(); + + //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 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 + System.out.printf("The sum of all the numbers that can be written as the sum of the fifth powers of their digits is %d\n", getSumOfList()); + System.out.println("It took " + timer.getStr() + " to run this algorithm"); + } +} + +/* 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 +*/ diff --git a/Problem4.java b/Problem4.java new file mode 100644 index 0000000..966c5f2 --- /dev/null +++ b/Problem4.java @@ -0,0 +1,81 @@ +//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 . +*/ + + +import mattrixwv.Stopwatch; +import mattrixwv.Algorithms; + +import java.util.ArrayList; +import java.util.Collections; + + +public class Problem4{ + private static final Integer START_NUM = 100; //The first number to be multiplied + private static final Integer END_NUM = 999; //THe last number to be multiplied + public static void main(String[] argv){ + Stopwatch timer = new Stopwatch(); //To time the execution time of this algorithm + + //Start the timer + timer.start(); + + ArrayList palindromes = new ArrayList(); + + //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); + } + else{ + //System.out.println("ProductString = " + productString); + //System.out.println("reverseString = " + reverseString); + } + //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); + + //Print the results + System.out.printf("The largest palindrome is %d\n", palindromes.get(palindromes.size() - 1)); + System.out.printf("It took " + timer.getStr() + " to run this algorithm\n"); + } +} + +/* Results: +The largest palindrome is 906609 +It took 105.376 milliseconds to run this algorithm +*/ diff --git a/Problem5.java b/Problem5.java new file mode 100644 index 0000000..b9c990a --- /dev/null +++ b/Problem5.java @@ -0,0 +1,69 @@ +//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 . +*/ + + +import mattrixwv.Stopwatch; + +import java.util.ArrayList; + + +public class Problem5{ + public static void main(String[] argv){ + Stopwatch timer = new Stopwatch(); //So you can time the code + + //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(); + + //Print the results + System.out.println("The smallest positive number evenly divisibly by all number 1-20 is " + currentNum.toString()); + System.out.println("It took " + timer.getStr() + " to run this algorithm"); + } +} + +/* Results: +The smallest positive number evenly divisibly by all number 1-20 is 232792560 +It took 1.987 seconds to run this algorithm +*/ diff --git a/Problem6.java b/Problem6.java new file mode 100644 index 0000000..21408c3 --- /dev/null +++ b/Problem6.java @@ -0,0 +1,61 @@ +//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 . +*/ + + +import mattrixwv.Stopwatch; + + +public class Problem6{ + private static final Integer START_NUM = 1; //The first number that needs to be counted + private static final Integer END_NUM = 100; //The last number that needs to be counted + public static void main(String[] argv){ + Stopwatch timer = new Stopwatch(); //SO you can time the algorithm's run time + + //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(); + + //Print the results + System.out.printf("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)); + System.out.println("It took " + timer.getStr() + " to run this algorithm"); + } +} + +/* 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 +*/ diff --git a/Problem67.java b/Problem67.java new file mode 100644 index 0000000..31b756d --- /dev/null +++ b/Problem67.java @@ -0,0 +1,334 @@ +//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 . +*/ + + +import mattrixwv.Stopwatch; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.function.Predicate; + + +public class Problem67{ + //The number of rows in the array + private static final Integer NUM_ROWS = 100; + //Used to keep track of where the best location came from + private static class location{ + public Integer xLocation; + public Integer yLocation; + public Integer total; + public Boolean fromRight; + location(Integer x, Integer y, Integer t, Boolean r){ + xLocation = x; + yLocation = y; + total = t; + fromRight = r; + } + } + //This function turns every number in the array into (100 - num) to allow you to find the largest numbers rather than the smallest + private static void invert(ArrayList> 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 static void removeHelper(ArrayList possiblePoints, final location minLoc){ + possiblePoints.removeIf(loc -> ((loc.xLocation == minLoc.xLocation) && (loc.yLocation == minLoc.yLocation))); + } + public static void main(String[] args){ + //Setup the timer + Stopwatch timer = new Stopwatch(); + timer.start(); + + //Setup the list you are trying to find a path through + ArrayList> list = new ArrayList>(); + list.ensureCapacity(NUM_ROWS); + list.add(new ArrayList(Arrays.asList(59))); + list.add(new ArrayList(Arrays.asList(73, 41))); + list.add(new ArrayList(Arrays.asList(52, 40, 9))); + list.add(new ArrayList(Arrays.asList(26, 53, 06, 34))); + list.add(new ArrayList(Arrays.asList(10, 51, 87, 86, 81))); + list.add(new ArrayList(Arrays.asList(61, 95, 66, 57, 25, 68))); + list.add(new ArrayList(Arrays.asList(90, 81, 80, 38, 92, 67, 73))); + list.add(new ArrayList(Arrays.asList(30, 28, 51, 76, 81, 18, 75, 44))); + list.add(new ArrayList(Arrays.asList(84, 14, 95, 87, 62, 81, 17, 78, 58))); + list.add(new ArrayList(Arrays.asList(21, 46, 71, 58, 02, 79, 62, 39, 31, 9))); + list.add(new ArrayList(Arrays.asList(56, 34, 35, 53, 78, 31, 81, 18, 90, 93, 15))); + list.add(new ArrayList(Arrays.asList(78, 53, 04, 21, 84, 93, 32, 13, 97, 11, 37, 51))); + list.add(new ArrayList(Arrays.asList(45, 03, 81, 79, 05, 18, 78, 86, 13, 30, 63, 99, 95))); + list.add(new ArrayList(Arrays.asList(39, 87, 96, 28, 03, 38, 42, 17, 82, 87, 58, 07, 22, 57))); + list.add(new ArrayList(Arrays.asList(06, 17, 51, 17, 07, 93, 9, 07, 75, 97, 95, 78, 87, 8, 53))); + list.add(new ArrayList(Arrays.asList(67, 66, 59, 60, 88, 99, 94, 65, 55, 77, 55, 34, 27, 53, 78, 28))); + list.add(new ArrayList(Arrays.asList(76, 40, 41, 04, 87, 16, 9, 42, 75, 69, 23, 97, 30, 60, 10, 79, 87))); + list.add(new ArrayList(Arrays.asList(12, 10, 44, 26, 21, 36, 32, 84, 98, 60, 13, 12, 36, 16, 63, 31, 91, 35))); + list.add(new ArrayList(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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))); + + //Invert the list + invert(list); + + ArrayList foundPoints = new ArrayList(); //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 possiblePoints = new ArrayList(); //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(); + + //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); + + System.out.println("The value of the longest path is " + actualTotal.toString()); + System.out.println("It took " + timer.getStr() + " to run this algorithm"); + } +} + +/* Results: +The value of the longest path is 7273 +It took 3.736 seconds to run this algorithm +*/ diff --git a/Problem7.java b/Problem7.java new file mode 100644 index 0000000..a064d17 --- /dev/null +++ b/Problem7.java @@ -0,0 +1,55 @@ +//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 . +*/ + + +import mattrixwv.Stopwatch; +import mattrixwv.Algorithms; + +import java.util.ArrayList; +import java.math.BigInteger; + + +public class Problem7{ + private static final BigInteger NUMBER_OF_PRIMES = BigInteger.valueOf(10001); + public static void main(String[] argv){ + Stopwatch timer = new Stopwatch(); //So the algorithm can be timed + + //Start the timer + timer.start(); + + //Setup the variables + ArrayList primes = Algorithms.getNumPrimes(NUMBER_OF_PRIMES); //Holds the prime numbers + + //Stop the timer + timer.stop(); + + //Print the results + System.out.println("The " + NUMBER_OF_PRIMES.toString() + "th prime number is " + primes.get(primes.size() - 1)); + System.out.println("It took " + timer.getStr() + " to run this algorithm"); + } +} + +/* Results: +The 10001th prime number is 104743 +It took 142.783 milliseconds to run this algorithm +*/ diff --git a/Problem8.java b/Problem8.java new file mode 100644 index 0000000..a20ef72 --- /dev/null +++ b/Problem8.java @@ -0,0 +1,87 @@ +//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 . +*/ + + +import mattrixwv.Stopwatch; + + +public class Problem8{ + private static final String NUMBER = "7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450"; + public static void main(String[] argv){ + Stopwatch timer = new Stopwatch(); + + //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(); + + //Print the results + System.out.println("The greatest product is " + maxProduct.toString()); + System.out.println("The numbers are " + maxNums); + System.out.println("It took " + timer.getStr() + " to run this algorithm"); + } +} + +/* Results: +The greatest product is 23514624000 +The numbers are 5576689664895 +It took 8.069 milliseconds to run this algorithm +*/ diff --git a/Problem9.java b/Problem9.java new file mode 100644 index 0000000..9e3e9f5 --- /dev/null +++ b/Problem9.java @@ -0,0 +1,73 @@ +//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 . +*/ + + +import mattrixwv.Stopwatch; + + +public class Problem9{ + public static void main(String[] argv){ + //Setup the variables + Stopwatch timer = new Stopwatch(); //To time the execution time of this algorithm + 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(); + + //Print the results + if(found){ + System.out.printf("The Pythagorean triplet is %d + %d + %d\n", a, b, c.intValue()); + System.out.printf("The numbers' product is %d\n", a * b * c.intValue()); + System.out.println("It took " + timer.getStr() + " to run this algorithm"); + } + else{ + System.out.println("The number was not found!"); + } + } +} \ No newline at end of file