commit 4953474bf83b507513d85f351842b1167447a37c Author: Mattrixwv Date: Sat Jun 6 17:23:54 2020 -0400 Initial commit with existing files 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