From 4953474bf83b507513d85f351842b1167447a37c Mon Sep 17 00:00:00 2001 From: Mattrixwv Date: Sat, 6 Jun 2020 17:23:54 -0400 Subject: [PATCH] Initial commit with existing files --- .gitignore | 2 + LICENSE | 165 ++++++++++++++++++++ Problem1.m | 65 ++++++++ Problem10.m | 47 ++++++ Problem11.m | 171 ++++++++++++++++++++ Problem12.m | 93 +++++++++++ Problem13.m | 254 ++++++++++++++++++++++++++++++ Problem14.m | 80 ++++++++++ Problem15.m | 78 ++++++++++ Problem16.m | 90 +++++++++++ Problem17.m | 188 ++++++++++++++++++++++ Problem18.m | 170 ++++++++++++++++++++ Problem19.m | 186 ++++++++++++++++++++++ Problem2.m | 62 ++++++++ Problem20.m | 68 ++++++++ Problem21.m | 121 +++++++++++++++ Problem22.m | 437 ++++++++++++++++++++++++++++++++++++++++++++++++++++ Problem23.m | 128 +++++++++++++++ Problem24.m | 87 +++++++++++ Problem25.m | 108 +++++++++++++ Problem26.m | 96 ++++++++++++ Problem27.m | 87 +++++++++++ Problem28.m | 100 ++++++++++++ Problem29.m | 105 +++++++++++++ Problem3.m | 83 ++++++++++ Problem30.m | 76 +++++++++ Problem4.m | 79 ++++++++++ Problem5.m | 79 ++++++++++ Problem6.m | 55 +++++++ Problem67.m | 340 ++++++++++++++++++++++++++++++++++++++++ Problem7.m | 54 +++++++ Problem8.m | 99 ++++++++++++ Problem9.m | 72 +++++++++ Reverse.m | 24 +++ 34 files changed, 3949 insertions(+) create mode 100644 .gitignore create mode 100644 LICENSE create mode 100644 Problem1.m create mode 100644 Problem10.m create mode 100644 Problem11.m create mode 100644 Problem12.m create mode 100644 Problem13.m create mode 100644 Problem14.m create mode 100644 Problem15.m create mode 100644 Problem16.m create mode 100644 Problem17.m create mode 100644 Problem18.m create mode 100644 Problem19.m create mode 100644 Problem2.m create mode 100644 Problem20.m create mode 100644 Problem21.m create mode 100644 Problem22.m create mode 100644 Problem23.m create mode 100644 Problem24.m create mode 100644 Problem25.m create mode 100644 Problem26.m create mode 100644 Problem27.m create mode 100644 Problem28.m create mode 100644 Problem29.m create mode 100644 Problem3.m create mode 100644 Problem30.m create mode 100644 Problem4.m create mode 100644 Problem5.m create mode 100644 Problem6.m create mode 100644 Problem67.m create mode 100644 Problem7.m create mode 100644 Problem8.m create mode 100644 Problem9.m create mode 100644 Reverse.m diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..ca3b510 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +#Visual Studio Code +.vscode 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.m b/Problem1.m new file mode 100644 index 0000000..27068d4 --- /dev/null +++ b/Problem1.m @@ -0,0 +1,65 @@ +%ProjectEuler/Octave/Problem1.m +%Matthew Ellison +% Created: +%Modified: 03-28-19 +%What is the sum of all the multiples of 3 or 5 that are less than 1000 +%{ + 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 . +%} + + +%Setup your variables +fullSum = 0; %To hold the sum of all the numbers +numbers = 0; %To hold all of the numbers +counter = 0; %The number. It must stay below 1000 + +%Start the timer +startTime = clock(); + +%When done this way it removes the possibility of duplicate numbers +while(counter < 1000) + %See if the number is a multiple of 3 + if(mod(counter, 3) == 0) + numbers(end + 1) = counter; + %See if the number is a multiple of 5 + elseif(mod(counter, 5) == 0) + numbers(end + 1) = counter; + end + + %Increment the number + ++counter; +end + +%Stop the timer +endTime = clock(); + +%Print the results +printf("The sum of all the numbers less than 1000 that is divisibly by 3 or 5 is: %d\n", sum(numbers)) +printf("It took %f seconds to run this algorithm\n", etime(endTime, startTime)) + +%Cleanup your variables +clear fullSum; +clear numbers; +clear counter; +clear startTime; +clear endTime; +clear ans; + +%{ +Results: +The sum of all the numbers less than 1000 that is divisibly by 3 or 5 is: 233168 +It took 0.014717 seconds to run this algorithm +%} diff --git a/Problem10.m b/Problem10.m new file mode 100644 index 0000000..a95145a --- /dev/null +++ b/Problem10.m @@ -0,0 +1,47 @@ +%ProjectEuler/Octave/Problem10.m +%Matthew Ellison +% Created: +%Modified: 03-28-19 +%Find the sum of all the primes below two million. +%{ + 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 . +%} + + +%Start the timer +startTime = clock(); + +%Find the number +num = sum(primes(2000000)); + +%Stop the timer +endTime = clock(); + +%Print the results +printf("The sum of all the prime numbers less than 2000000 is %d\n", num) +printf("It took %f seconds to run this algorithm\n", etime(endTime, startTime)) + +%Cleanup your variables +clear num; +clear startTime; +clear endTime; +clear timeToRun; + +%{ +Results: +The sum of all the prime numbers less than 2000000 is 142913828922 +It took 0.012894 seconds to run this algorithm +%} diff --git a/Problem11.m b/Problem11.m new file mode 100644 index 0000000..8e5536e --- /dev/null +++ b/Problem11.m @@ -0,0 +1,171 @@ +%ProjectEuler/Octave/Problem11.m +%Matthew Ellison +% Created: +%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 +%} +%{ + 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 . +%} + + +%Create your variables +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]; +currentLocation = [1, 1]; %The location you are checking now +currentProduct = [0 0 0 0]; %The product you are currently looking at +greatestProduct = [0 0 0 0]; %The greatest product of values you have found +finished = false; + +%Start the timer +startTime = clock(); + +%Loop until you reach the last element +while(~finished) + left = false; + right = false; + down = false; + + %Check which directions you can go + %When moving you will be moving 4 locations + if((currentLocation(2) - 3) >= 1) + left = true; + end + if((currentLocation(2) + 3) <= size(grid)(2)) + right = true; + end + if((currentLocation(1) + 3) <= size(grid)(1)) + down = true; + end + + %Check the possible directions and check against greatest + %Right + if(right) + currentProduct = grid(currentLocation(1), currentLocation(2):(currentLocation(2) + 3)); + %If the current numbers' product is greater than the greatest product so far, replace it + if(prod(currentProduct) > prod(greatestProduct)) + greatestProduct = currentProduct; + end + end + %Down + if(down) + currentProduct = grid(currentLocation(1):(currentLocation(1) + 3), currentLocation(2)); + %If the current numbers' product is greater than the greatest product so far, replace it + if(prod(currentProduct) > prod(greatestProduct)) + greatestProduct = currentProduct; + end + end + %LeftDown + if(left && down) + currentProduct(1) = grid(currentLocation(1), currentLocation(2)); + currentProduct(2) = grid(currentLocation(1) + 1,currentLocation(2) - 1); + currentProduct(3) = grid(currentLocation(1) + 2,currentLocation(2) - 2); + currentProduct(4) = grid(currentLocation(1) + 3,currentLocation(2) - 3); + %If the current numbers' product is greater than the greatest product so far, replace it + if(prod(currentProduct) > prod(greatestProduct)) + greatestProduct = currentProduct; + end + end + %RightDown + if(right && down) + currentProduct(1) = grid(currentLocation(1), currentLocation(2)); + currentProduct(2) = grid(currentLocation(1) + 1,currentLocation(2) + 1); + currentProduct(3) = grid(currentLocation(1) + 2,currentLocation(2) + 2); + currentProduct(4) = grid(currentLocation(1) + 3,currentLocation(2) + 3); + %If the current numbers' product is greater than the greatest product so far, replace it + if(prod(currentProduct) > prod(greatestProduct)) + greatestProduct = currentProduct; + end + end + + %Move to the next column + ++currentLocation(2); + %If you have moved too far in the columns move back to the beginning and to the next row + if(currentLocation(2) > size(grid)(2)) + currentLocation(2) = 1; + ++currentLocation(1); + end + %If the row is currently greater than what is available you have traversed the list + if(currentLocation(1) > size(grid)(1)) + finished = true; + end +end +greatestProduct = reshape(greatestProduct, 1, 4); %For some reason it is coming out a 4X1 instead of 1X4 + +%Stop the timer +endTime = clock(); + +%Print the result +printf("The greatest product of 3 numbers in a line is %d\n", prod(greatestProduct)) +printf("It took %f seconds to run this algorithm\n", etime(endTime, startTime)) + +%Cleanup the variables +clear down; +clear right; +clear left; +clear finished; +clear startTime; +clear endTime; +clear grid; +clear greatestProduct; +clear currentLocation; +clear currentProduct; +clear ans; + +%{ +Results: +The greatest product of 3 numbers in a line is 70600674 +It took 0.081856 seconds to run this algorithm +%} diff --git a/Problem12.m b/Problem12.m new file mode 100644 index 0000000..54cdf60 --- /dev/null +++ b/Problem12.m @@ -0,0 +1,93 @@ +function [] = Problem12() +%ProjectEuler/Octave/Problem12.m +%Matthew Ellison +% Created: +%Modified: 03-28-19 +%What is the value of the first triangle number to have over five hundred divisors? +%{ + 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 . +%} + + +%Setup your variables +number = 1; %To hold the current triangle number +nextNumber = 2; %To hold the current number you have counted up to +found = false; %To tell when the answer has been found +numDivisors = 0; + +%Start the timer +startTime = clock(); + +%Keep checking to find the correct numbers until you +while((~found) && (number > 0)) + %See how many divisors the number has + numDivisors = size(getDivisors(number))(2); + + %If it is enough set the flag to stop the loop + if(numDivisors > 500) + found = true; + else + number += nextNumber; + nextNumber += 1; + end +end + +%Stop the timer +endTime = clock(); + +%Print your result +printf("The first triangular number with more than 500 divisors is %d\n", number) +printf("It took %f seconds to run this algorithm\n", etime(endTime, startTime)) + +end %End of Problem12() + +function [divisors] = getDivisors(goalNumber) + divisors = []; + %Start by checking that the number is positive + if(goalNumber <= 0) + return; + %If the number is 1 return just itself + elseif(goalNumber == 1) + divisors(end + 1) = 1; + return; + %Otherwise add 1 and itself to the list + else + divisors(end + 1) = 1; + divisors(end + 1) = goalNumber; + end + + %Start at 3 and loop through all numbers < sqrt(goalNumber) looking for a number that divides it evenly + topPossibleDivisor = ceil(sqrt(goalNumber)); + for possibleDivisor = 2 : topPossibleDivisor + %If you find one add it and the number it creates to the list + if(mod(goalNumber, possibleDivisor) == 0) + divisors(end + 1) = possibleDivisor; + %Account for the possibility sqrt(goalNumber) being a divisor + if(possibleDivisor != topPossibleDivisor) + divisors(end + 1) = goalNumber / possibleDivisor; + end + end + end + + %Sort the list before returning for neatness + divisors = sort(divisors); +end + +%{ +Results: +The first triangular number with more than 500 divisors is 76576500 +It took 344.606964 seconds to run this algorithm +%} diff --git a/Problem13.m b/Problem13.m new file mode 100644 index 0000000..bf4913e --- /dev/null +++ b/Problem13.m @@ -0,0 +1,254 @@ +%ProjectEuler/Octave/Problem13.m +%Matthew Ellison +% Created: +%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 +%} +%{ + 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 . +%} + + +%Variables +nums = [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]; + +%Start the timer +startTime = clock(); + + +%Get the sum of all the numbers +format long; %You need to be able to see 10 digits +sumOfNums = num2str(sum(nums)); %Get the sum of all the numbers +format short; %Set it back to normal + +%Stop the timer +endTime = clock(); + +%Print the results +printf("The first 10 digits are: %s%s\n", sumOfNums(1), sumOfNums(3:11)) +printf("It took %f seconds to run this algorithm\n", etime(endTime, startTime)) + +%Cleanup the variables +clear nums; +clear startTime; +clear endTime; +clear sumOfNums; + +%{ +Results: +The first 10 digits are: 5537376230 +It took 0.001442 seconds to run this algorithm +%} diff --git a/Problem14.m b/Problem14.m new file mode 100644 index 0000000..1b76f20 --- /dev/null +++ b/Problem14.m @@ -0,0 +1,80 @@ +%ProjectEuler/Octave/Problem14.m +%Matthew Ellison +% Created: +%Modified: 03-28-19 +%This is a script to answer Problem 14 for Project Euler +%{ +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? +%} +%{ + 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 . +%} + + +%Setup your variables +currentLength = 0; +maxLength = 0; +currentNum = 1; +maxNum = 0; + +%Start the timer +startTime = clock(); + +%Step through every number less than 1000000 +while(currentNum < 1000000) + currentLength = 0; + workingNum = currentNum; %So you can do math on the current number + while(workingNum > 1) + if(mod(workingNum, 2) == 0) + workingNum = workingNum / 2; + else + workingNum = (3 * workingNum) + 1; + end + ++currentLength; + end + %If the current number has a longer chain than the current max it becomes the max + if(currentLength > maxLength) + maxLength = currentLength; + maxNum = currentNum; + end + ++currentNum; +end + +%Stop the timer +endTime = clock(); + +%Print the results +printf("The longest chain with a starting number < 1000000 is %d with a length of %d\n", maxNum, maxLength) +printf("It took %f seconds to run this algorithm\n", etime(endTime, startTime)) + +%Cleanup the variables +clear maxLength; +clear maxNum; +clear endTime; +clear startTime; +clear currentNum; +clear currentLength; +clear workingNum; +clear ans; + +%{ +Results: +The longest chain with a starting number < 1000000 is 837799 with a length of 524 +It took 1136.180946 seconds to run this algorithm +%} \ No newline at end of file diff --git a/Problem15.m b/Problem15.m new file mode 100644 index 0000000..e7836a5 --- /dev/null +++ b/Problem15.m @@ -0,0 +1,78 @@ +function numOfRoutes = Problem15() +%ProjectEuler/Octave/Problem15.m +%Matthew Ellison +% Created: +%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? +%{ + 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 . +%} + + +%Setup your variables +gridLength = 20; +gridHeight = 20; +numOfRoutes = 0; +currentX = 0; +currentY = 0; + +%Start the timer +startTime = clock(); + +%Get the number of routes from top left to bottom right +numOfRoutes = movement(currentX, currentY, gridLength, gridHeight); + +%Stop the timer +endTime = clock(); + +%Print the results +printf("The number of routes from top left to bottom right is %d\n", numOfRoutes) +printf("It took %f seconds to run this algorithm\n", etime(endTime, startTime)) + +%Cleanup your variables +clear gridLength; +clear gridHeight; +clear numOfRoutes; +clear currentX; +clear currentY; +clear startTime; +clear endTime; + +end %End of Problem15() + +%Simulates moving along the grid +%Recurses moving right first, then down +function num = movement(currentX, currentY, gridLength, gridHeight) + num = 0; + %See if it is at the end of the grid + if((currentX == gridLength) && (currentY == gridHeight)) + num = 1; + else + %If it's not move right first, then move down, if possible + if(currentX < gridLength) + num += movement(currentX + 1, currentY, gridLength, gridHeight); + end + if(currentY < gridHeight) + num += movement(currentX, currentY + 1, gridLength, gridHeight); + end + end +end + +%{ +Results: +///This follows the same idea as my cpp program but I got tired of waiting for it to finish after two hours. +///It should work, but is still untested +%} diff --git a/Problem16.m b/Problem16.m new file mode 100644 index 0000000..1f424f8 --- /dev/null +++ b/Problem16.m @@ -0,0 +1,90 @@ +%ProjectEuler/Octave/Problem16.m +%Matthew Ellison +% Created: +%Modified: 03-28-19 +%What is the sum of the digits of the number 2^1000? +%{ + 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 . +%} + + +%Setup your variables +numberToPower = 2; +POWER = 1000; +nums = [1]; +carry = 0; +currentPower = 0; + +%Start the timer +startTime = clock(); + +%Loop until you reach the correct power to raise the number to +while(currentPower < POWER) + counter = 1; + %Loop through every element in the list and multiply by 2 + while(counter <= size(nums)(2)) + nums(counter) = (nums(counter) * numberToPower) + carry; + carry = 0; + %If one of the elements is >= 10 you need to carry to the next element + if(nums(counter) >= 10) + nums(counter) -= 10; + ++carry; + end + ++counter; + end + %If you have something to carry after everything has been multiplied you need to add a new column + if(carry > 0) + nums(end + 1) = carry; + carry = 0; + end + ++currentPower; +end + +%Stop the timer +endTime = clock(); + +%Print the results +nums = fliplr(nums); %Flip the results so it is easier to move to a string +counter = 1; +number = ['']; +while(counter <= size(nums)(2)) + number(counter) = num2str(nums(counter)); %Convert each number to a character + ++counter; +end + +%Print the results +printf("2^1000 = %s\n", number) +printf("The sum of the digits is: %d\n", sum(nums)) +printf("It took %f seconds to run this algorithm\n", etime(endTime, startTime)) + +%Cleanup your variables +clear numberToPower; +clear POWER; +clear nums; +clear carry; +clear currentPower; +clear counter; +clear startTime; +clear endTime; +clear number; +clear ans; + +%{ +Results: +2^1000 = 10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831652624386837205668069376 +The sum of the digits is: 1366 +It took 3.203796 seconds to run this algorithm +%} \ No newline at end of file diff --git a/Problem17.m b/Problem17.m new file mode 100644 index 0000000..fdea161 --- /dev/null +++ b/Problem17.m @@ -0,0 +1,188 @@ +function sumOfLetters = Problem17() %In order to have other functions the main part had to be a function as well +%ProjectEuler/Octave/Problem17.m +%Matthew Ellison +% Created: 02-05-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? +%{ + 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 . +%} + + +%Setup your variables +sumOfLetters = 0; +startNum = 1; +stopNum = 1000; + +%Start the timer +startTime = clock(); + +%Start with 1 and increment +currentNum = startNum; +for(currentNum = startNum:stopNum) + %Pass the number to a function that will create a string for the number + currentNumString = getStringFromNum(currentNum); + %Pass the string to a function that will count the number of letters in a string, ignoring whitespace and punctuation and add the amount to the running tally + sumOfLetters += getNumberChars(currentNumString); +end + +%Stop the timer +endTime = clock(); + +%Print the results +printf("The sum of all printed number from %d-%d is %d\n", startNum, stopNum, sumOfLetters) +printf("It took %f seconds to run this algorithm\n", etime(endTime, startTime)) + +%Clean up the variables +clear sumOfLetters; +clear startNum; +clear stopNum; +clear startTime; +clear endTime; + +end %End of Problem17() + +%This function returns the number of characters in a string, ignoring whitespace and punctuation +function sumOfLetters = getNumberChars(number) + sumOfLetters = 0; + %Start at location 0 and count the number of letters + for location = 1:size(number)(2) + tempString = substr(number, location, 1); + if(isalpha(tempString)) + ++sumOfLetters; + end + end +end + +%This function creates a string from a number +%It only works for numbers -1,000,000 < num < 1,000,000 +function numberString = getStringFromNum(number) + numberString = ""; + %Starting with the largest digit create a string based on the number passed in + %Check for negative + if(number < 0) + numberString = strcat(numberString, "negative "); + end + + %Check if the number is zero + if(number == 0) + numberString = strcat(numberString, "zero"); + end + + %Start with the thousands place + if((number / 1000) >= 1) + numberString = strcat(numberString, getStringFromNum(floor(number / 1000))); + numberString = strcat(numberString, " thousand"); + number -= (floor(number / 1000) * 1000); + end + + %Check for hundreds place + if((number / 100) >= 1) + numberString = strcat(numberString, getStringFromNum(floor(number / 100))); + numberString = strcat(numberString, " hundred"); + number -= (floor(number / 100) * 100); + end + + %Insert an and if there is need + if((size(numberString)(2) != 0) && (number > 0)) + numberString = strcat(numberString, " and "); + end + + %Check for tens place + if((number / 10) >= 2) + %For the tens you need to do something special + tensPlace = floor(number / 10); + if(tensPlace == 9) + numberString = strcat(numberString, "ninety"); + elseif(tensPlace == 8) + numberString = strcat(numberString, "eighty"); + elseif(tensPlace == 7) + numberString = strcat(numberString, "seventy"); + elseif(tensPlace == 6) + numberString = strcat(numberString, "sixty"); + elseif(tensPlace == 5) + numberString = strcat(numberString, "fifty"); + elseif(tensPlace == 4) + numberString = strcat(numberString, "forty"); + elseif(tensPlace == 3) + numberString = strcat(numberString, "thirty"); + elseif(tensPlace == 2) + numberString = strcat(numberString, "twenty"); + end + number -= (tensPlace * 10); + %If there is something left in the number you will need a space to separate it + if(number > 0) + numberString = strcat(numberString, ' '); + end + %Check for teens + elseif((number / 10) >= 1) + onesPlace = mod(number, 10); + if(onesPlace == 9) + numberString = strcat(numberString, "nineteen"); + elseif(onesPlace == 8) + numberString = strcat(numberString, "eighteen"); + elseif(onesPlace == 7) + numberString = strcat(numberString, "seventeen"); + elseif(onesPlace == 6) + numberString = strcat(numberString, "sixteen"); + elseif(onesPlace == 5) + numberString = strcat(numberString, "fifteen"); + elseif(onesPlace == 4) + numberString = strcat(numberString, "fourteen"); + elseif(onesPlace == 3) + numberString = strcat(numberString, "thirteen"); + elseif(onesPlace == 2) + numberString = strcat(numberString, "twelve"); + elseif(onesPlace == 1) + numberString = strcat(numberString, "eleven"); + elseif(onesPlace == 0) + numberString = strcat(numberString, "ten"); + end + %If this if was hit number was used up + number = 0; + end + + %Check for ones place + if(number >= 1) + if(number == 9) + numberString = strcat(numberString, "nine"); + elseif(number == 8) + numberString = strcat(numberString, "eight"); + elseif(number == 7) + numberString = strcat(numberString, "seven"); + elseif(number == 6) + numberString = strcat(numberString, "six"); + elseif(number == 5) + numberString = strcat(numberString, "five"); + elseif(number == 4) + numberString = strcat(numberString, "four"); + elseif(number == 3) + numberString = strcat(numberString, "three"); + elseif(number == 2) + numberString = strcat(numberString, "two"); + elseif(number == 1) + numberString = strcat(numberString, "one"); + end + %If this if was hit number was used up + number = 0; + end +end + +%{ +Results: +The sum of all printed number from 1-1000 is 21124 +It took 2.79162 seconds to run this algorithm +%} diff --git a/Problem18.m b/Problem18.m new file mode 100644 index 0000000..c78a1c7 --- /dev/null +++ b/Problem18.m @@ -0,0 +1,170 @@ +function [] = Problem18() +%ProjectEuler/Octave/Problem18.m +%Matthew Ellison +% Created: 03-12-19 +%Modified: 03-28-19 +%Find the maximun 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 +%{ + 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 . +%} + + +%Start the timer +startTime = clock(); + +%Setup your variables +NUM_ROWS = 15; +list = {}; +list{1} = [75]; +list{2} = [95, 64]; +list{3} = [17, 47, 82]; +list{4} = [18, 35, 87, 10]; +list{5} = [20, 04, 82, 47, 65]; +list{6} = [19, 01, 23, 75, 03, 34]; +list{7} = [88, 02, 77, 73, 07, 63, 67]; +list{8} = [99, 65, 04, 28, 06, 16, 70, 92]; +list{9} = [41, 41, 26, 56, 83, 40, 80, 70, 33]; +list{10} = [41, 48, 72, 33, 47, 32, 37, 16, 94, 29]; +list{11} = [53, 71, 44, 65, 25, 43, 91, 52, 97, 51, 14]; +list{12} = [70, 11, 33, 28, 77, 73, 17, 78, 39, 68, 17, 57]; +list{13} = [91, 71, 52, 38, 17, 14, 91, 43, 58, 50, 27, 29, 48]; +list{14} = [63, 66, 04, 68, 89, 53, 67, 30, 73, 16, 69, 87, 40, 31]; +list{15} = [04, 62, 98, 27, 23, 9, 70, 98, 73, 93, 38, 53, 60, 04, 23]; + + +%Invert the list so that each element will be 100 - element +list = invert(list); + +%Keeps track of the points that we know they are at their minumum total (Maximum after inversion) +foundPoints = []; +%Add the tip to the list because we have to come through that +foundPoints(end + 1).xLocation = 1; +foundPoints(end).yLocation = 1; +foundPoints(end).total = list{1}(1); +foundPoints(end).fromRight = false; +%Keeps track of points that could be at their maximum +possiblePoints = []; +%Add the second row to the list of possibles +possiblePoints(end + 1).xLocation = 1; +possiblePoints(end).yLocation = 2; +possiblePoints(end).total = (list{1}(1) + list{2}(1)); +possiblePoints(end).fromRight = true; +possiblePoints(end + 1).xLocation = 2; +possiblePoints(end).yLocation = 2; +possiblePoints(end).total = (list{1}(1) + list{2}(2)); +possiblePoints(end).fromRight = false; +foundBottom = false; %Used when you find a point at the bottom of the list + +%Loop until you find the bottom +while(~foundBottom) + %Check which possible point gives us the lowest number. If more than one has the same number simply keep the first one + minLoc = possiblePoints(1); + for loc = 1 : size(possiblePoints)(2) + if(possiblePoints(loc).total < minLoc.total) + minLoc.xLocation = possiblePoints(loc).xLocation; + minLoc.yLocation = possiblePoints(loc).yLocation; + minLoc.total = possiblePoints(loc).total; + minLoc.fromRight = possiblePoints(loc).fromRight; + end + end + %disp(minLoc) + possiblePoints = remove_if(possiblePoints, minLoc); + + %Add the current minimum to the found points + foundPoints(end + 1) = 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 + xLoc = minLoc.xLocation; + yLoc = minLoc.yLocation + 1; %Add one because you will always be moving down a row + if(yLoc > NUM_ROWS) + foundBottom = true; + else + %Add the next 2 possible points + possiblePoints(end + 1).xLocation = xLoc; + possiblePoints(end).yLocation = yLoc; + possiblePoints(end).total = (minLoc.total + list{yLoc}(xLoc)); + possiblePoints(end).fromRight = true; + + xLoc = xLoc + 1; %Advance the x location to simulate going right instead of left + + possiblePoints(end + 1).xLocation = xLoc; + possiblePoints(end).yLocation = yLoc; + possiblePoints(end).total = (minLoc.total + list{yLoc}(xLoc)); + possiblePoints(end).fromRight = false; + end +end + +actualTotal = ((100 * NUM_ROWS) - foundPoints(end).total); + +%Stop the timer +endTime = clock(); + +%Reinvert the list so it will print propperly +invert(list); + +%Print the results +printf("The value of the longest path is %d\n", actualTotal) +printf("It took %f seconds to run this algorithm\n", etime(endTime, startTime)) + +end %End of Problem18() + + +%This function changes each element in the list to 100 - element +function [temp] = invert(list) + temp = list; + for rowCnt = 1 : size(temp)(2) + for colCnt = 1 : size(temp{rowCnt})(2) + temp{rowCnt}(colCnt) = 100 - temp{rowCnt}(colCnt); + end + end +end + +function [temp] = remove_if(list, loc) + location = 1; + while(location <= size(list)(2)) + if((list(location).xLocation == loc.xLocation) && (list(location).yLocation == loc.yLocation)) + list(location) = []; + else + location = location + 1; + end + end + temp = list; +end + +%{ +Results: +The value of the longest path is 1074 +It took 0.098862 seconds to run this algorithm +%} diff --git a/Problem19.m b/Problem19.m new file mode 100644 index 0000000..11fa5d3 --- /dev/null +++ b/Problem19.m @@ -0,0 +1,186 @@ +function [] = Problem19() +%ProjectEuler/Octave/Problem19.m +%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)? +%{ +Results: +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. +%} +%All of my requires, unless otherwise listed, can be found at https://bitbucket.org/Mattrixwv/luaClasses +%{ + 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 . +%} + + +global DAYS = []; +DAYS.SUNDAY = 0; +DAYS.MONDAY = 1; +DAYS.TUESDAY = 2; +DAYS.WEDNESDAY = 3; +DAYS.THURSDAY = 4; +DAYS.FRIDAY = 5; +DAYS.SATURDAY = 6; +DAYS.NUMBER_OF_DAYS = 7; +DAYS.ERROR = 8; +START_YEAR = 1901; +END_YEAR = 2000; + + +%Star the timer +startTime = clock(); + +%Setup the variables +totalSundays = 0; + +%Run for all years from start to end +for year=START_YEAR : END_YEAR + %Run for all months in the year + for month=1 : 12 + day = getDay(month, 1, year); + if(day == DAYS.ERROR) + disp("There was an error with the day\n") + return; + elseif(day == DAYS.SUNDAY) + totalSundays = totalSundays + 1; + end + end +end + +%Stop the timer +stopTime = clock(); + +%Print the results +printf("There are %d Sundays that landed on the first of the month from %d to %d\n", totalSundays, START_YEAR, END_YEAR) +printf("It took %f to run this algorithm\n", etime(stopTime, startTime)) + +end %Problem19() + + +%Returns the day of the week that the day you pass into it is on +function [day] = getDay(month, day, year) + global DAYS; + %Make sure the numbers are within propper bounds + if((month < 1) || (month > 12) || (day < 1) || (day > 31) || (year < 1)) + day = DAYS.ERROR; + return; + end + + numDays = 0; + currentYear = 1; + currentMonth = 1; + currentDay = DAYS.SATURDAY; + day = day - 1; + + %Add the correct number of days for every year + while(currentYear < year) + if(isLeapYear(currentYear)) + numDays = numDays + 366; + else + numDays = numDays + 365; + end + currentYear = currentYear + 1; + end + %Add the correct number of days for every month + while(currentMonth < month) + %February + if(currentMonth == 2) + if(isLeapYear(currentYear)) + numDays = numDays + 29; + else + numDays = numDays + 28; + end + %31 day months + elseif((currentMonth == 1) || (currentMonth == 3) || (currentMonth == 5) || (currentMonth == 7) || (currentMonth == 8) || (currentMonth == 10) || (currentMonth == 12)) + numDays = numDays + 31; + %30 day months + else + numDays = numDays + 30; + end + currentMonth = currentMonth + 1; + end + %Account for the weird year of 1752 + if(year > 1752) + numDays = numDays - 11; + elseif(year == 1752) + if(month > 9) + numDays = numDays - 1; + elseif(month == 9) + if(day >= 14) + numDays = numDays - 11; + %Days 3-13 were skipped that year + elseif((day > 2) && (day < 14)) + day = ERROR; + return; + end + end + end + %Add the correct number of days for every day + numDays = numDays + day; + + currentDay = currentDay + numDays; + currentDay = mod(currentDay, DAYS.NUMBER_OF_DAYS); + if(currentDay == DAYS.SUNDAY) + day = DAYS.SUNDAY; + elseif(currentDay == DAYS.MONDAY) + day = DAYS.MONDAY; + elseif(currentDay == DAYS.TUESDAY) + day = DAYS.TUESDAY; + elseif(currentDay == DAYS.WEDNESDAY) + day = DAYS.WEDNESDAY; + elseif(currentDay == DAYS.THURSDAY) + day = DAYS.THURSDAY; + elseif(currentDay == DAYS.FRIDAY) + day = DAYS.FRIDAY; + elseif(currentDay == DAYS.SATURDAY) + day = DAYS.SATURDAY; + else + day = DAYS.ERROR; + end +end + +function [answer] = isLeapYear(year) + if(year < 1) + answer = false; + elseif(mod(year, 100) == 0) + %This rule only applies at and after 1800 + if(year <= 1700) + answer = true; + elseif(mod(year, 400) == 0) + answer = true; + else + answer = false; + end + elseif(mod(year, 4) == 0) + answer = true; + else + answer = false; + end +end + +%{ +There are 171 Sundays that landed on the first of the month from 1901 to 2000 +It took 68.439590 to run this algorithm +%} diff --git a/Problem2.m b/Problem2.m new file mode 100644 index 0000000..34f5dce --- /dev/null +++ b/Problem2.m @@ -0,0 +1,62 @@ +%ProjectEuler/Octave/Problem2.m +%Matthew Ellison +% Created: +%Modified: 03-28-19 +%The sum of the even Fibonacci numbers less than 4,000,000 +%{ + 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 . +%} + + +%Setup your Variables +fib = [1, 1, 2]; %Holds the Fibonacci numbers +currentFib = fib(end) + fib(end - 1); %The current Fibonacci number to be tested +evenFib = [2]; %A subset of the even Fibonacci numbers + +%Start the timer +startTime = clock(); + +while(currentFib < 4000000) + %Add the number to the list + fib(end + 1) = currentFib; + %If the number is even add it to the even list as well + if(mod(currentFib, 2) == 0) + evenFib(end + 1) = currentFib; + end + + %Set the next Fibonacci + currentFib = fib(end) + fib(end - 1); +end + +%Stop the timer +endTime = clock(); + +%Print the results +printf("The sum of all even Fibonacci numbers less than 4000000 is %d\n", sum(evenFib)) +printf("It took %f seconds to run this algorithm\n", etime(endTime, startTime)) + +%Cleanup your variables +clear fib; +clear currentFib; +clear evenFib; +clear startTime; +clear endTime; + +%{ +Results: +The sum of all even Fibonacci numbers less than 4000000 is 4613732 +It took 0.001076 seconds to run this algorithm +%} diff --git a/Problem20.m b/Problem20.m new file mode 100644 index 0000000..b45cf35 --- /dev/null +++ b/Problem20.m @@ -0,0 +1,68 @@ +%ProjectEuler/Octave/Problem20.m +%Matthew Ellison +% Created: 03-14-19 +%Modified: 03-28-19 +%What is the sum of the digits of 100!? +%This project uses the symbolic library. Make sure that you install the symbolic library as well as sympy before running this script +%The way to do this is run this command in octave: pkg install -forge symbolic +%This library requires sympy as well. This is easily installed with pip: pip install sympy +%{ + 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 . +%} + + +pkg load symbolic; +digits(500) %Keep track of enough digits to do this calculation correctly + + +%The number that will hold 100! +syms num; +syms x; %A helper that will allow us to do easy math with the symbolics +num = 1 * x; +num = subs(num, x, 1); +%Setup the rest of our variables +sumOfNums = 0; %Holds the sum of the digits of num +TOP_NUM = 100; %The number that we are trying to factorial + +%Start the timer +startTime = clock(); + +%Run through every number from 1 to 100 and multiply it by the current number +for cnt = 1 : TOP_NUM + num = num * x; + num = subs(num, x, cnt); +end + +%Get a string of the numebr because it is easier to pull appart the individual characters for the sum +numString = char(num); +%Run through every character in the string, convert it back to an integer and add it to the running sum +for cnt = 1 : size(numString)(2) + sumOfNums += str2num(numString(cnt)); +end + +%Stop the timer +endTime = clock(); + +%Print the results +printf("100! = %s\n", numString) +printf("The sum of the digits is: %d\n", sumOfNums) +printf("It took %f seconds to run this algorithm\n", etime(endTime, startTime)) + +%{ +100! = 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000 +The sum of the digits is: 648 +It took 6.356117 seconds to run this algorithm +%} diff --git a/Problem21.m b/Problem21.m new file mode 100644 index 0000000..9545fe0 --- /dev/null +++ b/Problem21.m @@ -0,0 +1,121 @@ +function [] = Problem21() +%ProjectEuler/Octave/Problem21.m +%Matthew Ellison +% Created: 03-19-19 +%Modified: 03-28-19 +%Evaluate the sum of all the amicable numbers under 10000 +%{ + 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 . +%} + + +%Setup the varibles +LIMIT = 10000; %The top number that will be evaluated +divisorSum = []; %Holds the sum of the factors of the subscript number + +%Start the timer +startTime = clock(); + +%Generate the factors of all the numbers < 10000, get their sum, and add it to the list +for cnt = 1 : LIMIT + divisors = getDivisors(cnt); %Get all the divisors of a number + if(size(divisors)(2) > 1) + divisors(end) = []; %Remove the last entry because it will be the number itself + end + divisorSum(end + 1) = sum(divisors); %Add the sum of the divisors to the vector +end +%Check every sum of divisors in the list for a matching sum +amicable = []; +for cnt = 1 : size(divisorSum)(2) + sumOfDivisors = divisorSum(cnt); + %If the sum is greater than the number of divisors then it is impossible to be amicable. Skip the number and continue + if(sumOfDivisors >= size(divisorSum)(2)) + continue; + %We know that divisorSum[cnt] == sum, do if divisorSum[sum] == cnt we have found an amicable number + elseif(divisorSum(sumOfDivisors) == cnt) + %A number can't be amicable with itself, so skip those numbers + if(sumOfDivisors == cnt) + continue; + end + amicable(end + 1) = cnt; + end +end + +%Stop the timer +endTime = clock(); + +%Sort the vector for neatness +sort(amicable); + +%Print the results +printf("All amicable numbers less than %d are\n", LIMIT) +%Print the list of amicable numbers +for location = 1: size(amicable)(2) + printf("%d\n", amicable(location)) +end +printf("The sum of all of these amicable numbers is %d\n", sum(amicable)) +printf("It took %f seconds to run this algorithm\n", etime(endTime, startTime)) + +end %Problem21() + +function [divisors] = getDivisors(goalNumber) + divisors = []; + %Start by checking that the number is positive + if(goalNumber <= 0) + return; + %If the number is 1 return just itself + elseif(goalNumber == 1) + divisors(end + 1) = 1; + return; + %Otherwise add 1 and itself to the list + else + divisors(end + 1) = 1; + divisors(end + 1) = goalNumber; + end + + %Start at 3 and loop through all numbers < sqrt(goalNumber) looking for a number that divides it evenly + topPossibleDivisor = ceil(sqrt(goalNumber)); + for possibleDivisor = 2 : topPossibleDivisor + %If you find one add it and the number it creates to the list + if(mod(goalNumber, possibleDivisor) == 0) + divisors(end + 1) = possibleDivisor; + %Account for the possibility sqrt(goalNumber) being a divisor + if(possibleDivisor != topPossibleDivisor) + divisors(end + 1) = goalNumber / possibleDivisor; + end + end + end + + %Sort the list before returning for neatness + divisors = sort(divisors); +end + +%{ +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 5.650108 seconds to run this algorithm +%} diff --git a/Problem22.m b/Problem22.m new file mode 100644 index 0000000..be1efbc --- /dev/null +++ b/Problem22.m @@ -0,0 +1,437 @@ +%ProjectEuler/Octave/Problem22.m +%Matthew Ellison +% Created: 03-19-19 +%Modified: 03-28-19 +%What is the total of all the name scores in the file? +%{ + 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 . +%} + + +NAMES = {"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"}; + +%Setup the variables +sums = []; %Holds the score based on the sum of the characters in the name +prods = []; %Holds the score based on the sum of the characters and the location in alphabetical order + +%Start the timer +startTime = clock(); + +%Sort all the names +NAMES = sort(NAMES); +%Step through every name adding up the values of the characters +for nameCnt = 1: size(NAMES)(1) + %Step through every character in the current name adding up the value of the characters + sums(end + 1) = 0; + for charCnt = 1: size(NAMES{nameCnt})(2) + %A = 65 so subtracting 64 means A - 1. This will only work correctly if all letters are capitalized + sums(nameCnt) += (NAMES{nameCnt}(charCnt) - 64); + end +end + +%Get the product for all numbers +for cnt = 1: size(sums)(2) + prods(end + 1) = sums(cnt) * cnt; +end + +%Stop the timer +endTime = clock(); + +%Print the results +printf("The answer to the question is %d\n", sum(prods)) +printf("It took %f seconds to run this algorithm\n", etime(endTime, startTime)); + +clear NAMES; +clear startTime; +clear endTime; +clear sums; +clear prods; +clear charCnt; +clear cnt; +clear nameCnt; + +%{ +Results: +The answer to the question is 871198282 +It took 0.600388 seconds to run this algorithm +%} diff --git a/Problem23.m b/Problem23.m new file mode 100644 index 0000000..d156b7e --- /dev/null +++ b/Problem23.m @@ -0,0 +1,128 @@ +function [] = Problem23() +%ProjectEuler/Octave/Problem23.m +%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 +%{ + 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 . +%} + + +MAX_NUM = 28123; %The highest number that will be evaluated + + +%Setup the variables +divisorSums = []; +%Make sure every element has a 0 in it's location +for cnt = 1 : MAX_NUM + divisorSums(end + 1) = 0; +end + +%Start the timer +startTime = clock(); + +%Get the sum of the divisors of all numbers < MAX_NUM +for cnt = 1 : MAX_NUM + div = getDivisors(cnt); + if(size(div)(2) > 1) + div(end) = []; + end + divisorSums(cnt) = sum(div); +end + +%Get the abundant numbers +abund = []; +for cnt = 1 : size(divisorSums)(2) + if(divisorSums(cnt) > cnt) + abund(end + 1) = cnt; + end +end + +%Check if each number can be the sum of 2 abundant numbers and add to the sum if no +sumOfNums = 0; +for cnt = 1 : MAX_NUM + if(~isSum(abund, cnt)) + printf("Added %d to sum\n", cnt) + sumOfNums += cnt; + end +end + +%Stop the timer +endTime = clock(); + +%Print the results +printf("The answer is %d\n", sumOfNums) +printf("It took %f seconds to run this algorithm\n", etime(endTime, startTime)) + +end %Problem23 + +function [divisors] = getDivisors(goalNumber) + divisors = []; + %Start by checking that the number is positive + if(goalNumber <= 0) + return; + %If the number is 1 return just itself + elseif(goalNumber == 1) + divisors(end + 1) = 1; + return; + end + + %Start at 3 and loop through all numbers < sqrt(goalNumber) looking for a number that divides it evenly + topPossibleDivisor = ceil(sqrt(goalNumber)); + possibleDivisor = 1; + while(possibleDivisor <= topPossibleDivisor) + %If you find one add it and the number it creates to the list + if(mod(goalNumber, possibleDivisor) == 0) + divisors(end + 1) = possibleDivisor; + %Account for the possibility sqrt(goalNumber) being a divisor + if(possibleDivisor != topPossibleDivisor) + divisors(end + 1) = goalNumber / possibleDivisor; + end + %Take care of a few occations where a number was added twice + if(divisors(end) == (possibleDivisor + 1)) + possibleDivisor += 1; + end + end + possibleDivisor += 1; + end + + %Sort the list before returning for neatness + divisors = sort(divisors); +end + +function [answer] = isSum(abund, num) + sumOfNums = 0; + %Pick a number for the first part of the sum + for firstNum = 1 : size(abund)(2) + %Pick a number for the second part of the sum + for secondNum = firstNum : size(abund)(2) + sumOfNums = abund(firstNum) + abund(secondNum); + if(sumOfNums == num) + answer = true; + return; + elseif(sumOfNums > num) + break; + end + end + end + answer = false; +end + +%{ +Results: I let this run for 11 hours and did not come up with a result. I added some tracking and tested again and it seems like it is doing what it is supposed to and will come to the correct answer... eventually +However, for now, this remains unproven. +%} diff --git a/Problem24.m b/Problem24.m new file mode 100644 index 0000000..0400cad --- /dev/null +++ b/Problem24.m @@ -0,0 +1,87 @@ +function [] = Problem24() +%ProjectEuler/Octave/Problem24.m +%Matthew Ellison +% Created: 03-25-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? +%{ + 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 . +%} + + +NEEDED_PERM = 1000000; %The number of the permutation that you need + + +%Setup the variables +nums = "0123456789"; + +%Start the time +startTime = clock(); + +%Get all permutations of the string +permutations = getPermutations(nums); + +%Stop the timer +endTime = clock(); + +%Print the results +printf("The 1 millionth permutation is %s\n", permutations{NEEDED_PERM}) +printf("It took %f second to run this algorithm\n", etime(endTime, startTime)) + + +end %Problem24() + +function [perms] = getPermutations(master, num = 1) + perms = {}; + %Check if the number is out of bounds + if((num > size(master)(2)) || (num <= 0)) + %Do nothing and return and empty list + perms; + %If this is the last possible recurse just return the current string + elseif(num == size(master)(2)) + perms(end + 1) = master; + %If there are more possible recurses, recurse with the current permutations + else + temp = getPermutations(master, num + 1); + perms = {perms{:}, temp{:}}; + %You need to swap the current letter with every possible letter after it + %The ones needed to swap before will happen automatically when the function recurses + for cnt = 1 : (size(master)(2) - num) + %Swap two elements + temp = master(num); + master(num) = master(num + cnt); + master(num + cnt) = temp; + %Get the permutations after swapping two elements + temp = getPermutations(master, num + 1); + perms = {perms{:}, temp{:}}; + %Swap the elements back + temp = master(num); + master(num) = master(num + cnt); + master(num + cnt) = temp; + end + end + + %The array is not necessarily in alpha-numeric order. So if this is the full array sort it before returning + if(num == 1) + perms = sort(perms); + end +end %getPermutations() + +%{ +Results: +The 1 millionth permutation is 2783915460 +It took 433.922920 second to run this algorithm +%} diff --git a/Problem25.m b/Problem25.m new file mode 100644 index 0000000..a624293 --- /dev/null +++ b/Problem25.m @@ -0,0 +1,108 @@ +function [] = Problem25() +%ProjectEuler/Octave/Problem25.m +%Matthew Ellison +% Created: 03-26-19 +%Modified: 03-28-19 +%What is the index of the first term in the Fibonacci sequence to contain 1000 digits? +%This project uses the symbolic library. Make sure that you install the symbolic library as well as sympy before running this script +%The way to do this is run this command in octave: pkg install -forge symbolic +%This library requires sympy as well. This is easily installed with pip: pip install sympy +%{ + 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 . +%} + + +pkg load symbolic; +digits(500) %Keep track of enough digits to do this calculation correctly + +NUM_DIGITS = 1000; %The number of digits to calculate up to + + +%Setup the variables +syms number; %The current Fibonacci number +syms x; %A helper that will allow us to do easy math with the symbolics +number = x; +number = subs(number, x, 0); %Set the number to 0 +indexNum = 2; %The index of the just calculated Fibonacci number + +%Start the timer +startTime = clock(); + +%Move through all Fibonacci numbers until you reach the one with at least NUM_DIGITS digits +while(size(char(number))(2) < NUM_DIGITS) + indexNum += 1; %Increase the index number. Doing this at the beginning keeps the index correct at the end of the loop + number = getFib(indexNum); + printf("Index: %d\n", indexNum) +end + +%Stop the timer +endTime = clock(); + +%Print the results +printf("The first Fibonacci number with %d digits is %s\n", NUM_DIGITS, char(number)) +printf("The index is %d\n", indexNum); +printf("It took %f seconds to run this algorithm\n", etime(endTime, startTime)); + + +end %Problem25 + + +function [num] = getFib(goalSubscript) + %Setup the variables + fibNums = {}; + syms tempNum; + syms x; + tempNum = x; + tempNum = subs(tempNum, x, 1); + fibNums(end + 1) = tempNum; + fibNums(end + 1) = tempNum; + tempNum = x; + tempNum = subs(tempNum, x, 0); + fibNums(end + 1) = tempNum; + + %If the number is <= 0 return 0 + if(goalSubscript <= 0) + num = 0; + return; + end + + %Loop through the list, generating Fibonacci numbers until it finds the correct subscript + fibLoc = 2; + while(fibLoc <= goalSubscript) + tempNum = x; + tempNum = subs(tempNum, x, fibNums(mod((fibLoc - 1), 3) + 1)); + fibNums(mod(fibLoc, 3) + 1) = tempNum; + tempNum = x; + tempNum = subs(tempNum, x, fibNums(mod((fibLoc - 2), 3) + 1)); + fibNums(mod(fibLoc, 3) + 1) += tempNum; + fibLoc += 1; + end + + %Make sure the correct number is chosen for return + answerLocation = mod((fibLoc - 1), 3); + if(answerLocation == 0) + answerLocation = 3; + end + num = fibNums(answerLocation); + +end %getFib + +%{ +Results: +I partially tested this and it seems to be working propperly. +Because I am using the symbolic package to simulate a bigint library it is very slow. +It looks as though it would take several days before it finished. +%} diff --git a/Problem26.m b/Problem26.m new file mode 100644 index 0000000..672f3bf --- /dev/null +++ b/Problem26.m @@ -0,0 +1,96 @@ +function [] = Problem26() +%ProjectEuler/Octave/Problem26.m +%Matthew Ellison +% Created: 08-02-19 +%Modified: 08-02-19 +%Find the value of d < 1000 for which 1/d contains the longest recurring cycle in its decimal fraction part. +%{ + 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 . +%} + + +TOP_NUMBER = 999; %The largest denominator to the checked + + +%Setup variables +longestCycle = 0; % +longestNumber = 1; + +%Start the timer +startTime = clock(); + +%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 denominator = 2 : TOP_NUMBER + remainderList = []; %Holds the list of remainders + endFound = false; %Holds whether we have found an end ot the number (either a cycle or a 0 for a remainder) + cycleFound = false; %Holds whether a cycle was detected + numerator = 1; %The numerator that will be divided + while(~endFound) + %Get the remainder after the division + remainder = mod(numerator, denominator); + %Check if the remainder is 0 + %If it is, set the flag + if(remainder == 0) + endFound = true; + %Check if the remainder is in the list + %If it is in the list, set the appropriate flags + elseif(isFound(remainderList, remainder)) + endFound = true; + cycleFound = true; + %Else add it to the list + else + remainderList(end + 1) = remainder; + end + %Multiply the remainder by 10 to continue finding the next remainder + numerator = remainder * 10; + end + %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(size(remainderList)(2) > longestCycle) + longestCycle = size(remainderList)(2); + longestNumber = denominator; + end + end +end + +%End the timer +endTime = clock(); + +%Print the results +printf("The longest cycle is %d digits long\n", longestCycle); +printf("It is started with the number %d\n", longestNumber); +printf("It took %f seconds to run this algorithm\n", etime(endTime, startTime)); + +end + +function [found] = isFound(array, key) + found = false; %Start with a false. It only turns true if you find key in array + for location = 1 : size(array)(2) + if(key == array(location)) + found = true; + return; + end + end +end + +%{ +Results: +The longest cycle is 982 digits long +It is started with the number 983 +It took 49.173325 seconds to run this algorithm +%} diff --git a/Problem27.m b/Problem27.m new file mode 100644 index 0000000..ab538e4 --- /dev/null +++ b/Problem27.m @@ -0,0 +1,87 @@ +function [] = Problem27() +%ProjectEuler/Octave/Problem27.m +%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. +%{ + 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 . +%} + + +%Setup variables +topA = 0; +topB = 0; +topN = 0; +primeNums = primes(12000); + +%Start timer +startTime = clock(); + + +%Start with the lowest possible A and check all possibilities after that +for a = -999 : 999 + %Start with the lowest possible B and check all possibilities after that + for b = -1000 : 1000 + %Start with n=0 and check the formula to see how many primes you can get get with concecutive n's + n = 0; + quadratic = (n * n) + (a * n) + b; + while(isFound(primeNums, quadratic)) + ++n; + quadratic = (n * n) + (a * n) + b; + end + --n; + + %Set all the largest number if this creaed more primes than any other + if(n > topN) + topN = n; + topB = b; + topA = a; + end + end +end + + +%End the timer +endTime = clock(); + +%Print the results +printf("The greatest number of primes found is %d", topN) +printf("\nIt was found with A = %d, B = %d", topA, topB) +printf("\nThe product of A and B is %d\n", topA * topB) +printf("It took %f seconds to run this algorithm\n", etime(endTime, startTime)) + +end + +function [found] = isFound(array, key) + found = false; %Start with a false. It only turns true if you find key in array + for location = 1 : size(array)(2) + if(key < array(location)) + return; + elseif(key == array(location)) + found = true; + return; + end + end +end + +%{ +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 1298.651146 seconds to run this algorithm +%} diff --git a/Problem28.m b/Problem28.m new file mode 100644 index 0000000..59da28a --- /dev/null +++ b/Problem28.m @@ -0,0 +1,100 @@ +function [] = Problem28() +%ProjectEuler/Octave/Problem28.m +%Matthew Ellison +% Created: 09-29-19 +%Modified: 10-06-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. +%{ + 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 . +%} + + +%Setup the variables +finalLocation = false; %A flag to indicate if the final location to be filled has been reached +currentNum = 1; %Set the number that is going to be put at each location +%Make a 1001x1001 grid full of 0's +square = zeros(1001, 1001); + +%Start the timer +startTime = clock(); + +%Start with the middle location and set it correctly and advance the tracker to the next number +xLocation = 501; +yLocation = 501; +square(yLocation, 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(square(yLocation, xLocation - 1) ~= 0) + square(yLocation, xLocation) = currentNum++; + ++yLocation; + end + %Move left until you reach a blank location above + while(square(yLocation - 1, xLocation) ~= 0) + square(yLocation, xLocation) = currentNum++; + --xLocation; + end + %Move up until you reach a blank location to the right + while(square(yLocation, xLocation + 1) ~= 0) + square(yLocation, xLocation) = currentNum++; + --yLocation; + end + %Move right until you reach a blank location below + while(square(yLocation + 1, xLocation) ~= 0) + square(yLocation, xLocation) = currentNum++; + ++xLocation; + %Check if you are at the final location and break the loop if you are + if(xLocation > size(square)(2)) + finalLocation = true; + break; + end + end +end + +%Get the sum of the diagonals +sumOfDiag = 0; +leftSide = 1; +rightSide = size(square)(2); +row = 1; +while(row <= size(square)(2)) + %This ensure the middle location is only counted one + if(leftSide == rightSide) + sumOfDiag += square(row, leftSide); + else + sumOfDiag += square(row, leftSide); + sumOfDiag += square(row, rightSide); + end + ++row; + ++leftSide; + --rightSide; +end + +%Stop the timer +endTime = clock(); + +%Print the results +printf("The sum of the diagonals in the given grid is %d\n", sumOfDiag); +printf("It took %f to run this algorithm\n", etime(endTime, startTime)); + +end + +%{ +Results: +The sum of the diagonals in the given grid is 669171001 +It took 8.751038 to run this algorithm +%} diff --git a/Problem29.m b/Problem29.m new file mode 100644 index 0000000..61c31f1 --- /dev/null +++ b/Problem29.m @@ -0,0 +1,105 @@ +function [] = Problem29() +%ProjectEuler/Octave/Problem29.m +%Matthew Ellison +% Created: 10-16-19 +%Modified: 10-20-19 +%How many distinct terms are in the sequence generated by a^b for 2 <= a <= 100 and 2 <= b <= 100? +%{ + 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 . +%} + + +%Setup your variables +BOTTOM_A = 2; %The lowest possible value for A +TOP_A = 100; %The highest possible value for A +BOTTOM_B = 2; %The lowest possible value for B +TOP_B = 100; %The highest possible value for B +uniq = {}; %A table to hold all of the unique answers for the equation +currentNum = [];%Holds the answer to the equation for a particular loop + + +%Start the timer +startTime = clock(); + +%Start with the lowest A and move towards the largest +for currentA = BOTTOM_A : TOP_A + currentA + %Start with the lowest B and move towards the largest + for currentB = BOTTOM_B : TOP_B + %Get the number + %Start with the base number and multiply until you reach the correct power + currentPower = 0; + carry = 0; + currentNum = [1]; + while(currentPower < currentB) + counter = 1; + %Loop through every element in the list and multiply it by the current A + while(counter <= size(currentNum)(2)) + currentNum(counter) = (currentNum(counter) * currentA) + carry; + carry = 0; + %If one fo the elements is too large you need to carry that to the next element + while(currentNum(counter) >= 10) + currentNum(counter) -= 10; + ++carry; + end + ++counter; + end + %If you ahve something to carry after everything has been multiplied you need to add a new column + while(carry > 0) + currentNum(end + 1) = carry; + carry = 0; + %If one fo the elements is too large you need to carry that to the next element + while(currentNum(end) >= 10) + currentNum(end) -= 10; + ++carry; + end + end + ++currentPower; + end + %If the number isn't in the list add it + if(~isFound(uniq, currentNum)) + uniq(end + 1) = currentNum; + end + end +end + +%Stop the timer +endTime = clock(); + +%Print the results +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, size(uniq)(2)); +printf("It took %f seconds to run this algorithm\n", etime(endTime, startTime)) + +end + + +function [found] = isFound(array, key) + found = false; %Start with a false. It only turns true if you find key in array + for location = 1 : size(array)(2) + if(size(key)(2) != size(array{location})(2)) + continue; + elseif(key == array{location}) + found = true; + return; + end + end +end + +%{ +This has not run to completion because it would take an insane amount of time +but it got the correct results on several subsets (compared with my python code) +so it should come up with the same answer. +%} diff --git a/Problem3.m b/Problem3.m new file mode 100644 index 0000000..1c06c44 --- /dev/null +++ b/Problem3.m @@ -0,0 +1,83 @@ +%ProjectEuler/Octave/Problem3.m +%Matthew Ellison +% Created: +%Modified: 03-28-19 +%The largest prime factor of 600851475143 +%{ + 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 . +%} + + +%Setup your variables +number = 600851475143; %The number we are trying to find the greatest prime factor of +primeNums = []; %A list of prime numbers. Will include all prime numbers <= number +factors = []; %For the list of factors of number +tempNum = number; %Used to track the current value if all of the factors were taken out of number + +%Get the prime numbers up to sqrt(number). If it is not prime there must be a value <= sqrt +primeNums = primes(sqrt(number)); + +%Start the timer +startTime = clock(); + +%Setup the loop +counter = 1; + +%Start with the lowest number and work your way up. When you reach a number > size(primeNums) you have found all of the factors +while(counter <= size(primeNums)(2)) + + %Divide the number by the next prime number in the list + answer = (tempNum/primeNums(counter)); + + %If it is a whole number add it to the factors + if(mod(answer,1) == 0) + factors(end + 1) = primeNums(counter); + %Set tempNum so that it reflects number/factors + tempNum = tempNum / primeNums(counter); + %Keep the counter where it is in case a factor appears more than once + %Get the new set of prime numbers + primeNums = primes(sqrt(tempNum)); + else + %If it was not an integer increment the counter + ++counter; + end +end +%When the last number is not divisible by a prime number it must be a prime number +factors(end + 1) = tempNum; + +%Stop the timer +endTime = clock(); + +%Print the results +printf("The largest prime factor of 600851475143 is %d\n", max(factors)) +printf("It took %f seconds to run this algorithm\n", etime(endTime, startTime)) + +%Cleanup your variables +clear counter; +clear tempNum; +clear answer; +clear number; +clear primeNums; +clear factors; +clear startTime; +clear endTime; +clear ans; + +%{ +Results: +The largest prime factor of 600851475143 is 6857 +It took 0.006256 seconds to run this algorithm +%} diff --git a/Problem30.m b/Problem30.m new file mode 100644 index 0000000..687663f --- /dev/null +++ b/Problem30.m @@ -0,0 +1,76 @@ +function [] = Problem30() +%ProjectEuler/Octave/Problem30.m +%Matthew Ellison +% Created: 10-28-19 +%Modified: 10-28-19 +%Find the sum of all the numbers that can be written as the sum of the fifth powers of their digits. +%{ + 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 . +%} + + +%Setup the variables +TOP_NUM = 1000000; %This is the largest number that will be check +BOTTOM_NUM = 2; %Starts with 2 because 0 and 1 don't count +POWER_RAISED = 5; %This is the power that the digits are raised to +sumOfFifthNumbers = []; %This is an array of the numbers that are the sum of the fifth power of their digits + +%Start the timer +startTime = clock(); + +%Start with the lowest number and increment until you reach the largest number +for currentNum = BOTTOM_NUM : TOP_NUM + printf("%d\n", currentNum) + %Get the digits of the number + digits = getDigits(currentNum); + %Get the sum of the powers + sumOfPowers = 0; + for cnt = 1 : size(digits)(2) + sumOfPowers += digits(cnt)^POWER_RAISED; + end + %Check if the sum of the powers is the same as the number + %If it is add it to the list, otherwise continue to the next number + if(sumOfPowers == currentNum) + sumOfFifthNumbers(end + 1) = currentNum; + end +end + +%Stop the timer +endTime = clock(); + +%Print the results +printf("The sum of all the numbers that can be written as the sum of the fifth powers of their digits is %d\n", sum(sumOfFifthNumbers)) +printf("It took %f seconds to run this algorithm\n", etime(endTime, startTime)) + +end + + +%Returns an array with the individual digits of the number passed to it +function [listOfDigits] = getDigits(num) + listOfDigits = []; %This array holds the individual digits of num + %The easiest way to get the individual digits of a number is by converting it to a string + digits = num2str(num); + %Start with the first digit, convert it to an integer, store it in the table, and move to the next digit + for cnt = 1 : size(digits)(2) + listOfDigits(end + 1) = str2num(substr(digits, cnt, 1)); + end +end + +%{ +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 1849.877525 seconds to run this algorithm +%} diff --git a/Problem4.m b/Problem4.m new file mode 100644 index 0000000..ffca8b7 --- /dev/null +++ b/Problem4.m @@ -0,0 +1,79 @@ +%ProjectEuler/Octave/Problem4.m +%Matthew Ellison +% Created: +%Modified: 03-28-19 +%Find the largest palindrome made from the product of two 3-digit numbers +%{ + 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 . +%} + + +%Make your variables +answer = 0; %For the product of the two numbers +numbers = [100:999]; %Create an array with a list of all 3 digit numbers +palindromes = []; %Holds all the numbers that are palindromes +%Create 2 counters for an inner loop and an outer loop +%This allows you to multiply 2 numbers from the same array +outerCounter = 1; +innerCounter = 1; + +%Start the timer +startTime = clock(); + +while(outerCounter < size(numbers)(2)) + innerCounter = outerCounter; %Once you have multiplied 2 numbers there is no need to multiply them again, so skip what has already been done + while(innerCounter < size(numbers)(2)) + %Multiply the two numbers + answer = numbers(outerCounter) * numbers(innerCounter); + + %See if the number is a palindromes + %%WARNING - Ocatave does not have a Reverse function. I had to create one that reversed strings + if(num2str(answer) == Reverse(num2str(answer))) + %Add it to the palindromes list + palindromes(end + 1) = answer; + end + ++innerCounter; %Increment + end + ++outerCounter; %Increment +end + +%Stop the timer +endTime = clock(); %This is for timing purposes + + +%Print the results +printf("The largest palindrome made from the product of two 3-digit numbers is %d\n", max(palindromes)) +printf("It took %f seconds to run this algorithm\n", etime(endTime, startTime)) + +%Cleanup your variables +clear outerCounter; +clear innerCounter; +clear answer; +clear numbers; +clear palindromes; +clear startTime; +clear endTime; + +%{ +Results: +The largest palindrome made from the product of two 3-digit numbers is 906609 +It took 663.732803 seconds to run this algorithm +%} + +%This way is slow. I would like to find a faster way +%{ +The palindrome can be written as: abccba Which then simpifies to: 100000a + 10000b + 1000c + 100c + 10b + a And then: 100001a + 10010b + 1100c Factoring out 11, you get: 11(9091a + 910b + 100c) So the palindrome must be divisible by 11. Seeing as 11 is prime, at least one of the numbers must be divisible by 11 +%} diff --git a/Problem5.m b/Problem5.m new file mode 100644 index 0000000..6835de9 --- /dev/null +++ b/Problem5.m @@ -0,0 +1,79 @@ +%ProjectEuler/Octave/Problem5.m +%Matthew Ellison +% Created: 03-16-19 +%Modified: 03-28-19 +%What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20? +%{ + 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 . +%} + + +%Create your variables +nums = [1:20]; +factors = [1]; %The factors that are already in the number +list = []; %For a temperary list of the factors of the current number +counter = 1; + +%Start the timer +startTime = clock(); + +%You need to find the factors of all the numbers from 1->20 +while(counter <= size(nums)(2)) + list = factor(nums(counter)); + + %Search factors and try to match all elements in list + listCnt = 1; + factorCnt = 1; + while(listCnt <= size(list)(2)) + if((factorCnt > size(factors)(2)) || (factors(factorCnt) > list(listCnt))) + %If it was not found add the factor to the list for the number and reset the counters + factors(end + 1) = list(listCnt); + factors = sort(factors); + factorCnt = 1; + listCnt = 1; + elseif(factors(factorCnt) == list(listCnt)) + ++listCnt; + ++factorCnt; + else + ++factorCnt; + end + end + ++counter; +end + +%Stop the timer +endTime = clock(); + +%Print the results +printf("The smallest positive number that is evenly divisible by all numbers 1-20 is %d\n", prod(factors)) +printf("It took %f seconds to run this algorithm\n", etime(endTime, startTime)) + +%Cleanup your variables +clear counter; +clear factorCnt; +clear listCnt; +clear list; +clear nums; +clear factors; +clear startTime; +clear endTime; +clear ans; + +%{ +Results: +The smallest positive number that is evenly divisible by all numbers 1-20 is 232792560 +It took 0.010742 seconds to run this algorithm +%} diff --git a/Problem6.m b/Problem6.m new file mode 100644 index 0000000..d8dfbd6 --- /dev/null +++ b/Problem6.m @@ -0,0 +1,55 @@ +%ProjectEuler/Octave/Problem6.m +%Matthew Ellison +% Created: +%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. +%{ + 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 . +%} + + +%Start the timer +startTime = clock(); + +%Setup your variables +nums = [1:100]; +squares = nums.^2; %Square every number in the list nums +sumOfSquares = sum(squares); %Get the sum of all the elements in the list squares +squareOfSums = sum(nums)^2; %Get the sum of all the elements in the list nums and square the answer +value = abs(squareOfSums - sumOfSquares); %Get the difference of the 2 numbers +%This could all be done on one line, but this is less confusing + +%Stop the timer +endTime = clock(); + +%Print the results +printf("The difference between the sum of the squares and the square of the sum of the numbers 1-100 is %d\n", value) +printf("It took %f seconds to run this algorithm\n", etime(endTime, startTime)) + +%Cleanup your variables +clear nums; +clear squares; +clear sumOfSquares; +clear squareOfSums; +clear value; +clear startTime; +clear endTime; + +%{ +Results: +The difference between the sum of the squares and the square of the sum of the numbers 1-100 is 25164150 +It took 0.000137 seconds to run this algorithm +%} diff --git a/Problem67.m b/Problem67.m new file mode 100644 index 0000000..95843d7 --- /dev/null +++ b/Problem67.m @@ -0,0 +1,340 @@ +function [] = Problem67() +%ProjectEuler/Octave/Problem67.m +%Matthew Ellison +% Created: 03-26-19 +%Modified: 03-28-19 +%Find the maximun 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 +%{ + 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 . +%} + + +%Start the timer +startTime = clock(); + +%Setup your variables +NUM_ROWS = 100; +list = {}; +list{1} = [59]; +list{2} = [73, 41]; +list{3} = [52, 40, 9]; +list{4} = [26, 53, 06, 34]; +list{5} = [10, 51, 87, 86, 81]; +list{6} = [61, 95, 66, 57, 25, 68]; +list{7} = [90, 81, 80, 38, 92, 67, 73]; +list{8} = [30, 28, 51, 76, 81, 18, 75, 44]; +list{9} = [84, 14, 95, 87, 62, 81, 17, 78, 58]; +list{10} = [21, 46, 71, 58, 02, 79, 62, 39, 31, 9]; +list{11} = [56, 34, 35, 53, 78, 31, 81, 18, 90, 93, 15]; +list{12} = [78, 53, 04, 21, 84, 93, 32, 13, 97, 11, 37, 51]; +list{13} = [45, 03, 81, 79, 05, 18, 78, 86, 13, 30, 63, 99, 95]; +list{14} = [39, 87, 96, 28, 03, 38, 42, 17, 82, 87, 58, 07, 22, 57]; +list{15} = [06, 17, 51, 17, 07, 93, 9, 07, 75, 97, 95, 78, 87, 8, 53]; +list{16} = [67, 66, 59, 60, 88, 99, 94, 65, 55, 77, 55, 34, 27, 53, 78, 28]; +list{17} = [76, 40, 41, 04, 87, 16, 9, 42, 75, 69, 23, 97, 30, 60, 10, 79, 87]; +list{18} = [12, 10, 44, 26, 21, 36, 32, 84, 98, 60, 13, 12, 36, 16, 63, 31, 91, 35]; +list{19} = [70, 39, 06, 05, 55, 27, 38, 48, 28, 22, 34, 35, 62, 62, 15, 14, 94, 89, 86]; +list{20} = [66, 56, 68, 84, 96, 21, 34, 34, 34, 81, 62, 40, 65, 54, 62, 05, 98, 03, 02, 60]; +list{21} = [38, 89, 46, 37, 99, 54, 34, 53, 36, 14, 70, 26, 02, 90, 45, 13, 31, 61, 83, 73, 47]; +list{22} = [36, 10, 63, 96, 60, 49, 41, 05, 37, 42, 14, 58, 84, 93, 96, 17, 9, 43, 05, 43, 06, 59]; +list{23} = [66, 57, 87, 57, 61, 28, 37, 51, 84, 73, 79, 15, 39, 95, 88, 87, 43, 39, 11, 86, 77, 74, 18]; +list{24} = [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{25} = [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{26} = [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{27} = [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{28} = [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{29} = [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{30} = [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{31} = [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{32} = [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{33} = [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{34} = [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{35} = [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{36} = [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{37} = [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{38} = [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{39} = [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{40} = [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{41} = [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{42} = [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{43} = [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{44} = [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{45} = [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{46} = [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{47} = [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{48} = [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{49} = [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{50} = [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{51} = [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{52} = [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{53} = [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{54} = [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{55} = [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{56} = [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{57} = [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{58} = [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{59} = [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{60} = [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{61} = [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{62} = [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{63} = [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{64} = [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{65} = [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{66} = [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{67} = [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{68} = [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{69} = [ 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{70} = [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{71} = [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{72} = [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{73} = [ 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{74} = [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{75} = [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{76} = [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{77} = [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{78} = [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{79} = [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{80} = [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{81} = [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{82} = [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{83} = [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{84} = [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{85} = [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{86} = [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{87} = [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{88} = [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{89} = [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{90} = [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{91} = [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{92} = [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{93} = [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{94} = [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{95} = [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{96} = [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{97} = [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{98} = [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{99} = [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{100} =[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 so that each element will be 100 - element +list = invert(list); + +%Keeps track of the points that we know they are at their minumum total (Maximum after inversion) +foundPoints = []; +%Add the tip to the list because we have to come through that +foundPoints(end + 1).xLocation = 1; +foundPoints(end).yLocation = 1; +foundPoints(end).total = list{1}(1); +foundPoints(end).fromRight = false; +%Keeps track of points that could be at their maximum +possiblePoints = []; +%Add the second row to the list of possibles +possiblePoints(end + 1).xLocation = 1; +possiblePoints(end).yLocation = 2; +possiblePoints(end).total = (list{1}(1) + list{2}(1)); +possiblePoints(end).fromRight = true; +possiblePoints(end + 1).xLocation = 2; +possiblePoints(end).yLocation = 2; +possiblePoints(end).total = (list{1}(1) + list{2}(2)); +possiblePoints(end).fromRight = false; +foundBottom = false; %Used when you find a point at the bottom of the list + +%Loop until you find the bottom +while(~foundBottom) + %Check which possible point gives us the lowest number. If more than one has the same number simply keep the first one + minLoc = possiblePoints(1); + for loc = 1 : size(possiblePoints)(2) + if(possiblePoints(loc).total < minLoc.total) + minLoc.xLocation = possiblePoints(loc).xLocation; + minLoc.yLocation = possiblePoints(loc).yLocation; + minLoc.total = possiblePoints(loc).total; + minLoc.fromRight = possiblePoints(loc).fromRight; + end + end + %disp(minLoc) + possiblePoints = remove_if(possiblePoints, minLoc); + + %Add the current minimum to the found points + foundPoints(end + 1) = 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 + xLoc = minLoc.xLocation; + yLoc = minLoc.yLocation + 1; %Add one because you will always be moving down a row + if(yLoc > NUM_ROWS) + foundBottom = true; + else + %Add the next 2 possible points + possiblePoints(end + 1).xLocation = xLoc; + possiblePoints(end).yLocation = yLoc; + possiblePoints(end).total = (minLoc.total + list{yLoc}(xLoc)); + possiblePoints(end).fromRight = true; + + xLoc = xLoc + 1; %Advance the x location to simulate going right instead of left + + possiblePoints(end + 1).xLocation = xLoc; + possiblePoints(end).yLocation = yLoc; + possiblePoints(end).total = (minLoc.total + list{yLoc}(xLoc)); + possiblePoints(end).fromRight = false; + end +end + +actualTotal = ((100 * NUM_ROWS) - foundPoints(end).total); + +%Stop the timer +endTime = clock(); + +%Reinvert the list so it will print propperly +invert(list); + +%Print the results +printf("The value of the longest path is %d\n", actualTotal) +printf("It took %f seconds to run this algorithm\n", etime(endTime, startTime)) + +end %End of Problem18() + + +%This function changes each element in the list to 100 - element +function [temp] = invert(list) + temp = list; + for rowCnt = 1 : size(temp)(2) + for colCnt = 1 : size(temp{rowCnt})(2) + temp{rowCnt}(colCnt) = 100 - temp{rowCnt}(colCnt); + end + end +end + +function [temp] = remove_if(list, loc) + location = 1; + while(location <= size(list)(2)) + if((list(location).xLocation == loc.xLocation) && (list(location).yLocation == loc.yLocation)) + list(location) = []; + else + location = location + 1; + end + end + temp = list; +end + +%{ +Results: +The value of the longest path is 7273 +It took 1274.581131 seconds to run this algorithm +%} diff --git a/Problem7.m b/Problem7.m new file mode 100644 index 0000000..64be6b9 --- /dev/null +++ b/Problem7.m @@ -0,0 +1,54 @@ +%ProjectEuler/Octave/Problem7.m +%Matthew Ellison +% Created: +%Modified: 03-28-19 +%What is the 10001th prime number? +%{ + 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 . +%} + + +%Setup the variables +counter = 1000; +primeList = []; + +%Start the timer +startTime = clock(); + +%Cycle through the prime numbers until you get the correct number +while(size(primeList)(2) < 10001) + primeList = primes(counter); + counter += 1000; +end + +%Stop the timer +endTime = clock(); + +%Print the results +printf("The 10001st prime number is %d\n", primeList(10001)) +printf("It took %f seconds to run this algorithm\n", etime(endTime, startTime)) + +%Cleanup the variables +clear counter; +clear primeList; +clear startTime; +clear endTime; + +%{ +Results: +The 10001st prime number is 104743 +It took 0.107124 seconds to run this algorithm +%} diff --git a/Problem8.m b/Problem8.m new file mode 100644 index 0000000..b562519 --- /dev/null +++ b/Problem8.m @@ -0,0 +1,99 @@ +%ProjectEuler/Octave/Problem8.m +%Matthew Ellison +% Created: +%Modified: 03-28-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 +%} +%{ + 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 . +%} + + +%Setup your variables +%The string of the number +number = '7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450'; +counter = 1; %Location of the first digit in the series +productNumbers = ['']; %The numbers in the current product +greatestProduct = []; %The numbers in the greatest product + +%Start the timer +startTime = clock(); + +%Loop through the string until every element has been tested +while((counter + 12) < size(number)(2)) + innerCounter = 0; + productNumbers = ['']; %Clear the variable + while(innerCounter < 13) + %Octave throws an error if you don't take this round about way of adding the characters to the array + tempChar = ''; %Throw away variable + tempChar = [number(counter + innerCounter), ' ']; %Add the next number to what you already have and add a space at the end + productNumbers = [productNumbers, tempChar]; + ++innerCounter; + end + productNumbers = str2num(productNumbers); %Convert the characters to numbers + %Check whether the current product is greater than the current greatest product + if(prod(productNumbers) > prod(greatestProduct)) + greatestProduct = productNumbers; + end + ++counter; +end + +%Stop the timer +endTime = clock(); + +%Print the results +printf("The largest product of 13 adjacent digits in the number is %d\n", prod(greatestProduct)) +printf("The numbers are: %d %d %d %d %d %d %d %d %d %d %d %d %d\n", greatestProduct(1), greatestProduct(2), greatestProduct(3), greatestProduct(4), greatestProduct(5), greatestProduct(6), greatestProduct(7), greatestProduct(8), greatestProduct(9), greatestProduct(10), greatestProduct(11), greatestProduct(12), greatestProduct(13)) +printf("It took %f seconds to run this algorithm\n", etime(endTime, startTime)) + +%Cleanup your variables +clear number; +clear counter; +clear productNumbers; +clear greatestProduct; +clear tempChar; +clear innerCounter; +clear startTime; +clear endTime; +clear ans; + +%{ +Results: +The largest product of 13 adjacent digits in the number is 23514624000 +The numbers are: 5 5 7 6 6 8 9 6 6 4 8 9 5 +It took 0.431618 seconds to run this algorithm +%} diff --git a/Problem9.m b/Problem9.m new file mode 100644 index 0000000..3f02c0a --- /dev/null +++ b/Problem9.m @@ -0,0 +1,72 @@ +%ProjectEuler/Octave/Problem9.m +%Matthew Ellison +% Created: +%Modified: 03-28-19 +%There exists exactly one Pythagorean triplet for which a + b + c = 1000. Find the product abc. +%{ + 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 . +%} + + +%Create the variable +a = 1; +b = 0; +c = 0; +found = false; + +%Start the timer +startTime = clock(); + +%Start with the smallest possible a +while((a < 1000) && ~found) + b = a + 1; %b must be > a + c = sqrt(a^2 + b^2); %c^2 = a^2 + b^2 + %Loop through all possible b's. When the sum of a, b, c is > 1000. You done have the number. Try the next a + while((a + b + c) < 1000) + ++b; + c = sqrt(a^2 + b^2); + end + %If you haven't found the numbers yet, increment a and try again + if((a + b + c) == 1000) + found = true; + else + ++a; + end +end + +%Stop the timer +endTime = clock(); + +%print the results +printf("The Pythagorean triplet where a + b + c = 1000 is %d %d %d\n", a, b, c) +printf("The product of those numbers is %d\n", a * b * c) +printf("It took %f seconds to run this algorithm\n", etime(endTime, startTime)) + +%Cleanup the variables +clear a; +clear b; +clear c; +clear found; +clear startTime; +clear endTime; +clear ans; + +%{ +Results: +The Pythagorean triplet where a + b + c = 1000 is 200 375 425 +The product of those numbers is 31875000 +It took 0.573143 seconds to run this algorithm +%} diff --git a/Reverse.m b/Reverse.m new file mode 100644 index 0000000..ee3c05a --- /dev/null +++ b/Reverse.m @@ -0,0 +1,24 @@ +function [rString] = Reverse(str) +%Reverse(string) +%This function Reverse the order of the elements in an array +%It was specifically designed for a string, but should work on other 1xX arrays + +%ProjectEuler/Octave/Reverse.m +%Matthew Ellison +% Created: +%Modified: 03-28-19 +%This is a function that reverses the elements in an array + + if(nargin ~= 1) + error('That is not a valid number of arguments') + return; + end + + counter = size(str)(2); %Set the counter to the last element in string + %Loop until the counter reaches 0 + while(counter > 0) + %Add the current element of string to rString + rString(end + 1) = str(counter); + --counter; + end +end