ProjectEuler/ProjectEulerOctave
1
0
Fork 0
mirror of https://bitbucket.org/Mattrixwv/projecteuleroctave.git synced 2025-12-06 17:43:57 -05:00
Code Issues Packages Projects Releases Wiki Activity

Initial commit with existing files

Browse Source
This commit is contained in:
Mattrixwv
2020-06-06 17:23:54 -04:00
commit 4953474bf8
34 changed files with 3949 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored Normal file
View File

@@ -0,0 +1,2 @@
#Visual Studio Code
.vscode

165
LICENSE Normal file
View File

@@ -0,0 +1,165 @@
GNU LESSER GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
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.

65
Problem1.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
%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
%}

47
Problem10.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
%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
%}

171
Problem11.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
%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
%}

93
Problem12.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
%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
%}

254
Problem13.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
%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
%}

80
Problem14.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
%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
%}

78
Problem15.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
%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
%}

90
Problem16.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
%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
%}

188
Problem17.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
%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
%}

170
Problem18.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
%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
%}

186
Problem19.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
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
%}

62
Problem2.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
%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
%}

68
Problem20.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
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
%}

121
Problem21.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
%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
%}

437
Problem22.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
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
%}

128
Problem23.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
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.
%}

87
Problem24.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
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
%}

108
Problem25.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
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.
%}

96
Problem26.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
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
%}

87
Problem27.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
%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
%}

100
Problem28.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
%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
%}

105
Problem29.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
%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.
%}

83
Problem3.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
%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
%}

76
Problem30.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
%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
%}

79
Problem4.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
%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
%}

79
Problem5.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
%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
%}

55
Problem6.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
%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
%}

340
Problem67.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
%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
%}

54
Problem7.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
%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
%}

99
Problem8.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
%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
%}

72
Problem9.m Normal file
View File

@@ -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 <https://www.gnu.org/licenses/>.
%}
%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
%}

24
Reverse.m Normal file
View File

@@ -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