From 321e91c0985b251264a18b6c140489184b9fee17 Mon Sep 17 00:00:00 2001 From: Mattrixwv Date: Sat, 6 Jun 2020 17:15:36 -0400 Subject: [PATCH] Initial commit with existing files --- .gitignore | 2 + LICENSE | 165 +++++++++++++++++++ Problem1.lua | 51 ++++++ Problem10.lua | 52 ++++++ Problem11.lua | 183 +++++++++++++++++++++ Problem12.lua | 65 ++++++++ Problem13.lua | 251 +++++++++++++++++++++++++++++ Problem14.lua | 83 ++++++++++ Problem15.lua | 74 +++++++++ Problem16.lua | 57 +++++++ Problem17.lua | 186 +++++++++++++++++++++ Problem18.lua | 227 ++++++++++++++++++++++++++ Problem19.lua | 186 +++++++++++++++++++++ Problem2.lua | 59 +++++++ Problem20.lua | 62 +++++++ Problem21.lua | 94 +++++++++++ Problem22.lua | 436 ++++++++++++++++++++++++++++++++++++++++++++++++++ Problem23.lua | 91 +++++++++++ Problem24.lua | 51 ++++++ Problem25.lua | 63 ++++++++ Problem26.lua | 86 ++++++++++ Problem27.lua | 77 +++++++++ Problem28.lua | 114 +++++++++++++ Problem29.lua | 64 ++++++++ Problem3.lua | 46 ++++++ Problem30.lua | 89 +++++++++++ Problem4.lua | 56 +++++++ Problem5.lua | 66 ++++++++ Problem6.lua | 51 ++++++ Problem67.lua | 331 ++++++++++++++++++++++++++++++++++++++ Problem7.lua | 45 ++++++ Problem8.lua | 81 ++++++++++ Problem9.lua | 72 +++++++++ 33 files changed, 3616 insertions(+) create mode 100644 .gitignore create mode 100644 LICENSE create mode 100644 Problem1.lua create mode 100644 Problem10.lua create mode 100644 Problem11.lua create mode 100644 Problem12.lua create mode 100644 Problem13.lua create mode 100644 Problem14.lua create mode 100644 Problem15.lua create mode 100644 Problem16.lua create mode 100644 Problem17.lua create mode 100644 Problem18.lua create mode 100644 Problem19.lua create mode 100644 Problem2.lua create mode 100644 Problem20.lua create mode 100644 Problem21.lua create mode 100644 Problem22.lua create mode 100644 Problem23.lua create mode 100644 Problem24.lua create mode 100644 Problem25.lua create mode 100644 Problem26.lua create mode 100644 Problem27.lua create mode 100644 Problem28.lua create mode 100644 Problem29.lua create mode 100644 Problem3.lua create mode 100644 Problem30.lua create mode 100644 Problem4.lua create mode 100644 Problem5.lua create mode 100644 Problem6.lua create mode 100644 Problem67.lua create mode 100644 Problem7.lua create mode 100644 Problem8.lua create mode 100644 Problem9.lua diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..ca3b510 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +#Visual Studio Code +.vscode diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..0a04128 --- /dev/null +++ b/LICENSE @@ -0,0 +1,165 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + + This version of the GNU Lesser General Public License incorporates +the terms and conditions of version 3 of the GNU General Public +License, supplemented by the additional permissions listed below. + + 0. Additional Definitions. + + As used herein, "this License" refers to version 3 of the GNU Lesser +General Public License, and the "GNU GPL" refers to version 3 of the GNU +General Public License. + + "The Library" refers to a covered work governed by this License, +other than an Application or a Combined Work as defined below. + + An "Application" is any work that makes use of an interface provided +by the Library, but which is not otherwise based on the Library. +Defining a subclass of a class defined by the Library is deemed a mode +of using an interface provided by the Library. + + A "Combined Work" is a work produced by combining or linking an +Application with the Library. The particular version of the Library +with which the Combined Work was made is also called the "Linked +Version". + + The "Minimal Corresponding Source" for a Combined Work means the +Corresponding Source for the Combined Work, excluding any source code +for portions of the Combined Work that, considered in isolation, are +based on the Application, and not on the Linked Version. + + The "Corresponding Application Code" for a Combined Work means the +object code and/or source code for the Application, including any data +and utility programs needed for reproducing the Combined Work from the +Application, but excluding the System Libraries of the Combined Work. + + 1. Exception to Section 3 of the GNU GPL. + + You may convey a covered work under sections 3 and 4 of this License +without being bound by section 3 of the GNU GPL. + + 2. Conveying Modified Versions. + + If you modify a copy of the Library, and, in your modifications, a +facility refers to a function or data to be supplied by an Application +that uses the facility (other than as an argument passed when the +facility is invoked), then you may convey a copy of the modified +version: + + a) under this License, provided that you make a good faith effort to + ensure that, in the event an Application does not supply the + function or data, the facility still operates, and performs + whatever part of its purpose remains meaningful, or + + b) under the GNU GPL, with none of the additional permissions of + this License applicable to that copy. + + 3. Object Code Incorporating Material from Library Header Files. + + The object code form of an Application may incorporate material from +a header file that is part of the Library. You may convey such object +code under terms of your choice, provided that, if the incorporated +material is not limited to numerical parameters, data structure +layouts and accessors, or small macros, inline functions and templates +(ten or fewer lines in length), you do both of the following: + + a) Give prominent notice with each copy of the object code that the + Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the object code with a copy of the GNU GPL and this license + document. + + 4. Combined Works. + + You may convey a Combined Work under terms of your choice that, +taken together, effectively do not restrict modification of the +portions of the Library contained in the Combined Work and reverse +engineering for debugging such modifications, if you also do each of +the following: + + a) Give prominent notice with each copy of the Combined Work that + the Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the Combined Work with a copy of the GNU GPL and this license + document. + + c) For a Combined Work that displays copyright notices during + execution, include the copyright notice for the Library among + these notices, as well as a reference directing the user to the + copies of the GNU GPL and this license document. + + d) Do one of the following: + + 0) Convey the Minimal Corresponding Source under the terms of this + License, and the Corresponding Application Code in a form + suitable for, and under terms that permit, the user to + recombine or relink the Application with a modified version of + the Linked Version to produce a modified Combined Work, in the + manner specified by section 6 of the GNU GPL for conveying + Corresponding Source. + + 1) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (a) uses at run time + a copy of the Library already present on the user's computer + system, and (b) will operate properly with a modified version + of the Library that is interface-compatible with the Linked + Version. + + e) Provide Installation Information, but only if you would otherwise + be required to provide such information under section 6 of the + GNU GPL, and only to the extent that such information is + necessary to install and execute a modified version of the + Combined Work produced by recombining or relinking the + Application with a modified version of the Linked Version. (If + you use option 4d0, the Installation Information must accompany + the Minimal Corresponding Source and Corresponding Application + Code. If you use option 4d1, you must provide the Installation + Information in the manner specified by section 6 of the GNU GPL + for conveying Corresponding Source.) + + 5. Combined Libraries. + + You may place library facilities that are a work based on the +Library side by side in a single library together with other library +facilities that are not Applications and are not covered by this +License, and convey such a combined library under terms of your +choice, if you do both of the following: + + a) Accompany the combined library with a copy of the same work based + on the Library, uncombined with any other library facilities, + conveyed under the terms of this License. + + b) Give prominent notice with the combined library that part of it + is a work based on the Library, and explaining where to find the + accompanying uncombined form of the same work. + + 6. Revised Versions of the GNU Lesser General Public License. + + The Free Software Foundation may publish revised and/or new versions +of the GNU Lesser General Public License from time to time. Such new +versions will be similar in spirit to the present version, but may +differ in detail to address new problems or concerns. + + Each version is given a distinguishing version number. If the +Library as you received it specifies that a certain numbered version +of the GNU Lesser General Public License "or any later version" +applies to it, you have the option of following the terms and +conditions either of that published version or of any later version +published by the Free Software Foundation. If the Library as you +received it does not specify a version number of the GNU Lesser +General Public License, you may choose any version of the GNU Lesser +General Public License ever published by the Free Software Foundation. + + If the Library as you received it specifies that a proxy can decide +whether future versions of the GNU Lesser General Public License shall +apply, that proxy's public statement of acceptance of any version is +permanent authorization for you to choose that version for the +Library. diff --git a/Problem1.lua b/Problem1.lua new file mode 100644 index 0000000..aa8b6f0 --- /dev/null +++ b/Problem1.lua @@ -0,0 +1,51 @@ +--ProjectEuler/lua/Problem1.lua +--Matthew Ellison +-- Created: 02-01-19 +--Modified: 03-28-19 +--What is the sum of all the multiples of 3 or 5 that are less than 1000 +--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 . +]] + + +require "Stopwatch" + + +timer = Stopwatch:create(); +timer:start(); + +TOP_NUMBER = 999; --This is the largest number that you are going to check +sumOfMultiples = 0; +for num = 1, TOP_NUMBER do + if((num % 3) == 0) then + sumOfMultiples = sumOfMultiples + num; + elseif((num % 5) == 0) then + sumOfMultiples = sumOfMultiples + num; + end +end + +timer:stop() + +--Print the results +print("The sum of all numbers < 1000 is " .. sumOfMultiples); +print("It took " .. timer:getMicroseconds() .. " microseconds to run this algorithm"); + + +--[[Results: +The sum of all numbers < 1000 is 233168 +It took 148 microseconds to run this algorithm +]] diff --git a/Problem10.lua b/Problem10.lua new file mode 100644 index 0000000..15aebcb --- /dev/null +++ b/Problem10.lua @@ -0,0 +1,52 @@ +--ProjectEuler/lua/Problem10.lua +--Matthew Ellison +-- Created: 02-06-19 +--Modified: 03-28-19 +--Find the sum of all the primes below two million +--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 . +]] + + +require "Stopwatch" +require "Algorithms" + + +timer = Stopwatch:create(); +timer:start(); + +LARGEST_PRIME = 2000000; --Sum all prime numbers smaller than this + +--Get all of the prime numbers < LARGEST_PRIME +local primes = getPrimes(LARGEST_PRIME); + +--Get the sum of the table +local sumOfPrimes = 0; +for location=1,#primes do + sumOfPrimes = sumOfPrimes + primes[location]; +end + +timer:stop(); + +--Print the results +print("The sum of all prime numbers less than " .. LARGEST_PRIME .. " is " .. sumOfPrimes); +print("It took " .. timer:getSeconds() .. " seconds to run this algorithm"); + +--[[Results: +The sum of all prime numbers less than 2000000 is 142913828922 +It took 5.940409 seconds to run this algorithm +]] diff --git a/Problem11.lua b/Problem11.lua new file mode 100644 index 0000000..f05c920 --- /dev/null +++ b/Problem11.lua @@ -0,0 +1,183 @@ +--ProjectEuler/lua/Problem11.lua +--Matthew Ellison +-- Created: 02-06-19 +--Modified: 03-28-19 +--What is the greatest product of four adjacent numbers in the same direction (up, down, left, right, or diagonally) in the 20×20 grid? +--[[ +08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08 +49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00 +81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65 +52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91 +22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80 +24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50 +32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70 +67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21 +24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72 +21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95 +78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92 +16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57 +86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58 +19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40 +04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66 +88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69 +04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36 +20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16 +20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54 +01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48 +]] +--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 . +]] + + +require "Stopwatch" + + +timer = Stopwatch:create(); +timer:start(); + +--Setup the grid of numbers +local GRID = {}; +GRID[1] = {8, 2, 22, 97, 38, 15, 00, 40, 00, 75, 4, 5, 7, 78, 52, 12, 50, 77, 91, 8}; +GRID[2] = {49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48, 4, 56, 62, 00}; +GRID[3] = {81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30, 3, 49, 13, 36, 65}; +GRID[4] = {52, 70, 95, 23, 4, 60, 11, 42, 69, 24, 68, 56, 1, 32, 56, 71, 37, 2, 36, 91}; +GRID[5] = {22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80}; +GRID[6] = {24, 47, 32, 60, 99, 3, 45, 2, 44, 75, 33, 53, 78, 36, 84, 20, 35, 17, 12, 50}; +GRID[7] = {32, 98, 81, 28, 64, 23, 67, 10, 26, 38, 40, 67, 59, 54, 70, 66, 18, 38, 64, 70}; +GRID[8] = {67, 26, 20, 68, 2, 62, 12, 20, 95, 63, 94, 39, 63, 8, 40, 91, 66, 49, 94, 21}; +GRID[9] = {24, 55, 58, 5, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72}; +GRID[10] = {21, 36, 23, 9, 75, 00, 76, 44, 20, 45, 35, 14, 00, 61, 33, 97, 34, 31, 33, 95}; +GRID[11] = {78, 17, 53, 28, 22, 75, 31, 67, 15, 94, 3, 80, 4, 62, 16, 14, 9, 53, 56, 92}; +GRID[12] = {16, 39, 5, 42, 96, 35, 31, 47, 55, 58, 88, 24, 00, 17, 54, 24, 36, 29, 85, 57}; +GRID[13] = {86, 56, 00, 48, 35, 71, 89, 7, 5, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58}; +GRID[14] = {19, 80, 81, 68, 5, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77, 4, 89, 55, 40}; +GRID[15] = {4, 52, 8, 83, 97, 35, 99, 16, 7, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66}; +GRID[16] = {88, 36, 68, 87, 57, 62, 20, 72, 3, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69}; +GRID[17] = {4, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18, 8, 46, 29, 32, 40, 62, 76, 36}; +GRID[18] = {20, 69, 36, 41, 72, 30, 23, 88, 34, 62, 99, 69, 82, 67, 59, 85, 74, 4, 36, 16}; +GRID[19] = {20, 73, 35, 29, 78, 31, 90, 1, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57, 5, 54}; +GRID[20] = {1, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52, 1, 89, 19, 67, 48}; + +--This function returns the product of all elements in a table +function getTableProduct(numbers) + local product = 1; --Start with 1 because you are working with multiplication + --Loop through ever element in a table and multiply them all together + for location=1,#numbers do + product = product * numbers[location]; + end + --Return the product of all elements + return product; +end + +local greatestNumbers = {0, 0, 0, 0}; --Holds the numbers that give the greatest product +local currentNumbers = {0, 0, 0, 0}; --Holds the numbers that you are currently working with +--Loop through ever location in the grid +for row=1,#GRID do + for col=1,#GRID[row] do + --Setup variables for know what direction you can move + local moveLeft = false; + local moveRight = false; + local moveDown = false; + + --Check which directions you will be able to move + if((col - 3) >= 1) then + moveLeft = true; + end + if((col + 3) <= #GRID[row]) then + moveRight = true; + end + if((row + 3) <= #GRID) then + moveDown = true; + end + + --With these movements check for the greatest product of 4 adjacent numbers + --Move Right + if(moveRight) then + currentNumbers[1] = GRID[row][col]; + currentNumbers[2] = GRID[row][col + 1]; + currentNumbers[3] = GRID[row][col + 2]; + currentNumbers[4] = GRID[row][col + 3]; + --Check if the current set is greater than the maximum + if(getTableProduct(currentNumbers) > getTableProduct(greatestNumbers)) then + greatestNumbers[1] = currentNumbers[1]; + greatestNumbers[2] = currentNumbers[2]; + greatestNumbers[3] = currentNumbers[3]; + greatestNumbers[4] = currentNumbers[4]; + end + end + + --Move Down + if(moveDown) then + currentNumbers[1] = GRID[row][col]; + currentNumbers[2] = GRID[row + 1][col]; + currentNumbers[3] = GRID[row + 2][col]; + currentNumbers[4] = GRID[row + 3][col]; + --Check if the current set is greater than the maximum + if(getTableProduct(currentNumbers) > getTableProduct(greatestNumbers)) then + greatestNumbers[1] = currentNumbers[1]; + greatestNumbers[2] = currentNumbers[2]; + greatestNumbers[3] = currentNumbers[3]; + greatestNumbers[4] = currentNumbers[4]; + end + end + + --Move Down & Left + if(moveDown and moveLeft) then + currentNumbers[1] = GRID[row][col]; + currentNumbers[2] = GRID[row + 1][col - 1]; + currentNumbers[3] = GRID[row + 2][col - 2]; + currentNumbers[4] = GRID[row + 3][col - 3]; + + --Check if the current set is greater than the maximum + if(getTableProduct(currentNumbers) > getTableProduct(greatestNumbers)) then + greatestNumbers[1] = currentNumbers[1]; + greatestNumbers[2] = currentNumbers[2]; + greatestNumbers[3] = currentNumbers[3]; + greatestNumbers[4] = currentNumbers[4]; + end + end + + --Move Down & Right + if(moveDown and moveRight) then + currentNumbers[1] = GRID[row][col]; + currentNumbers[2] = GRID[row + 1][col + 1]; + currentNumbers[3] = GRID[row + 2][col + 2]; + currentNumbers[4] = GRID[row + 3][col + 3]; + --Check if the current set is greater than the maximum + if(getTableProduct(currentNumbers) > getTableProduct(greatestNumbers)) then + greatestNumbers[1] = currentNumbers[1]; + greatestNumbers[2] = currentNumbers[2]; + greatestNumbers[3] = currentNumbers[3]; + greatestNumbers[4] = currentNumbers[4]; + end + end + end +end + +timer:stop(); + +--Print the results +print("The greatest product of 4 numbers in a line is " .. getTableProduct(greatestNumbers)); +print("The numbers are " .. greatestNumbers[1] .. ' ' .. greatestNumbers[2] .. ' ' .. greatestNumbers[3] .. ' ' .. greatestNumbers[4]); +print("It took " .. timer:getMilliseconds() .. " milliseconds to run this algorithm"); + +--[[Results: +The greatest product of 4 numbers in a line is 70600674 +The numbers are 89 94 97 87 +It took 0.701 milliseconds to run this algorithm +]] diff --git a/Problem12.lua b/Problem12.lua new file mode 100644 index 0000000..0ce6644 --- /dev/null +++ b/Problem12.lua @@ -0,0 +1,65 @@ +--ProjectEUler/lua/Problem12.lua +--Matthew Ellison +-- Created: 02-07-19 +--Modified: 03-28-19 +--What is the value of the first triangle number to have over five hundred divisors? +--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 . +]] + + +require "Stopwatch" +require "Algorithms" + + +timer = Stopwatch:create(); +timer:start(); + +GOAL_DIVISORS = 500; + +local triangularNumber = 1; +local nextNumber = 2; +local foundNumber = false; +local divisors = {}; + +while((not foundNumber) and (triangularNumber > 0)) do + --See how many divisors this triangular number has + divisors = getDivisors(triangularNumber); + --If it has more than GOAL_DIVISORS raise a flag to stop the loop + if(#divisors > GOAL_DIVISORS) then + foundNumber = true; + else + triangularNumber = triangularNumber + nextNumber; --Add the next number to continue the triangular sequence + nextNumber = nextNumber + 1; --Advance to the next number for the triangular sequence + end +end + +timer:stop(); + +--Print the results +if(foundNumber) then + print("The first triangular number with more than " .. GOAL_DIVISORS .. " divisors is " .. triangularNumber); +else + print("There was an error. Could not find a triangular number with " .. GOAL_DIVISORS .. " divisors before overflow"); +end +print("It took " .. timer:getSeconds() .. " seconds to run this algorithm"); + + +--[[Results +The first triangular number with more than 500divisors is 76576500 +It took 1.498547 seconds to run this algorithm +]] diff --git a/Problem13.lua b/Problem13.lua new file mode 100644 index 0000000..927479c --- /dev/null +++ b/Problem13.lua @@ -0,0 +1,251 @@ +--ProjectEuler/lua/Problem13.lua +--Matthew Ellison +-- Created: 02-07-19 +--Modified: 03-28-19 +--Work out the first ten digits of the sum of the following one-hundred 50-digit numbers +--[[ +37107287533902102798797998220837590246510135740250 +46376937677490009712648124896970078050417018260538 +74324986199524741059474233309513058123726617309629 +91942213363574161572522430563301811072406154908250 +23067588207539346171171980310421047513778063246676 +89261670696623633820136378418383684178734361726757 +28112879812849979408065481931592621691275889832738 +44274228917432520321923589422876796487670272189318 +47451445736001306439091167216856844588711603153276 +70386486105843025439939619828917593665686757934951 +62176457141856560629502157223196586755079324193331 +64906352462741904929101432445813822663347944758178 +92575867718337217661963751590579239728245598838407 +58203565325359399008402633568948830189458628227828 +80181199384826282014278194139940567587151170094390 +35398664372827112653829987240784473053190104293586 +86515506006295864861532075273371959191420517255829 +71693888707715466499115593487603532921714970056938 +54370070576826684624621495650076471787294438377604 +53282654108756828443191190634694037855217779295145 +36123272525000296071075082563815656710885258350721 +45876576172410976447339110607218265236877223636045 +17423706905851860660448207621209813287860733969412 +81142660418086830619328460811191061556940512689692 +51934325451728388641918047049293215058642563049483 +62467221648435076201727918039944693004732956340691 +15732444386908125794514089057706229429197107928209 +55037687525678773091862540744969844508330393682126 +18336384825330154686196124348767681297534375946515 +80386287592878490201521685554828717201219257766954 +78182833757993103614740356856449095527097864797581 +16726320100436897842553539920931837441497806860984 +48403098129077791799088218795327364475675590848030 +87086987551392711854517078544161852424320693150332 +59959406895756536782107074926966537676326235447210 +69793950679652694742597709739166693763042633987085 +41052684708299085211399427365734116182760315001271 +65378607361501080857009149939512557028198746004375 +35829035317434717326932123578154982629742552737307 +94953759765105305946966067683156574377167401875275 +88902802571733229619176668713819931811048770190271 +25267680276078003013678680992525463401061632866526 +36270218540497705585629946580636237993140746255962 +24074486908231174977792365466257246923322810917141 +91430288197103288597806669760892938638285025333403 +34413065578016127815921815005561868836468420090470 +23053081172816430487623791969842487255036638784583 +11487696932154902810424020138335124462181441773470 +63783299490636259666498587618221225225512486764533 +67720186971698544312419572409913959008952310058822 +95548255300263520781532296796249481641953868218774 +76085327132285723110424803456124867697064507995236 +37774242535411291684276865538926205024910326572967 +23701913275725675285653248258265463092207058596522 +29798860272258331913126375147341994889534765745501 +18495701454879288984856827726077713721403798879715 +38298203783031473527721580348144513491373226651381 +34829543829199918180278916522431027392251122869539 +40957953066405232632538044100059654939159879593635 +29746152185502371307642255121183693803580388584903 +41698116222072977186158236678424689157993532961922 +62467957194401269043877107275048102390895523597457 +23189706772547915061505504953922979530901129967519 +86188088225875314529584099251203829009407770775672 +11306739708304724483816533873502340845647058077308 +82959174767140363198008187129011875491310547126581 +97623331044818386269515456334926366572897563400500 +42846280183517070527831839425882145521227251250327 +55121603546981200581762165212827652751691296897789 +32238195734329339946437501907836945765883352399886 +75506164965184775180738168837861091527357929701337 +62177842752192623401942399639168044983993173312731 +32924185707147349566916674687634660915035914677504 +99518671430235219628894890102423325116913619626622 +73267460800591547471830798392868535206946944540724 +76841822524674417161514036427982273348055556214818 +97142617910342598647204516893989422179826088076852 +87783646182799346313767754307809363333018982642090 +10848802521674670883215120185883543223812876952786 +71329612474782464538636993009049310363619763878039 +62184073572399794223406235393808339651327408011116 +66627891981488087797941876876144230030984490851411 +60661826293682836764744779239180335110989069790714 +85786944089552990653640447425576083659976645795096 +66024396409905389607120198219976047599490197230297 +64913982680032973156037120041377903785566085089252 +16730939319872750275468906903707539413042652315011 +94809377245048795150954100921645863754710598436791 +78639167021187492431995700641917969777599028300699 +15368713711936614952811305876380278410754449733078 +40789923115535562561142322423255033685442488917353 +44889911501440648020369068063960672322193204149535 +41503128880339536053299340368006977710650566631954 +81234880673210146739058568557934581403627822703280 +82616570773948327592232845941706525094512325230608 +22918802058777319719839450180888072429661980811197 +77158542502016545090413245809786882778948721859617 +72107838435069186155435662884062257473692284509516 +20849603980134001723930671666823555245252804609722 +53503534226472524250874054075591789781264330331690 +]] +--All of my requires, unless otherwise listed, can be found at https://bitbucket.org/Mattrixwv/luaClasses +--I used the bigint library from https://github.com/empyreuma/bigint.lua +--[[ + 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 . +]] + + +require "Stopwatch" +local bigint = require "bigint" + + +timer = Stopwatch:create(); +timer:start(); + +NUMBERS = {}; +NUMBERS[#NUMBERS+1] = bigint.new("37107287533902102798797998220837590246510135740250") +NUMBERS[#NUMBERS+1] = bigint.new("46376937677490009712648124896970078050417018260538") +NUMBERS[#NUMBERS+1] = bigint.new("74324986199524741059474233309513058123726617309629") +NUMBERS[#NUMBERS+1] = bigint.new("91942213363574161572522430563301811072406154908250") +NUMBERS[#NUMBERS+1] = bigint.new("23067588207539346171171980310421047513778063246676") +NUMBERS[#NUMBERS+1] = bigint.new("89261670696623633820136378418383684178734361726757") +NUMBERS[#NUMBERS+1] = bigint.new("28112879812849979408065481931592621691275889832738") +NUMBERS[#NUMBERS+1] = bigint.new("44274228917432520321923589422876796487670272189318") +NUMBERS[#NUMBERS+1] = bigint.new("47451445736001306439091167216856844588711603153276") +NUMBERS[#NUMBERS+1] = bigint.new("70386486105843025439939619828917593665686757934951") +NUMBERS[#NUMBERS+1] = bigint.new("62176457141856560629502157223196586755079324193331") +NUMBERS[#NUMBERS+1] = bigint.new("64906352462741904929101432445813822663347944758178") +NUMBERS[#NUMBERS+1] = bigint.new("92575867718337217661963751590579239728245598838407") +NUMBERS[#NUMBERS+1] = bigint.new("58203565325359399008402633568948830189458628227828") +NUMBERS[#NUMBERS+1] = bigint.new("80181199384826282014278194139940567587151170094390") +NUMBERS[#NUMBERS+1] = bigint.new("35398664372827112653829987240784473053190104293586") +NUMBERS[#NUMBERS+1] = bigint.new("86515506006295864861532075273371959191420517255829") +NUMBERS[#NUMBERS+1] = bigint.new("71693888707715466499115593487603532921714970056938") +NUMBERS[#NUMBERS+1] = bigint.new("54370070576826684624621495650076471787294438377604") +NUMBERS[#NUMBERS+1] = bigint.new("53282654108756828443191190634694037855217779295145") +NUMBERS[#NUMBERS+1] = bigint.new("36123272525000296071075082563815656710885258350721") +NUMBERS[#NUMBERS+1] = bigint.new("45876576172410976447339110607218265236877223636045") +NUMBERS[#NUMBERS+1] = bigint.new("17423706905851860660448207621209813287860733969412") +NUMBERS[#NUMBERS+1] = bigint.new("81142660418086830619328460811191061556940512689692") +NUMBERS[#NUMBERS+1] = bigint.new("51934325451728388641918047049293215058642563049483") +NUMBERS[#NUMBERS+1] = bigint.new("62467221648435076201727918039944693004732956340691") +NUMBERS[#NUMBERS+1] = bigint.new("15732444386908125794514089057706229429197107928209") +NUMBERS[#NUMBERS+1] = bigint.new("55037687525678773091862540744969844508330393682126") +NUMBERS[#NUMBERS+1] = bigint.new("18336384825330154686196124348767681297534375946515") +NUMBERS[#NUMBERS+1] = bigint.new("80386287592878490201521685554828717201219257766954") +NUMBERS[#NUMBERS+1] = bigint.new("78182833757993103614740356856449095527097864797581") +NUMBERS[#NUMBERS+1] = bigint.new("16726320100436897842553539920931837441497806860984") +NUMBERS[#NUMBERS+1] = bigint.new("48403098129077791799088218795327364475675590848030") +NUMBERS[#NUMBERS+1] = bigint.new("87086987551392711854517078544161852424320693150332") +NUMBERS[#NUMBERS+1] = bigint.new("59959406895756536782107074926966537676326235447210") +NUMBERS[#NUMBERS+1] = bigint.new("69793950679652694742597709739166693763042633987085") +NUMBERS[#NUMBERS+1] = bigint.new("41052684708299085211399427365734116182760315001271") +NUMBERS[#NUMBERS+1] = bigint.new("65378607361501080857009149939512557028198746004375") +NUMBERS[#NUMBERS+1] = bigint.new("35829035317434717326932123578154982629742552737307") +NUMBERS[#NUMBERS+1] = bigint.new("94953759765105305946966067683156574377167401875275") +NUMBERS[#NUMBERS+1] = bigint.new("88902802571733229619176668713819931811048770190271") +NUMBERS[#NUMBERS+1] = bigint.new("25267680276078003013678680992525463401061632866526") +NUMBERS[#NUMBERS+1] = bigint.new("36270218540497705585629946580636237993140746255962") +NUMBERS[#NUMBERS+1] = bigint.new("24074486908231174977792365466257246923322810917141") +NUMBERS[#NUMBERS+1] = bigint.new("91430288197103288597806669760892938638285025333403") +NUMBERS[#NUMBERS+1] = bigint.new("34413065578016127815921815005561868836468420090470") +NUMBERS[#NUMBERS+1] = bigint.new("23053081172816430487623791969842487255036638784583") +NUMBERS[#NUMBERS+1] = bigint.new("11487696932154902810424020138335124462181441773470") +NUMBERS[#NUMBERS+1] = bigint.new("63783299490636259666498587618221225225512486764533") +NUMBERS[#NUMBERS+1] = bigint.new("67720186971698544312419572409913959008952310058822") +NUMBERS[#NUMBERS+1] = bigint.new("95548255300263520781532296796249481641953868218774") +NUMBERS[#NUMBERS+1] = bigint.new("76085327132285723110424803456124867697064507995236") +NUMBERS[#NUMBERS+1] = bigint.new("37774242535411291684276865538926205024910326572967") +NUMBERS[#NUMBERS+1] = bigint.new("23701913275725675285653248258265463092207058596522") +NUMBERS[#NUMBERS+1] = bigint.new("29798860272258331913126375147341994889534765745501") +NUMBERS[#NUMBERS+1] = bigint.new("18495701454879288984856827726077713721403798879715") +NUMBERS[#NUMBERS+1] = bigint.new("38298203783031473527721580348144513491373226651381") +NUMBERS[#NUMBERS+1] = bigint.new("34829543829199918180278916522431027392251122869539") +NUMBERS[#NUMBERS+1] = bigint.new("40957953066405232632538044100059654939159879593635") +NUMBERS[#NUMBERS+1] = bigint.new("29746152185502371307642255121183693803580388584903") +NUMBERS[#NUMBERS+1] = bigint.new("41698116222072977186158236678424689157993532961922") +NUMBERS[#NUMBERS+1] = bigint.new("62467957194401269043877107275048102390895523597457") +NUMBERS[#NUMBERS+1] = bigint.new("23189706772547915061505504953922979530901129967519") +NUMBERS[#NUMBERS+1] = bigint.new("86188088225875314529584099251203829009407770775672") +NUMBERS[#NUMBERS+1] = bigint.new("11306739708304724483816533873502340845647058077308") +NUMBERS[#NUMBERS+1] = bigint.new("82959174767140363198008187129011875491310547126581") +NUMBERS[#NUMBERS+1] = bigint.new("97623331044818386269515456334926366572897563400500") +NUMBERS[#NUMBERS+1] = bigint.new("42846280183517070527831839425882145521227251250327") +NUMBERS[#NUMBERS+1] = bigint.new("55121603546981200581762165212827652751691296897789") +NUMBERS[#NUMBERS+1] = bigint.new("32238195734329339946437501907836945765883352399886") +NUMBERS[#NUMBERS+1] = bigint.new("75506164965184775180738168837861091527357929701337") +NUMBERS[#NUMBERS+1] = bigint.new("62177842752192623401942399639168044983993173312731") +NUMBERS[#NUMBERS+1] = bigint.new("32924185707147349566916674687634660915035914677504") +NUMBERS[#NUMBERS+1] = bigint.new("99518671430235219628894890102423325116913619626622") +NUMBERS[#NUMBERS+1] = bigint.new("73267460800591547471830798392868535206946944540724") +NUMBERS[#NUMBERS+1] = bigint.new("76841822524674417161514036427982273348055556214818") +NUMBERS[#NUMBERS+1] = bigint.new("97142617910342598647204516893989422179826088076852") +NUMBERS[#NUMBERS+1] = bigint.new("87783646182799346313767754307809363333018982642090") +NUMBERS[#NUMBERS+1] = bigint.new("10848802521674670883215120185883543223812876952786") +NUMBERS[#NUMBERS+1] = bigint.new("71329612474782464538636993009049310363619763878039") +NUMBERS[#NUMBERS+1] = bigint.new("62184073572399794223406235393808339651327408011116") +NUMBERS[#NUMBERS+1] = bigint.new("66627891981488087797941876876144230030984490851411") +NUMBERS[#NUMBERS+1] = bigint.new("60661826293682836764744779239180335110989069790714") +NUMBERS[#NUMBERS+1] = bigint.new("85786944089552990653640447425576083659976645795096") +NUMBERS[#NUMBERS+1] = bigint.new("66024396409905389607120198219976047599490197230297") +NUMBERS[#NUMBERS+1] = bigint.new("64913982680032973156037120041377903785566085089252") +NUMBERS[#NUMBERS+1] = bigint.new("16730939319872750275468906903707539413042652315011") +NUMBERS[#NUMBERS+1] = bigint.new("94809377245048795150954100921645863754710598436791") +NUMBERS[#NUMBERS+1] = bigint.new("78639167021187492431995700641917969777599028300699") +NUMBERS[#NUMBERS+1] = bigint.new("15368713711936614952811305876380278410754449733078") +NUMBERS[#NUMBERS+1] = bigint.new("40789923115535562561142322423255033685442488917353") +NUMBERS[#NUMBERS+1] = bigint.new("44889911501440648020369068063960672322193204149535") +NUMBERS[#NUMBERS+1] = bigint.new("41503128880339536053299340368006977710650566631954") +NUMBERS[#NUMBERS+1] = bigint.new("81234880673210146739058568557934581403627822703280") +NUMBERS[#NUMBERS+1] = bigint.new("82616570773948327592232845941706525094512325230608") +NUMBERS[#NUMBERS+1] = bigint.new("22918802058777319719839450180888072429661980811197") +NUMBERS[#NUMBERS+1] = bigint.new("77158542502016545090413245809786882778948721859617") +NUMBERS[#NUMBERS+1] = bigint.new("72107838435069186155435662884062257473692284509516") +NUMBERS[#NUMBERS+1] = bigint.new("20849603980134001723930671666823555245252804609722") +NUMBERS[#NUMBERS+1] = bigint.new("53503534226472524250874054075591789781264330331690") + +--Get the sum of all the numbers in the table +local sum = bigint.new(0); +for location=1,#NUMBERS do + sum = bigint.add(sum, NUMBERS[location]); +end + +timer:stop(); + +--Print the results +print("The sum off all " .. #NUMBERS .. " numbers is " .. bigint.unserialize(sum, 's')); +print("The first 10 digits are " .. string.sub(bigint.unserialize(sum, 's'), 1, 10)); + +--[[Results: + +]] diff --git a/Problem14.lua b/Problem14.lua new file mode 100644 index 0000000..34e05ff --- /dev/null +++ b/Problem14.lua @@ -0,0 +1,83 @@ +--ProjectEuler/lua/Problem14.lua +--Matthew Ellison +-- Created: 02-07-19 +--Modified: 03-28-19 +--[[ +The following iterative sequence is defined for the set of positive integers: +n → n/2 (n is even) +n → 3n + 1 (n is odd) +Which starting number, under one million, produces the longest chain? +]] +--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 . +]] + + +require "Stopwatch" + + +timer = Stopwatch:create(); +timer:start(); + +TOP_NUM = 1000000 --The largest number that you will check against the chain + +--This function returns a table of numbers created by the chain +function getChain(startNum) + --Put the starting number in the list + local chain = {}; + chain[#chain+1] = startNum; + + --Starting with the current number perform the correct opperations on the numbers until that number reaches 1 + while(startNum > 1) do + --Determine if the number is odd or even and perform the correct operations and add the new number to the list + if((startNum % 2) == 0) then + startNum = startNum / 2; + else + startNum = (3 * startNum) + 1; + end + --Add the new number to the chain + chain[#chain+1] = startNum; + end + + --Return the list + return chain; +end + +--Setup your variables +local largestChain = {}; + +--Start at 1 and run up to TOP_NUM checking how long the chain is when started with each number +for startingNumber=1,TOP_NUM do + local currentChain = getChain(startingNumber); + --If the new chain is longer than the current longest chain replace it + if(#currentChain > #largestChain) then + for location=1,#currentChain do + largestChain[location] = currentChain[location]; + end + end +end + +timer:stop(); + +--Print the results +print("The longest chain with a starting number < " .. TOP_NUM .. " starts with " .. largestChain[1] .. " with a length of " .. #largestChain); +print("It took " .. timer:getSeconds() .. " seconds to run this algorithm") + +--[[Results: +The longest chain with a starting number < 1000000 starts with 837799 with a length of 525 +It took 13.704 seconds to run this algorithm +]] diff --git a/Problem15.lua b/Problem15.lua new file mode 100644 index 0000000..fd3e341 --- /dev/null +++ b/Problem15.lua @@ -0,0 +1,74 @@ +--ProjectEuler/lua/Problem15.lua +--Matthew Ellison +-- Created: 02-07-19 +--Modified: 03-28-19 +--How many routes from the top left corner to the bottom right corner are there through a 20×20 grid if you can only move right and down? +--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 . +]] + + +require "Stopwatch" + + +timer = Stopwatch:create(); +timer:start(); + +GRID_WIDTH = 20; +GRID_HEIGHT = 20; +lowestXReached = 20; +function movement(currentX, currentY) + --Return 1 if you are at the finish location + if((currentX == GRID_WIDTH) and (currentY == GRID_HEIGHT)) then + return 1; + end + + local numberMoves = 0; + --Otherwise move one right if you can and recurse + if(currentX < GRID_WIDTH) then + numberMoves = numberMoves + movement(currentX + 1, currentY); + end + + --Then move one down and recurse + if(currentY < GRID_HEIGHT) then + numberMoves = numberMoves + movement(currentX, currentY + 1); + end + ---Helps keep track of where it is for timing purposes + if(currentX < lowestXReached) then + lowestXReached = currentX; + print("X hit"); + print("NumberMoves = " .. numberMoves); + print("position = " .. currentX .. "; " .. currentY); + end + + return numberMoves; --Return the number of moves that have been found so far +end + +--Start the recursion at the correct location and catch what is returned +numberMoves = movement(0, 0); + +timer:stop(); + +--Print the results +print("The number of paths from 1 corner of a " .. GRID_WIDTH .. " x " .. GRID_HEIGHT .. " grid to the opposite corner is " .. numberMoves); +print("It took " .. timer:getMinutes() .. " seconds to run this algorithm"); + +--[[Results: +Did not run this program to completion. It ran for 12.5 hours and was over half way done, but I got tired of waiting. +It is coded the same way as the C++ version so should come up to the same answer. +There has got to be a better way to do this problem. +]] diff --git a/Problem16.lua b/Problem16.lua new file mode 100644 index 0000000..1729ab0 --- /dev/null +++ b/Problem16.lua @@ -0,0 +1,57 @@ +--ProjectEuler/lua/Problem16.lua +--Matthew Ellison +-- Created: 02-07-19 +--Modified: 03-28-19 +--What is the sum of the digits of the number 2^1000? +--All of my requires, unless otherwise listed, can be found at https://bitbucket.org/Mattrixwv/luaClasses +--I used the bigint library from https://github.com/empyreuma/bigint.lua +--[[ + 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 . +]] + + +require "Stopwatch" +local bigint = require("bigint") + + +local timer = Stopwatch:create(); +timer:start(); + +--Get the number +local num = bigint.exponentiate(bigint.new(2), bigint.new(1000)); + +--Change the number to the string +local stringOfNum = bigint.unserialize(num, 's'); + +--Step through the string one element at a time +local sumOfNum = 0; +for location=1,string.len(stringOfNum) do + --Treat the character like a num and add it to the sum + sumOfNum = sumOfNum + string.sub(stringOfNum, location, location); +end + +timer:stop(); + +--Print the results +print("2^1000 = " .. stringOfNum); +print("The sum of the digits is: " .. math.floor(sumOfNum)); +print("It took " .. timer:getMilliseconds() .. " milliseconds to run this algorithm"); + +--[[Results: +2^1000 = 10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831652624386837205668069376 +The sum of the digits is: 1366 +It took 352.0 milliseconds to run this algorithm +]] diff --git a/Problem17.lua b/Problem17.lua new file mode 100644 index 0000000..b940914 --- /dev/null +++ b/Problem17.lua @@ -0,0 +1,186 @@ +--ProjectEuler/lua/Problem17.lua +--Matthew Ellison +-- Created: 02-07-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? +--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 . +]] + + +require "Stopwatch" + + +timer = Stopwatch:create(); +timer:start(); + +--This function takes a number and returns it as a string in english +--This function only works for numbers -1,000,000 < num < 1,000,000 +function getStringFromNum(number) + local numberString = ""; + --Starting with the largest digit create a string based on the number passed in + --Check for negative + if(number < 0) then + numberString = numberString .. "negative "; + --Check if the number is zero + elseif(number == 0) then + numberString = numberString .. "zero"; + end + + --Start with the thousands place + if((number / 1000) >= 1) then + numberString = numberString .. getStringFromNum(math.floor(number / 1000)); + numberString = numberString .. " thousand"; + number = number - (math.floor(number / 1000) * 1000); + end + + --Check for hundreds place + if((number / 100) >= 1) then + numberString = numberString .. getStringFromNum(math.floor(number / 100)); + numberString = numberString .. " hundred"; + number = number - (math.floor(number / 100) * 100); + end + + --Insert an and if there is need + if((numberString ~= "") and (number > 0)) then + numberString = numberString .. " and "; + end + + --Check for tens place + if((number / 10) >= 2) then + --For the tens you need to do something special + local tensPlace = math.floor(number / 10); + if(tensPlace == 9) then + numberString = numberString .. "ninety"; + elseif(tensPlace == 8) then + numberString = numberString .. "eighty"; + elseif(tensPlace == 7) then + numberString = numberString .. "seventy"; + elseif(tensPlace == 6) then + numberString = numberString .. "sixty"; + elseif(tensPlace == 5) then + numberString = numberString .. "fifty"; + elseif(tensPlace == 4) then + numberString = numberString .. "forty"; + elseif(tensPlace == 3) then + numberString = numberString .. "thrity"; + elseif(tensPlace == 2) then + numberString = numberString .. "twenty"; + end + number = number - (tensPlace * 10); + --If there is something left in the number you will need a space to separate it + if(number > 0) then + numberString = numberString .. ' '; + end + --Check for teens + elseif((number / 10) >= 1) then + local onesPlace = (number % 10); + if(onesPlace == 9) then + numberString = numberString .. "nineteen"; + elseif(onesPlace == 8) then + numberString = numberString .. "eighteen"; + elseif(onesPlace == 7) then + numberString = numberString .. "seventeen"; + elseif(onesPlace == 6) then + numberString = numberString .. "sixteen"; + elseif(onesPlace == 5) then + numberString = numberString .. "fifteen"; + elseif(onesPlace == 4) then + numberString = numberString .. "fourteen"; + elseif(onesPlace == 3) then + numberString = numberString .. "thirteen"; + elseif(onesPlace == 2) then + numberString = numberString .. "twelve"; + elseif(onesPlace == 1) then + numberString = numberString .. "eleven"; + elseif(onesPlace == 0) then + numberString = numberString .. "ten"; + end + --If this if was hit number was used up + number = 0; + end + + --Check for ones place + if(number >= 1) then + if(number == 9) then + numberString = numberString .. "nine"; + elseif(number == 8) then + numberString = numberString .. "eight"; + elseif(number == 7) then + numberString = numberString .. "seven"; + elseif(number == 6) then + numberString = numberString .. "six"; + elseif(number == 5) then + numberString = numberString .. "five"; + elseif(number == 4) then + numberString = numberString .. "four"; + elseif(number == 3) then + numberString = numberString .. "three"; + elseif(number == 2) then + numberString = numberString .. "two"; + elseif(number == 1) then + numberString = numberString .. "one"; + end + --If this if was hit number was used up + number = 0; + end + + --Return the string + return numberString; +end + +--This function returns the number of letters in a string, ignoring punctuation, whitespace, and numbers +function getNumberChars(number) + local sumOfLetters = 0; + --Start at location 1 and count the number of letters, ignoring punctuation and whitespace + for location=1,string.len(number) do + local tempString = string.sub(number, location, location); + if(string.match(tempString, "%w")) then + sumOfLetters = sumOfLetters + 1; + end + end + + --Return the number of letters + return sumOfLetters; +end + + +timer = Stopwatch:create(); +timer:start(); + +START_NUM = 1; +STOP_NUM = 1000; + +local sumOfLetters = 0; +--Start with 1 and increment +for num=START_NUM,STOP_NUM do + --Pass the number to a function that will create a string for the number + local currentNumString = getStringFromNum(num); + --Pass the string to a function that will count the number of letters in a string, ignoring whitespace, punctuation, and numbers and add the amount tot he running tally + sumOfLetters = sumOfLetters + getNumberChars(currentNumString); +end + +timer:stop(); + +--Print the results +print("The sum of all the letters in all the numbers " .. START_NUM .. '-' .. STOP_NUM .. " is " .. sumOfLetters); +print("It took " .. timer:getMilliseconds() .. " milliseconds to run this algorithm"); + +--[[Results: +The sum of all the letters in all the numbers 1-1000 is 21124 +It took 4.0 milliseconds to run this algorithm +]] diff --git a/Problem18.lua b/Problem18.lua new file mode 100644 index 0000000..c5a90a6 --- /dev/null +++ b/Problem18.lua @@ -0,0 +1,227 @@ +--ProjectEuler/lua/Problem18.lua +--Matthew Ellison +-- Created: 03-12-19 +--Modified: 03-28-19 +--Find the maximum total from top to bottom +--[[ +75 +95 64 +17 47 82 +18 35 87 10 +20 04 82 47 65 +19 01 23 75 03 34 +88 02 77 73 07 63 67 +99 65 04 28 06 16 70 92 +41 41 26 56 83 40 80 70 33 +41 48 72 33 47 32 37 16 94 29 +53 71 44 65 25 43 91 52 97 51 14 +70 11 33 28 77 73 17 78 39 68 17 57 +91 71 52 38 17 14 91 43 58 50 27 29 48 +63 66 04 68 89 53 67 30 73 16 69 87 40 31 +04 62 98 27 23 09 70 98 73 93 38 53 60 04 23 +]] +--This is done using a breadth first search +--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 . +]] + + +require "Stopwatch" + +--[[ This is what locations should look like +location = { + xLocation = 0, + yLocation = 0, + total = 0, + fromRight = false +}; +]] + +function invert(list) + for rowCnt=1,NUM_ROWS do + for colCnt=1,#list[rowCnt] do + list[rowCnt][colCnt] = 100 - list[rowCnt][colCnt]; + end + end +end + +function foundInList(list, loc) + for location=1,#list do + if((list[location].xLocation == loc.xLocation) and (list[location].yLocation == loc.yLocation)) then + return true; + end + end + return false; +end + +function remove_if(list, loc) + location = 1; + while(location <= #list) do + if((list[location].xLocation == loc.xLocation) and (list[location].yLocation == loc.yLocation)) then + table.remove(list, location); + else + location = location + 1; + end + end +end + +--Create a timer and time the algorithm +timer = Stopwatch:create(); +timer:start(); + +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 all elements are 100 - element +invert(list); + +foundPoints = {}; --This is a table of locations +foundPoints[1] = {xLocation = 1, yLocation = 1, total = list[1][1], fromRight = false}; +possiblePoints = {}; --This is a table of locations +--Add the second row as possible points +possiblePoints[1] = {xLocation = 1, yLocation = 2, total = (list[1][1] + list[2][1]), fromRight = true}; +possiblePoints[2] = {xLocation = 2, yLocation = 2, total = (list[1][1] + list[2][2]), fromRight = false}; +foundBottom = false; --Used when you find a point at the bottom + +--Loop until you find the bottom +while(not foundBottom) do + --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,#possiblePoints do + if(possiblePoints[loc].total < minLoc.total) then + minLoc = possiblePoints[loc]; + end + end + + --Remove it from the list of possible points + remove_if(possiblePoints, minLoc); + + --[[ Aids in tracing the trail instead of using line after this + --Add that point to the list of found points + if(not foundInList(foundPoints, minLoc)) then + table.insert(foundPoints, minLoc); + end + ]] + table.insert(foundPoints, 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 to the next row + if(yLoc > NUM_ROWS) then + foundBottom = true; + else + --print("minLoc.total = " .. minLoc.total); + --print("list[" .. yLoc .. "][" .. xLoc .. "] = "); + table.insert(possiblePoints, {xLocation = xLoc, yLocation = yLoc, total = (minLoc.total + list[yLoc][xLoc]), fromRight = true}); + xLoc = xLoc + 1; --Advance the x location to simulate going right + table.insert(possiblePoints, {xLocation = xLoc, yLocation = yLoc, total = (minLoc.total + list[yLoc][xLoc]), fromRight = false}); + end +end + +actualTotal = ((100 * (NUM_ROWS)) - foundPoints[#foundPoints].total); + +--Stop the timer +timer:stop(); + +--Reinvert the list so it will print propperly +invert(list); + +--Print the results +print("The value of the longest path is " .. actualTotal); +print("It took " .. timer:getMilliseconds() .. " milliseconds to run this algorithm"); + +--[[ +--Print the pyramid of numbers out +for rowCnt=1,NUM_ROWS do + for colCnt=1,#list[rowCnt] do + if(list[rowCnt][colCnt] < 10) then + io.write(' ' .. list[rowCnt][colCnt] .. ' '); + else + io.write(list[rowCnt][colCnt] .. ' '); + end + end + print(""); +end +print("\n\n") + +--Find the trail followed +trail = {}; --Holds the locations that were traveled along +table.insert(trail, 1, foundPoints[#foundPoints]); --Start with the last point and continue adding to the front of the list +top = false; +while(not top) do + --Find the shortest way from the last location to the current one + found = false; + location = #foundPoints; + while(not found) do + --print("Location: " .. location); + --print("trail[1].xLocation = " .. trail[1].xLocation .. "\ntrail[1].yLocation = " .. trail[1].yLocation); + --print("foundPoints[location].xLocation = " .. foundPoints[location].xLocation .. "\nfoundPoints[location].yLocation = " .. foundPoints[location].yLocation); + if(trail[1].fromRight) then + if((foundPoints[location].xLocation == trail[1].xLocation) and (foundPoints[location].yLocation == (trail[1].yLocation - 1))) then + found = true; + else + location = location - 1; + end + else + if((foundPoints[location].xLocation == (trail[1].xLocation) - 1) and (foundPoints[location].yLocation == (trail[1].yLocation - 1))) then + found = true; + else + location = location - 1; + end + end + end + + --Insert the location into the trail + table.insert(trail, 1, foundPoints[location]); + + --If the current location is 1 then we are at the top + if(trail[1].yLocation == 1) then + top = true; + end +end + + +--Print the trail +for location=1,#trail do + io.write(list[trail[location].yLocation][trail[location].xLocation] .. "->"); +end +print(""); +]] + + +--[[ Results: +The value of the longest path is 1074 +It took 1.162 milliseconds to run this algorithm +]] diff --git a/Problem19.lua b/Problem19.lua new file mode 100644 index 0000000..a4c1bf7 --- /dev/null +++ b/Problem19.lua @@ -0,0 +1,186 @@ +--ProjectEuler/lua/Problem19.lua +--Matthew Ellison +-- Created: 03-13-19 +--Modified: 03-28-19 +--How many Sundays fell on the first of the month during the twentieth century (1 Jan 1901 to 31 Dec 2000)? +--[[ +You are given the following information, but you may prefer to do some research for yourself. +1 Jan 1900 was a Monday. +Thirty days has September, +April, June and November. +All the rest have thirty-one, +Saving February alone, +Which has twenty-eight, rain or shine. +And on leap years, twenty-nine. +A leap year occurs on any year evenly divisible by 4, but not on a century unless it is divisible by 400. +]] +--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 . +]] + + +require "Stopwatch" + + +DAYS = { + SUNDAY = 0, + MONDAY = 1, + TUESDAY = 2, + WEDNESDAY = 3, + THURSDAY = 4, + FRIDAY = 5, + SATURDAY = 6, + NUMBER_OF_DAYS = 7, + ERROR = 8; +} + +START_YEAR = 1901; +END_YEAR = 2000; + +--Return the day of the week that the date you pass into it is on +function getDay(month, day, year) + --Make sure the numbers are within propper bounds + if((month < 1) or (month > 12) or (day < 1) or (day > 31) or (year < 1)) then + return DAYS.ERROR; + 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) do + if(isLeapYear(currentYear)) then + numDays = numDays + 366; + else + numDays = numDays + 365; + end + currentYear = currentYear + 1; + end + --Add the correct number of days for every month + while(currentMonth < month) do + --February + if(currentMonth == 2) then + if(isLeapYear(currentYear)) then + numDays = numDays + 29; + else + numDays = numDays + 28; + end + --31 day months + elseif((currentMonth == 1) or (currentMonth == 3) or (currentMonth == 5) or (currentMonth == 7) or (currentMonth == 8) or (currentMonth == 10) or (currentMonth == 12)) then + 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) then + numDays = numDays - 11; + elseif(year == 1752) then + if(month > 9) then + numDays = numDays - 11; + elseif(month == 9) then + if(day >= 14) then + numDays = numDays - 11; + --Days 3-13 were skipped that year + elseif((day > 2) and (day < 14)) then + return DAYS.ERROR; + end + end + end + --Add the correct number of days for every day + numDays = numDays + day; + + currentDay = currentDay + numDays; + currentDay = currentDay % DAYS.NUMBER_OF_DAYS; + if(currentDay == DAYS.SUNDAY) then + day = DAYS.SUNDAY; + elseif(currentDay == DAYS.MONDAY) then + day = DAYS.MONDAY; + elseif(currentDay == DAYS.TUESDAY) then + day = DAYS.TUESDAY; + elseif(currentDay == DAYS.WEDNESDAY) then + day = DAYS.WEDNESDAY; + elseif(currentDay == DAYS.THURSDAY) then + day = DAYS.THURSDAY; + elseif(currentDay == DAYS.FRIDAY) then + day = DAYS.FRIDAY; + elseif(currentDay == DAYS.SATURDAY) then + day = DAYS.SATURDAY; + else + day = DAYS.ERROR; + end + --Return the day generated + return day; +end + +function isLeapYear(year) + if(year < 1) then + answer = false; + elseif((year % 100) == 0) then + --This rule only applies at and after 1800 + if(year <= 1700) then + answer = true; + elseif((year % 400) == 0) then + answer = true; + else + answer = false; + end + elseif((year % 4) == 0) then + answer = true; + else + answer = false; + end + return answer; +end + +--Setup the variables +timer = Stopwatch:create(); +totalSundays = 0; + +--Start the timer +timer:start(); + +--Run for all years up to 2000 +for year=START_YEAR,END_YEAR do + --Run for all months in the year + for month=1,12 do + day = getDay(month, 1, year); + if(day == DAYS.ERROR) then + io.output("There was an error with the day\n"); + os.exit(); + elseif(day == DAYS.SUNDAY) then + totalSundays = totalSundays + 1; + end + end +end + +--Stop the timer +timer:stop() + +--Print the results +io.write("There are " .. totalSundays .. " Sundays that landed on the first of the months from " .. START_YEAR .. " to " .. END_YEAR .. '\n'); +io.write("It took " .. timer:getMilliseconds() .. " milliseconds to run this algorithm\n"); + +--[[ Results: +There are 171 Sundays that landed on the first of the months from 1901 to 2000 +It took 390.0 milliseconds to run this algorithm +]] \ No newline at end of file diff --git a/Problem2.lua b/Problem2.lua new file mode 100644 index 0000000..93081bb --- /dev/null +++ b/Problem2.lua @@ -0,0 +1,59 @@ +--ProjectEuler/lua/Problem1.lua +--Matthew Ellison +-- Created: 02-01-19 +--Modified: 03-28-19 +--The sum of the even Fibonacci numbers less than 4,000,000 +--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 . +]] + + +require "Stopwatch" + + +timer = Stopwatch:create(); +timer:start(); + +--Setup the variables +TOP_NUM = 4000000; --The highest looked for Fibonacci numbers +fibSum = 0; --Holds the sum of the Fibonacci numbers +fibNums = {1, 1, 2}; --An array to keep track of the Fibonacci numbers + +--Loop to generate the Fibonacci numbers +cnt = 2; --A counter to hold the location in the array of the currently working Fibonacci number +fibNums[(cnt % 3) + 1] = fibNums[((cnt - 1) % 3) + 1] + fibNums[((cnt - 2) % 3) + 1]; +while(fibNums[(cnt % 3) + 1] < TOP_NUM) do + --If the number is even add it to the sum, otherwise ignore it + if((fibNums[(cnt % 3) + 1] % 2) == 0) then + fibSum = fibSum + fibNums[(cnt % 3) + 1]; + end + --Generate the next Fibonacci number in the sequence + cnt = cnt + 1 + fibNums[(cnt % 3) + 1] = fibNums[((cnt - 1) % 3) + 1] + fibNums[((cnt - 2) % 3) + 1]; +end + +timer:stop(); + +--Print the results +print("The sum of all even Fibonacci numbers less than " .. TOP_NUM .. " is " .. fibSum); +print("It took " .. timer:getMicroseconds() .. " microseconds to run this algorithm"); + + +--[[Results: +The sum of all even Fibonacci numbers less than 4000000 is 4613732 +It took 56 microseconds to run this algorithm +]] diff --git a/Problem20.lua b/Problem20.lua new file mode 100644 index 0000000..197e4dc --- /dev/null +++ b/Problem20.lua @@ -0,0 +1,62 @@ +--ProjectEuler/lua/Problem20.lua +--Matthew Ellison +-- Created: 03-14-19 +--Modified: 03-28-19 +--What is the sum of the digits of 100! +--All of my requires, unless otherwise listed, can be found at https://bitbucket.org/Mattrixwv/luaClasses +--I used the bigint library from https://github.com/empyreuma/bigint.lua +--[[ + 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 . +]] + + +require "Stopwatch" +local bigint = require("bigint") + +TOP_NUM = 100; + + +--Start the timer +timer = Stopwatch:create(); +timer:start(); + +local num = bigint.new(1); --The number to be generated +local sum = 0; --The sum of the digits in num + +for cnt = 1, TOP_NUM do + num = bigint.multiply(num, bigint.new(cnt)); +end + +--Get a string of the number because it is easier to pull appart the individual characters to get the sum +numString = bigint.unserialize(num, 's'); +--Run through every character in the string, convert it back to an integer and add it to the running sum +for cnt = 1, string.len(numString) do + sum = sum + tonumber(string.sub(numString, cnt, cnt)); +end + +--Stop the timer +timer:stop() + +--Print the results +io.write("100! = " .. numString .. '\n'); +io.write("The sum of the digits is: " .. sum .. '\n'); +io.write("It took " .. timer:getMilliseconds() .. " milliseconds to run this algorithm\n"); + +--[[ Results: +100! = 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000 +The sum of the digits is: 648 +It took 81.113 milliseconds to run this algorithm +]] diff --git a/Problem21.lua b/Problem21.lua new file mode 100644 index 0000000..98bef74 --- /dev/null +++ b/Problem21.lua @@ -0,0 +1,94 @@ +--ProjectEuler/lua/Problem21.lua +--Matthew Ellison +-- Created: 03-19-19 +--Modified: 03-28-19 +--Evaluate the sum of all the amicable numbers under 10000 +--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 . +]] + + +require "Stopwatch" +require "Algorithms" + +LIMIT = 10000; --The top number that will be evaluated + + +--Setup the timer +timer = Stopwatch:create(); + +--Setup the variables +divisorSum = {}; --Holds the sum of the factors of the subscript number + +--Start the timer +timer:start(); + +--Generate the factors of all the numbers < 10000, get their sum, and add it to the list +for cnt = 1, LIMIT do + divisors = getDivisors(cnt); --Get all the divisors of a number + if(#divisors > 1) then + table.remove(divisors); --Remove the last entry because it will be the number itself + end + divisorSum[#divisorSum + 1] = getSum(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, #divisorSum do + sum = 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(sum >= #divisorSum) then + --We know that divisorSum[cnt] == sum, do if divisorSum[sum] == cnt we have found an amicable number + elseif(divisorSum[sum] == cnt) then + --A number can't be amicable with itself, so skip those numbers + if(sum == cnt) then + --Add the number to the amicable vector + else + amicable[#amicable + 1] = cnt; + end + end +end + +--Stop the timer +timer:stop(); + +--Sort the vector for neatness +table.sort(amicable); + +--Print the results +io.write("All amicable numbers less than " .. LIMIT .. " are \n"); +--Print the list of amicable numbers +for location = 1, #amicable do + io.write(amicable[location] .. '\n'); +end +io.write("The sum of all of these amicable numbers is " .. getSum(amicable) .. '\n'); +io.write("It took " .. timer:getMilliseconds() .. " milliseconds to run this algorithm\n"); + +--[[ 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 46.0 milliseconds to run this algorithm +]] diff --git a/Problem22.lua b/Problem22.lua new file mode 100644 index 0000000..dc247b8 --- /dev/null +++ b/Problem22.lua @@ -0,0 +1,436 @@ +--ProjectEuler/lua/Problem22.lua +--Matthew Ellison +-- Created: 03-20-19 +--Modified: 03-28-19 +--What is the total of all the name scores in the file? +--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 . +]] + + +require("Stopwatch") +require("Algorithms") + + +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 +timer = Stopwatch:create(); +sums = {} --Holds the score based on the sum of the characters in the name +prod = {} --Holds the score based on the sum of the characters and the location in alphabetical order + +--Start the timer +timer:start(); + +--Sort all the names +table.sort(NAMES); + +--Step through every name adding up the values of the characters +for nameCnt = 1, #NAMES do + --Step through every character in the current name adding up the value + sums[nameCnt] = 0; + for charCnt = 1, string.len(NAMES[nameCnt]) do + --A = 65 so subtracting 64 means A - 1. This will only work correctly if all letters are capitalized + sums[nameCnt] = sums[nameCnt] + utf8.codepoint(string.sub(NAMES[nameCnt], charCnt, charCnt)) - 64; + end +end + +--Get the product for all numbers +for cnt = 1, #sums do + prod[cnt] = sums[cnt] * cnt; +end + +--Stop the timer +timer:stop(); + +--Print the results +io.write("The answer to the question is " .. getSum(prod) .. '\n'); +io.write("It tooks " .. timer:getMilliseconds() .. " milliseconds to run this algorithm\n"); + + +--[[ Results: +The answer to the question is 871198282 +It tooks 0.0 milliseconds to run this algorithm +]] diff --git a/Problem23.lua b/Problem23.lua new file mode 100644 index 0000000..5030b78 --- /dev/null +++ b/Problem23.lua @@ -0,0 +1,91 @@ +--ProjectEuler/lua/Problem23.lua +--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 +--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 . +]] + + +require "Stopwatch" +require "Algorithms" + + +MAX_NUM = 28123; --The highest number that will be evaluated + + +function isSum(abund, num) + local sumOfNums = 0; + --Pick a number for the first part of the sum + for firstNum = 1, #abund do + for secondNum = firstNum, #abund do + sumOfNums = abund[firstNum] + abund[secondNum]; + if(sumOfNums == num) then + return true; + elseif(sumOfNums > num) then + break; + end + end + end + return false; +end + + +--Setup the variables +local timer = Stopwatch:create(); +local divisorSums = {}; + +--Start the timer +timer:start(); + +--Get the sum of the divisors of all numbers < MAX_NUM +for cnt = 1, MAX_NUM do + local div = getDivisors(cnt); + if(#div > 1) then + table.remove(div, #div); + end + divisorSums[cnt] = getSum(div); +end + +--Get the abundant numbers +local abund = {}; +for cnt = 1, #divisorSums do + if(divisorSums[cnt] > cnt) then + abund[#abund + 1] = cnt; + end +end + +--Check if each number can be the sum of 2 abundant numbers and add to the sum if no +local sumOfNums = 0; +for cnt = 1, MAX_NUM do + if(not isSum(abund, cnt)) then + sumOfNums = sumOfNums + cnt; + end +end + +--Stop the timer +timer:stop(); + +--Print the results +io.write("The answer is " .. sumOfNums .. '\n'); +io.write("It took " .. timer:getSeconds() .. " seconds to run this algorithm\n"); + +--[[Results: +The answer is 4179871 +It took 393.139 seconds to run this algorithm +]] diff --git a/Problem24.lua b/Problem24.lua new file mode 100644 index 0000000..7a68020 --- /dev/null +++ b/Problem24.lua @@ -0,0 +1,51 @@ +--ProjectEuler/lua/Problem24.lua +--Matthew Ellison +-- Created: 03-24-19 +--Modified: 03-28-19 +--What is the millionth lexicographic permutation of the digits 0, 1, 2, 3, 4, 5, 6, 7, 8 and 9? +--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 . +]] + + +require "Stopwatch" +require "Algorithms" + +NEEDED_PERM = 1000000; --The number of the permutation that you need + + +--Setup the variables +timer = Stopwatch:create(); +nums = "0123456789"; + +--Start the timer +timer:start(); + +--Get all permutations of the string +permutations = getPermutations(nums); + +--Stop the timer +timer:stop(); + +--Print the results +io.write("The 1 millionth permutation is " .. permutations[NEEDED_PERM] .. '\n'); +io.write("It took " .. timer:getSeconds() .. " seconds to run this algorithm\n"); + +--[[ Results: +The 1 millionth permutation is 2783915460 +It took 50.175 seconds to run this algorithm +]] diff --git a/Problem25.lua b/Problem25.lua new file mode 100644 index 0000000..db52598 --- /dev/null +++ b/Problem25.lua @@ -0,0 +1,63 @@ +--ProjectEuler/lua/Problem25.lua +--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? +--All of my requires, unless otherwise listed, can be found at https://bitbucket.org/Mattrixwv/luaClasses +--I used the bigint library from https://github.com/empyreuma/bigint.lua +--[[ + 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 . +]] + + +require "Stopwatch"; +require "Algorithms"; +local bigint = require "bigint"; + + +NUM_DIGITS = 1000; --The number of digits to calculate up to + + +--Setup the variables +local timer = Stopwatch:create(); +local number = bigint.new(0); --The current Fibonacci number +local index = 2; --The index of the jest calculated Fibonacci number + +--Start the timer +timer:start(); + +--Move through all Fibonacci numbers until you reach the one with at least NUM_DIGITS digits +while(#bigint.unserialize(number, 's') < NUM_DIGITS) do + index = index + 1; --Increase the index number. Doing this at the beginning keeps the index correct at the end of the loop + print("index: " .. index); + --print("Size: " .. #bigint.unserialize(number, 's')); + --print("number: " .. bigint.unserialize(number, 's')); + number = getLargeFib(index); --Calculate the number +end + +--Stop the timer +timer:stop(); + +--Print the results +io.write("The first Fibonacci number with " .. NUM_DIGITS .. " digits is " .. bigint.unserialize(number, 's') .. '\n'); +io.write("The index is " .. index .. '\n'); +io.write("It took " .. timer:getMinutes() .. " minutes to run this algorithm\n"); + +--[[ Results: +The first Fibonacci number with 1000 digits is 1070066266382758936764980584457396885083683896632151665013235203375314520604694040621889147582489792657804694888177591957484336466672569959512996030461262748092482186144069433051234774442750273781753087579391666192149259186759553966422837148943113074699503439547001985432609723067290192870526447243726117715821825548491120525013201478612965931381792235559657452039506137551467837543229119602129934048260706175397706847068202895486902666185435124521900369480641357447470911707619766945691070098024393439617474103736912503231365532164773697023167755051595173518460579954919410967778373229665796581646513903488154256310184224190259846088000110186255550245493937113651657039447629584714548523425950428582425306083544435428212611008992863795048006894330309773217834864543113205765659868456288616808718693835297350643986297640660000723562917905207051164077614812491885830945940566688339109350944456576357666151619317753792891661581327159616877487983821820492520348473874384736771934512787029218636250627816 +The index is 4782 +It took 182.529 minutes to run this algorithm +]] diff --git a/Problem26.lua b/Problem26.lua new file mode 100644 index 0000000..04bafe3 --- /dev/null +++ b/Problem26.lua @@ -0,0 +1,86 @@ +--ProjectEuler/lua/Problem26.lua +--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. +--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 . +]] + + +require "Stopwatch" + +local TOP_NUMBER = 999 --The largest denominator to tbe checked + + +--Setup the variables +local timer = Stopwatch:create(); +local longestCycle = 0; +local longestNumber = 1; + +--Start the timer +timer:start(); + +--Start with 1/2 and find out how long the longest cycle is by checking the remainders +--Loop through every number from 2-999 and use it for the denominator +for denominator = 2, TOP_NUMBER do + local remainderList = {}; --Holds the list of remainders + local endFound = false; --Holds whether we have found an end to the number (either a cycle or a 0 for remainder) + local cycleFound = false; --Holds whether a cycle was detected + local numerator = 1; --The numerator that will be divided + while(not endFound) do + --Get the remainder after the division + local remainder = numerator % denominator + --Check if the remainder is 0 + --If it is, set the flag + if(remainder == 0) then + endFound = true; + --Check if the remainder is in the list + --If it is in the list, set the appropriate flags + elseif(remainderList[remainder]) then + endFound = true; + cycleFound = true; + --Else add it to the list + else + remainderList[remainder] = true; + 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) then + --If it is larger than the largest, set it as the new largest + if(#remainderList > longestCycle) then + longestCycle = #remainderList; + longestNumber = denominator; + end + end +end + +--End the timer +timer:stop(); + +--Print the results +io.write("The longest cycle is " .. longestCycle .. " digits long\n"); +io.write("It is started with the number " .. longestNumber .. '\n'); +io.write("It took " .. timer:getString() .. " to run this algorithm\n"); + +--[[ Results: +The longest cycle is 982 digits long +It is started with the number 983 +It took 28.222 milliseconds to run this algorithm +]] diff --git a/Problem27.lua b/Problem27.lua new file mode 100644 index 0000000..879c76e --- /dev/null +++ b/Problem27.lua @@ -0,0 +1,77 @@ +--ProjectEuler/lua/Problem27.lua +--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. +--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 . +]] + + +require "Stopwatch" +require "Algorithms" + + +--Setup the variables +local timer = Stopwatch:create(); +local topA = 0; --The A for the most n's generated +local topB = 0; --The B for the most n's generated +local topN = 0; --The most n's generated +local primes = getPrimes(12000) --A list of all primes that could possibly be generated with this formula + + +--Start the timer +timer:start(); + +--Start with the lowest possible A and check all possibilities after that +for a = -999, 999 do + --Start with the lowest possible B and check all possibilities after that + for b = -1000, 1000 do + --Start with n=0 and check the formula to see how many primes you can get get with concecutive n's + local n = 0; + local quadratic = (n * n) + (a * n) + b; + while(isFound(primes, quadratic)) do + n = n + 1; + quadratic = (n * n) + (a * n) + b; + end + n = n - 1; --Negate an n because the last formula failed + + --Set all the largest numbers if this created more primes than any other + if(n > topN) then + topN = n; + topB = b; + topA = a; + end + end +end + + +--Stop the timer +timer:stop(); + +--Print the results +io.write("The greatest number of primes found is " .. topN .. '\n'); +io.write("It was found with A = " .. topA .. ", B = " .. topB .. '\n'); +io.write("The product of A and B is " .. topA * topB .. '\n'); +io.write("It took " .. timer:getString() .. " to run this algorithm\n"); + +--[[ 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 119.350 seconds to run this algorithm +]] diff --git a/Problem28.lua b/Problem28.lua new file mode 100644 index 0000000..4b7fd4f --- /dev/null +++ b/Problem28.lua @@ -0,0 +1,114 @@ +--ProjectEuler/lua/Problem28.lua +--Matthew Ellison +-- Created: 09-15-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. +--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 . +]] + + +require "Stopwatch" + + +--Setup the variables +local timer = Stopwatch:create(); +local grid = {}; +local finalLocation = false; --A flag to indicate if the final location to be filled has been reached +local currentNum = 1; --Set the number that is going to be put at each location +--Make a 1001x1001 grid full of 0's +for row = 0, 1001 do + grid[row] = {}; + for col = 0, 1001 do + grid[row][col] = 0; + end +end + +--Start the timer +timer:start(); + +--Start with the middle location and set it correctly and advance the tracker to the next number +local xLocation = 500; +local yLocation = 500; +grid[yLocation][xLocation] = currentNum; +currentNum = currentNum + 1; +--Move right the first time +xLocation = xLocation + 1; +--Move in a circular pattern until you reach the final location +while(not finalLocation) do + --Move down until you reach a blank location on the left + while(grid[yLocation][xLocation - 1] ~= 0) do + grid[yLocation][xLocation] = currentNum; + currentNum = currentNum + 1; + yLocation = yLocation + 1; + end + --Move left until you reach a blank location above + while(grid[yLocation - 1][xLocation] ~= 0) do + grid[yLocation][xLocation] = currentNum; + currentNum = currentNum + 1; + xLocation = xLocation - 1; + end + + --Move up until you reach a blank location to the right + while(grid[yLocation][xLocation + 1] ~= 0) do + grid[yLocation][xLocation] = currentNum; + currentNum = currentNum + 1; + yLocation = yLocation - 1; + end + + --Move right until you reach a blank location below + while(grid[yLocation + 1][xLocation] ~= 0) do + grid[yLocation][xLocation] = currentNum; + currentNum = currentNum + 1; + xLocation = xLocation + 1; + --Check if you are at the final location and break the loop if you are + if(xLocation == #grid) then + finalLocation = true; + break; + end + end +end + +--Get the sum of the diagonals +local leftSide = 0; +local rightSide = #grid - 1; +local row = 0; +local sumOfDiag = 0; +while(row < #grid) do + --This ensures the middle location is only counted once + if(leftSide == rightSide) then + sumOfDiag = sumOfDiag + grid[row][leftSide]; + else + sumOfDiag = sumOfDiag + grid[row][leftSide]; + sumOfDiag = sumOfDiag + grid[row][rightSide]; + end + row = row + 1; + leftSide = leftSide + 1; + rightSide = rightSide - 1; +end + +--Stop the timer +timer:stop(); + +--Print the results +io.write("The sum of the diagonals in the given grid is " .. sumOfDiag .. '\n'); +io.write("It took " .. timer:getString() .. " to run this algorithm\n"); + +--[[ Results: +The sum of the diagonals in the given grid is 669171001 +It took 81.680 milliseconds to run this algorithm +]] diff --git a/Problem29.lua b/Problem29.lua new file mode 100644 index 0000000..d43ef41 --- /dev/null +++ b/Problem29.lua @@ -0,0 +1,64 @@ +--ProjectEuler/lua/Problem29.lua +-- Created: 10-10-19 +--Modified: 10-10-19 +--How many distinct terms are in the sequence generated by a^b for 2 <= a <= 100 and 2 <= b <= 100? +--All of my requires, unless otherwise listed, can be found at https://bitbucket.org/Mattrixwv/luaClasses +--I used the bigint library from https://github.com/empyreuma/bigint.lua +--[[ + 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 . +]] + + +require "Stopwatch" +require "Algorithms" +local bigint = require("bigint") + +--Setup the variables +local timer = Stopwatch:create(); +local BOTTOM_A = 2; --The lowest possible value for A +local TOP_A = 100; --The highest possible value for A +local BOTTOM_B = 2; --The lowest possible value for B +local TOP_B = 100; --The highest possible value for B +local unique = {}; --A table to hold all of the unique answers for the equation +local currentNum = bigint.new(); --Holds the answer to the equation for a particular loop + +--Start the timer +timer:start(); + +--Start with the lowest A and move towards the largest +for currentA = BOTTOM_A, TOP_A do + --Start with the lowest B and move towards the largest + for currentB = BOTTOM_B, TOP_B do + --Get the new number + currentNum = bigint.unserialize(bigint.exponentiate(bigint.new(currentA), bigint.new(currentB)), "s"); + --If the number isn't in the list add it + if(not isFound(unique, currentNum)) then + table.insert(unique, currentNum); + end + end +end + +--Stop the timer +timer:stop(); + +--Print the results +io.write("The number of unique values generated by a^b for " .. BOTTOM_A .. " <= a <= " .. TOP_A .. " and " .. BOTTOM_B .. " <= b <= " .. TOP_B .. " is " .. #unique .. '\n'); +io.write("It took " .. timer:getString() .. " to run this algorithm\n"); + +--[[ Results: +The number of unique values generated by a^b for 2 <= a <= 100 and 2 <= b <= 100 is 9183 +It took 2.714 minutes to run this algorithm +]] diff --git a/Problem3.lua b/Problem3.lua new file mode 100644 index 0000000..978eaa3 --- /dev/null +++ b/Problem3.lua @@ -0,0 +1,46 @@ +--ProjectEuler/lua/Problem3.lua +--Matthew Ellison +-- Created: 02-04-19 +--Modified: 03-28-19 +--The largest prime factor of 600851475143 +--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 . +]] + + +require "Stopwatch" +require "Algorithms" + + +timer = Stopwatch:create(); +timer:start(); + + +TARGET_NUMBER = 600851475143; +--Get the factors of the number +factors = getFactors(TARGET_NUMBER); +timer:stop(); + +--The largest number will be the answer +--Print the results +print("The largest prime factor of " .. TARGET_NUMBER .. " is " .. factors[#factors]); +print("It took " .. timer:getSeconds() .. " seconds to run this algorithm"); + +--[[Results: +The largest prime factor of 600851475143 is 6857 +It took 1.612 seconds to run this algorithm +]] diff --git a/Problem30.lua b/Problem30.lua new file mode 100644 index 0000000..a933b27 --- /dev/null +++ b/Problem30.lua @@ -0,0 +1,89 @@ +--ProjectEuler/lua/Problem29.lua +-- 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. +--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 . +]] + + +require "Stopwatch" + + +--Returns a table with the individual digits of the number passed to it +function getDigits(num) + local listOfDigits = {}; --This table holds the individual digits of num + --The easiest way to get the individual digits of a number is by converting it to a string + local digits = tostring(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, #digits do + table.insert(listOfDigits, tonumber(string.sub(digits, cnt, cnt))); + end + --Return the table of digits + return listOfDigits; +end + +--Gets the sum of a table of numbers +function getSumOfTable(ary) + local sum = 0; --Start the sum at 0 so you can add to it + --Add every number in the table to the sum + for cnt = 1, #ary do + sum = sum + ary[cnt]; + end + --Return the sum + return sum; +end + + +--Setup the variables +local timer = Stopwatch:create(); +local TOP_NUM = 1000000; --This is the largest number that will be checked +local BOTTOM_NUM = 2; --Starts with 2 because 0 and 1 don't count +local POWER_RAISED = 5; --This is the power that the digits are raised to +local sumOfFifthNumbers = {}; --This is a table of the numbers that are the sum of the fifth power of their digits + +--Start the timer +timer:start(); + +--Start with the lowest number and increment until you reach the largest number +for currentNum = BOTTOM_NUM, TOP_NUM do + --Get the digits of the number + local digits = getDigits(currentNum); + --Get the sum of the powers + local sumOfPowers = 0; + for cnt = 1, #digits do + sumOfPowers = sumOfPowers + math.pow(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) then + table.insert(sumOfFifthNumbers, currentNum); + end +end + +--Stop the timer +timer:stop(); + +--Print the results +io.write("The sum of all the numbers that can be written as the sum of the fifth powers of their digits is " .. getSumOfTable(sumOfFifthNumbers) .. '\n'); +io.write("It took " .. timer:getString() .. " to run this algorithm\n"); + + +--[[ 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 2.706 seconds to run this algorithm +]] diff --git a/Problem4.lua b/Problem4.lua new file mode 100644 index 0000000..b14e0df --- /dev/null +++ b/Problem4.lua @@ -0,0 +1,56 @@ +--ProjectEuler/lua/Problem4.lua +--Matthew Ellison +-- Created: 02-05-19 +--Modified: 03-28-19 +--Find the largest palindrome made from the product of two 3-digit numbers +--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 . +]] + + +require "Stopwatch" + + +timer = Stopwatch:create(); +timer:start(); + +palindromes = {}; --Holds all palindromes the program finds +--Loop through every number 100-999 twice, nested, so you can multiply every number by every other number in the array +for num1=100,999 do + for num2=num1,999 do + currentNum = num1 * num2; + --If the number is a palindrome add it to the list of palindromes, otherwise ignore it + --Using strings makes it easier to determine a palindrome + if(tostring(currentNum) == string.reverse(tostring(currentNum))) then + palindromes[#palindromes+1] = currentNum; + end + end +end + +--Sort the list for neatness +table.sort(palindromes); + +timer:stop(); + +--Print the results +print("The largest palindrome made from the product of two 3-digit numbers is " .. palindromes[#palindromes]); +print("It took " .. timer:getMilliseconds() .. " milliseconds to run this algorithm"); + +--[[Results: +The largest palindrome made from the product of two 3-digit numbers is 906609 +It took 268.412 milliseconds to run this algorithm +]] diff --git a/Problem5.lua b/Problem5.lua new file mode 100644 index 0000000..d419a37 --- /dev/null +++ b/Problem5.lua @@ -0,0 +1,66 @@ +--ProjectEuler/lua/Problem5.lua +--Matthew Ellison +-- Created: 02-05-19 +--Modified: 03-28-19 +--What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20? +--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 . +]] + + +require "Stopwatch" + + +timer = Stopwatch:create(); +timer:start(); + +--Setup the variables you need +numFound = false; +currentNum = 22; --Start looking at 22 becuase it must be divisible by 2 and greater than 20 +--Start a loop looking for the correct number +while((not numFound) and (currentNum > 0)) do + --Set that you found the number to true because you set this flag when you don't find it + numFound = true; + --See if the current number is divisible by all number from 1 to 20 + for divisor=1,20 do + --If it is not set a flag to move to the next possible number + if((currentNum % divisor) ~= 0) then + numFound = false; + break; + end + end + + --Increment the number by 2 to check the next one if you didn't find the number + if(not numFound) then + currentNum = currentNum + 2 + end +end + +timer:stop(); + +--Print the results +if(currentNum < 0) then + print("There was an error: Could not find a number that fit the criteria"); +else + print("The smallest positive number that is evenly divisible by all numbers 1-20 is " .. currentNum); + print("It took " .. timer:getSeconds() .. " seconds to run this algorithm") +end + +--[[Results: +The smallest positive number that is evenly divisible by all numbers 1-20 is 232792560 +It took 24.788324 seconds to run this algorithm +]] diff --git a/Problem6.lua b/Problem6.lua new file mode 100644 index 0000000..a4697c1 --- /dev/null +++ b/Problem6.lua @@ -0,0 +1,51 @@ +--ProjectEuler/lua/Problem6.lua +--Matthew Ellison +-- Created: 02-06-19 +--Modified: 03-28-19 +--Find the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum +--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 . +]] + + +require "Stopwatch" + + +timer = Stopwatch:create(); +timer:start(); + +--Create the variables you need +sumOfSquares = 0; +squareOfSum = 0; +--Loop through all numbers 1-100 to do the appropriate math with them +for num=1,100 do + sumOfSquares = sumOfSquares + num^2; --Get the sum of the squares of the first 100 natural number + squareOfSum = squareOfSum + num; --Get the sum of the first 100 natural numbers +end +--Square the normal sum +squareOfSum = squareOfSum^2; + +timer:stop(); + +--Print the result +print("The difference between the sum of the squares and the square of the sum of the numbers 1-100 is " .. math.floor(math.abs(sumOfSquares - squareOfSum))); +print("It took " .. timer:getMicroseconds() .. " microseconds to run this algorithm"); + +--[[Results: +The difference between the sum of the squares and the square of the sum of the numbers 1-100 is 25164150 +It took 53 microseconds to run this algorithm +]] diff --git a/Problem67.lua b/Problem67.lua new file mode 100644 index 0000000..66a2edd --- /dev/null +++ b/Problem67.lua @@ -0,0 +1,331 @@ +--ProjectEuler/lua/Problem67.lua +--Matthew Ellison +-- Created: 03-26-19 +--Modified: 03-28-19 +--Find the maximum total from top to bottom +--[[ +59 +73 41 +52 40 09 +26 53 06 34 +10 51 87 86 81 +61 95 66 57 25 68 +90 81 80 38 92 67 73 +30 28 51 76 81 18 75 44 +84 14 95 87 62 81 17 78 58 +21 46 71 58 02 79 62 39 31 09 +56 34 35 53 78 31 81 18 90 93 15 +78 53 04 21 84 93 32 13 97 11 37 51 +45 03 81 79 05 18 78 86 13 30 63 99 95 +39 87 96 28 03 38 42 17 82 87 58 07 22 57 +06 17 51 17 07 93 09 07 75 97 95 78 87 08 53 +67 66 59 60 88 99 94 65 55 77 55 34 27 53 78 28 +76 40 41 04 87 16 09 42 75 69 23 97 30 60 10 79 87 +12 10 44 26 21 36 32 84 98 60 13 12 36 16 63 31 91 35 +70 39 06 05 55 27 38 48 28 22 34 35 62 62 15 14 94 89 86 +66 56 68 84 96 21 34 34 34 81 62 40 65 54 62 05 98 03 02 60 +38 89 46 37 99 54 34 53 36 14 70 26 02 90 45 13 31 61 83 73 47 +36 10 63 96 60 49 41 05 37 42 14 58 84 93 96 17 09 43 05 43 06 59 +66 57 87 57 61 28 37 51 84 73 79 15 39 95 88 87 43 39 11 86 77 74 18 +54 42 05 79 30 49 99 73 46 37 50 02 45 09 54 52 27 95 27 65 19 45 26 45 +71 39 17 78 76 29 52 90 18 99 78 19 35 62 71 19 23 65 93 85 49 33 75 09 02 +33 24 47 61 60 55 32 88 57 55 91 54 46 57 07 77 98 52 80 99 24 25 46 78 79 05 +92 09 13 55 10 67 26 78 76 82 63 49 51 31 24 68 05 57 07 54 69 21 67 43 17 63 12 +24 59 06 08 98 74 66 26 61 60 13 03 09 09 24 30 71 08 88 70 72 70 29 90 11 82 41 34 +66 82 67 04 36 60 92 77 91 85 62 49 59 61 30 90 29 94 26 41 89 04 53 22 83 41 09 74 90 +48 28 26 37 28 52 77 26 51 32 18 98 79 36 62 13 17 08 19 54 89 29 73 68 42 14 08 16 70 37 +37 60 69 70 72 71 09 59 13 60 38 13 57 36 09 30 43 89 30 39 15 02 44 73 05 73 26 63 56 86 12 +55 55 85 50 62 99 84 77 28 85 03 21 27 22 19 26 82 69 54 04 13 07 85 14 01 15 70 59 89 95 10 19 +04 09 31 92 91 38 92 86 98 75 21 05 64 42 62 84 36 20 73 42 21 23 22 51 51 79 25 45 85 53 03 43 22 +75 63 02 49 14 12 89 14 60 78 92 16 44 82 38 30 72 11 46 52 90 27 08 65 78 03 85 41 57 79 39 52 33 48 +78 27 56 56 39 13 19 43 86 72 58 95 39 07 04 34 21 98 39 15 39 84 89 69 84 46 37 57 59 35 59 50 26 15 93 +42 89 36 27 78 91 24 11 17 41 05 94 07 69 51 96 03 96 47 90 90 45 91 20 50 56 10 32 36 49 04 53 85 92 25 65 +52 09 61 30 61 97 66 21 96 92 98 90 06 34 96 60 32 69 68 33 75 84 18 31 71 50 84 63 03 03 19 11 28 42 75 45 45 +61 31 61 68 96 34 49 39 05 71 76 59 62 67 06 47 96 99 34 21 32 47 52 07 71 60 42 72 94 56 82 83 84 40 94 87 82 46 +01 20 60 14 17 38 26 78 66 81 45 95 18 51 98 81 48 16 53 88 37 52 69 95 72 93 22 34 98 20 54 27 73 61 56 63 60 34 63 +93 42 94 83 47 61 27 51 79 79 45 01 44 73 31 70 83 42 88 25 53 51 30 15 65 94 80 44 61 84 12 77 02 62 02 65 94 42 14 94 +32 73 09 67 68 29 74 98 10 19 85 48 38 31 85 67 53 93 93 77 47 67 39 72 94 53 18 43 77 40 78 32 29 59 24 06 02 83 50 60 66 +32 01 44 30 16 51 15 81 98 15 10 62 86 79 50 62 45 60 70 38 31 85 65 61 64 06 69 84 14 22 56 43 09 48 66 69 83 91 60 40 36 61 +92 48 22 99 15 95 64 43 01 16 94 02 99 19 17 69 11 58 97 56 89 31 77 45 67 96 12 73 08 20 36 47 81 44 50 64 68 85 40 81 85 52 09 +91 35 92 45 32 84 62 15 19 64 21 66 06 01 52 80 62 59 12 25 88 28 91 50 40 16 22 99 92 79 87 51 21 77 74 77 07 42 38 42 74 83 02 05 +46 19 77 66 24 18 05 32 02 84 31 99 92 58 96 72 91 36 62 99 55 29 53 42 12 37 26 58 89 50 66 19 82 75 12 48 24 87 91 85 02 07 03 76 86 +99 98 84 93 07 17 33 61 92 20 66 60 24 66 40 30 67 05 37 29 24 96 03 27 70 62 13 04 45 47 59 88 43 20 66 15 46 92 30 04 71 66 78 70 53 99 +67 60 38 06 88 04 17 72 10 99 71 07 42 25 54 05 26 64 91 50 45 71 06 30 67 48 69 82 08 56 80 67 18 46 66 63 01 20 08 80 47 07 91 16 03 79 87 +18 54 78 49 80 48 77 40 68 23 60 88 58 80 33 57 11 69 55 53 64 02 94 49 60 92 16 35 81 21 82 96 25 24 96 18 02 05 49 03 50 77 06 32 84 27 18 38 +68 01 50 04 03 21 42 94 53 24 89 05 92 26 52 36 68 11 85 01 04 42 02 45 15 06 50 04 53 73 25 74 81 88 98 21 67 84 79 97 99 20 95 04 40 46 02 58 87 +94 10 02 78 88 52 21 03 88 60 06 53 49 71 20 91 12 65 07 49 21 22 11 41 58 99 36 16 09 48 17 24 52 36 23 15 72 16 84 56 02 99 43 76 81 71 29 39 49 17 +64 39 59 84 86 16 17 66 03 09 43 06 64 18 63 29 68 06 23 07 87 14 26 35 17 12 98 41 53 64 78 18 98 27 28 84 80 67 75 62 10 11 76 90 54 10 05 54 41 39 66 +43 83 18 37 32 31 52 29 95 47 08 76 35 11 04 53 35 43 34 10 52 57 12 36 20 39 40 55 78 44 07 31 38 26 08 15 56 88 86 01 52 62 10 24 32 05 60 65 53 28 57 99 +03 50 03 52 07 73 49 92 66 80 01 46 08 67 25 36 73 93 07 42 25 53 13 96 76 83 87 90 54 89 78 22 78 91 73 51 69 09 79 94 83 53 09 40 69 62 10 79 49 47 03 81 30 +71 54 73 33 51 76 59 54 79 37 56 45 84 17 62 21 98 69 41 95 65 24 39 37 62 03 24 48 54 64 46 82 71 78 33 67 09 16 96 68 52 74 79 68 32 21 13 78 96 60 09 69 20 36 +73 26 21 44 46 38 17 83 65 98 07 23 52 46 61 97 33 13 60 31 70 15 36 77 31 58 56 93 75 68 21 36 69 53 90 75 25 82 39 50 65 94 29 30 11 33 11 13 96 02 56 47 07 49 02 +76 46 73 30 10 20 60 70 14 56 34 26 37 39 48 24 55 76 84 91 39 86 95 61 50 14 53 93 64 67 37 31 10 84 42 70 48 20 10 72 60 61 84 79 69 65 99 73 89 25 85 48 92 56 97 16 +03 14 80 27 22 30 44 27 67 75 79 32 51 54 81 29 65 14 19 04 13 82 04 91 43 40 12 52 29 99 07 76 60 25 01 07 61 71 37 92 40 47 99 66 57 01 43 44 22 40 53 53 09 69 26 81 07 +49 80 56 90 93 87 47 13 75 28 87 23 72 79 32 18 27 20 28 10 37 59 21 18 70 04 79 96 03 31 45 71 81 06 14 18 17 05 31 50 92 79 23 47 09 39 47 91 43 54 69 47 42 95 62 46 32 85 +37 18 62 85 87 28 64 05 77 51 47 26 30 65 05 70 65 75 59 80 42 52 25 20 44 10 92 17 71 95 52 14 77 13 24 55 11 65 26 91 01 30 63 15 49 48 41 17 67 47 03 68 20 90 98 32 04 40 68 +90 51 58 60 06 55 23 68 05 19 76 94 82 36 96 43 38 90 87 28 33 83 05 17 70 83 96 93 06 04 78 47 80 06 23 84 75 23 87 72 99 14 50 98 92 38 90 64 61 58 76 94 36 66 87 80 51 35 61 38 +57 95 64 06 53 36 82 51 40 33 47 14 07 98 78 65 39 58 53 06 50 53 04 69 40 68 36 69 75 78 75 60 03 32 39 24 74 47 26 90 13 40 44 71 90 76 51 24 36 50 25 45 70 80 61 80 61 43 90 64 11 +18 29 86 56 68 42 79 10 42 44 30 12 96 18 23 18 52 59 02 99 67 46 60 86 43 38 55 17 44 93 42 21 55 14 47 34 55 16 49 24 23 29 96 51 55 10 46 53 27 92 27 46 63 57 30 65 43 27 21 20 24 83 +81 72 93 19 69 52 48 01 13 83 92 69 20 48 69 59 20 62 05 42 28 89 90 99 32 72 84 17 08 87 36 03 60 31 36 36 81 26 97 36 48 54 56 56 27 16 91 08 23 11 87 99 33 47 02 14 44 73 70 99 43 35 33 +90 56 61 86 56 12 70 59 63 32 01 15 81 47 71 76 95 32 65 80 54 70 34 51 40 45 33 04 64 55 78 68 88 47 31 47 68 87 03 84 23 44 89 72 35 08 31 76 63 26 90 85 96 67 65 91 19 14 17 86 04 71 32 95 +37 13 04 22 64 37 37 28 56 62 86 33 07 37 10 44 52 82 52 06 19 52 57 75 90 26 91 24 06 21 14 67 76 30 46 14 35 89 89 41 03 64 56 97 87 63 22 34 03 79 17 45 11 53 25 56 96 61 23 18 63 31 37 37 47 +77 23 26 70 72 76 77 04 28 64 71 69 14 85 96 54 95 48 06 62 99 83 86 77 97 75 71 66 30 19 57 90 33 01 60 61 14 12 90 99 32 77 56 41 18 14 87 49 10 14 90 64 18 50 21 74 14 16 88 05 45 73 82 47 74 44 +22 97 41 13 34 31 54 61 56 94 03 24 59 27 98 77 04 09 37 40 12 26 87 09 71 70 07 18 64 57 80 21 12 71 83 94 60 39 73 79 73 19 97 32 64 29 41 07 48 84 85 67 12 74 95 20 24 52 41 67 56 61 29 93 35 72 69 +72 23 63 66 01 11 07 30 52 56 95 16 65 26 83 90 50 74 60 18 16 48 43 77 37 11 99 98 30 94 91 26 62 73 45 12 87 73 47 27 01 88 66 99 21 41 95 80 02 53 23 32 61 48 32 43 43 83 14 66 95 91 19 81 80 67 25 88 +08 62 32 18 92 14 83 71 37 96 11 83 39 99 05 16 23 27 10 67 02 25 44 11 55 31 46 64 41 56 44 74 26 81 51 31 45 85 87 09 81 95 22 28 76 69 46 48 64 87 67 76 27 89 31 11 74 16 62 03 60 94 42 47 09 34 94 93 72 +56 18 90 18 42 17 42 32 14 86 06 53 33 95 99 35 29 15 44 20 49 59 25 54 34 59 84 21 23 54 35 90 78 16 93 13 37 88 54 19 86 67 68 55 66 84 65 42 98 37 87 56 33 28 58 38 28 38 66 27 52 21 81 15 08 22 97 32 85 27 +91 53 40 28 13 34 91 25 01 63 50 37 22 49 71 58 32 28 30 18 68 94 23 83 63 62 94 76 80 41 90 22 82 52 29 12 18 56 10 08 35 14 37 57 23 65 67 40 72 39 93 39 70 89 40 34 07 46 94 22 20 05 53 64 56 30 05 56 61 88 27 +23 95 11 12 37 69 68 24 66 10 87 70 43 50 75 07 62 41 83 58 95 93 89 79 45 39 02 22 05 22 95 43 62 11 68 29 17 40 26 44 25 71 87 16 70 85 19 25 59 94 90 41 41 80 61 70 55 60 84 33 95 76 42 63 15 09 03 40 38 12 03 32 +09 84 56 80 61 55 85 97 16 94 82 94 98 57 84 30 84 48 93 90 71 05 95 90 73 17 30 98 40 64 65 89 07 79 09 19 56 36 42 30 23 69 73 72 07 05 27 61 24 31 43 48 71 84 21 28 26 65 65 59 65 74 77 20 10 81 61 84 95 08 52 23 70 +47 81 28 09 98 51 67 64 35 51 59 36 92 82 77 65 80 24 72 53 22 07 27 10 21 28 30 22 48 82 80 48 56 20 14 43 18 25 50 95 90 31 77 08 09 48 44 80 90 22 93 45 82 17 13 96 25 26 08 73 34 99 06 49 24 06 83 51 40 14 15 10 25 01 +54 25 10 81 30 64 24 74 75 80 36 75 82 60 22 69 72 91 45 67 03 62 79 54 89 74 44 83 64 96 66 73 44 30 74 50 37 05 09 97 70 01 60 46 37 91 39 75 75 18 58 52 72 78 51 81 86 52 08 97 01 46 43 66 98 62 81 18 70 93 73 08 32 46 34 +96 80 82 07 59 71 92 53 19 20 88 66 03 26 26 10 24 27 50 82 94 73 63 08 51 33 22 45 19 13 58 33 90 15 22 50 36 13 55 06 35 47 82 52 33 61 36 27 28 46 98 14 73 20 73 32 16 26 80 53 47 66 76 38 94 45 02 01 22 52 47 96 64 58 52 39 +88 46 23 39 74 63 81 64 20 90 33 33 76 55 58 26 10 46 42 26 74 74 12 83 32 43 09 02 73 55 86 54 85 34 28 23 29 79 91 62 47 41 82 87 99 22 48 90 20 05 96 75 95 04 43 28 81 39 81 01 28 42 78 25 39 77 90 57 58 98 17 36 73 22 63 74 51 +29 39 74 94 95 78 64 24 38 86 63 87 93 06 70 92 22 16 80 64 29 52 20 27 23 50 14 13 87 15 72 96 81 22 08 49 72 30 70 24 79 31 16 64 59 21 89 34 96 91 48 76 43 53 88 01 57 80 23 81 90 79 58 01 80 87 17 99 86 90 72 63 32 69 14 28 88 69 +37 17 71 95 56 93 71 35 43 45 04 98 92 94 84 96 11 30 31 27 31 60 92 03 48 05 98 91 86 94 35 90 90 08 48 19 33 28 68 37 59 26 65 96 50 68 22 07 09 49 34 31 77 49 43 06 75 17 81 87 61 79 52 26 27 72 29 50 07 98 86 01 17 10 46 64 24 18 56 +51 30 25 94 88 85 79 91 40 33 63 84 49 67 98 92 15 26 75 19 82 05 18 78 65 93 61 48 91 43 59 41 70 51 22 15 92 81 67 91 46 98 11 11 65 31 66 10 98 65 83 21 05 56 05 98 73 67 46 74 69 34 08 30 05 52 07 98 32 95 30 94 65 50 24 63 28 81 99 57 +19 23 61 36 09 89 71 98 65 17 30 29 89 26 79 74 94 11 44 48 97 54 81 55 39 66 69 45 28 47 13 86 15 76 74 70 84 32 36 33 79 20 78 14 41 47 89 28 81 05 99 66 81 86 38 26 06 25 13 60 54 55 23 53 27 05 89 25 23 11 13 54 59 54 56 34 16 24 53 44 06 +13 40 57 72 21 15 60 08 04 19 11 98 34 45 09 97 86 71 03 15 56 19 15 44 97 31 90 04 87 87 76 08 12 30 24 62 84 28 12 85 82 53 99 52 13 94 06 65 97 86 09 50 94 68 69 74 30 67 87 94 63 07 78 27 80 36 69 41 06 92 32 78 37 82 30 05 18 87 99 72 19 99 +44 20 55 77 69 91 27 31 28 81 80 27 02 07 97 23 95 98 12 25 75 29 47 71 07 47 78 39 41 59 27 76 13 15 66 61 68 35 69 86 16 53 67 63 99 85 41 56 08 28 33 40 94 76 90 85 31 70 24 65 84 65 99 82 19 25 54 37 21 46 33 02 52 99 51 33 26 04 87 02 08 18 96 +54 42 61 45 91 06 64 79 80 82 32 16 83 63 42 49 19 78 65 97 40 42 14 61 49 34 04 18 25 98 59 30 82 72 26 88 54 36 21 75 03 88 99 53 46 51 55 78 22 94 34 40 68 87 84 25 30 76 25 08 92 84 42 61 40 38 09 99 40 23 29 39 46 55 10 90 35 84 56 70 63 23 91 39 +52 92 03 71 89 07 09 37 68 66 58 20 44 92 51 56 13 71 79 99 26 37 02 06 16 67 36 52 58 16 79 73 56 60 59 27 44 77 94 82 20 50 98 33 09 87 94 37 40 83 64 83 58 85 17 76 53 02 83 52 22 27 39 20 48 92 45 21 09 42 24 23 12 37 52 28 50 78 79 20 86 62 73 20 59 +54 96 80 15 91 90 99 70 10 09 58 90 93 50 81 99 54 38 36 10 30 11 35 84 16 45 82 18 11 97 36 43 96 79 97 65 40 48 23 19 17 31 64 52 65 65 37 32 65 76 99 79 34 65 79 27 55 33 03 01 33 27 61 28 66 08 04 70 49 46 48 83 01 45 19 96 13 81 14 21 31 79 93 85 50 05 +92 92 48 84 59 98 31 53 23 27 15 22 79 95 24 76 05 79 16 93 97 89 38 89 42 83 02 88 94 95 82 21 01 97 48 39 31 78 09 65 50 56 97 61 01 07 65 27 21 23 14 15 80 97 44 78 49 35 33 45 81 74 34 05 31 57 09 38 94 07 69 54 69 32 65 68 46 68 78 90 24 28 49 51 45 86 35 +41 63 89 76 87 31 86 09 46 14 87 82 22 29 47 16 13 10 70 72 82 95 48 64 58 43 13 75 42 69 21 12 67 13 64 85 58 23 98 09 37 76 05 22 31 12 66 50 29 99 86 72 45 25 10 28 19 06 90 43 29 31 67 79 46 25 74 14 97 35 76 37 65 46 23 82 06 22 30 76 93 66 94 17 96 13 20 72 +63 40 78 08 52 09 90 41 70 28 36 14 46 44 85 96 24 52 58 15 87 37 05 98 99 39 13 61 76 38 44 99 83 74 90 22 53 80 56 98 30 51 63 39 44 30 91 91 04 22 27 73 17 35 53 18 35 45 54 56 27 78 48 13 69 36 44 38 71 25 30 56 15 22 73 43 32 69 59 25 93 83 45 11 34 94 44 39 92 +12 36 56 88 13 96 16 12 55 54 11 47 19 78 17 17 68 81 77 51 42 55 99 85 66 27 81 79 93 42 65 61 69 74 14 01 18 56 12 01 58 37 91 22 42 66 83 25 19 04 96 41 25 45 18 69 96 88 36 93 10 12 98 32 44 83 83 04 72 91 04 27 73 07 34 37 71 60 59 31 01 54 54 44 96 93 83 36 04 45 +30 18 22 20 42 96 65 79 17 41 55 69 94 81 29 80 91 31 85 25 47 26 43 49 02 99 34 67 99 76 16 14 15 93 08 32 99 44 61 77 67 50 43 55 87 55 53 72 17 46 62 25 50 99 73 05 93 48 17 31 70 80 59 09 44 59 45 13 74 66 58 94 87 73 16 14 85 38 74 99 64 23 79 28 71 42 20 37 82 31 23 +51 96 39 65 46 71 56 13 29 68 53 86 45 33 51 49 12 91 21 21 76 85 02 17 98 15 46 12 60 21 88 30 92 83 44 59 42 50 27 88 46 86 94 73 45 54 23 24 14 10 94 21 20 34 23 51 04 83 99 75 90 63 60 16 22 33 83 70 11 32 10 50 29 30 83 46 11 05 31 17 86 42 49 01 44 63 28 60 07 78 95 40 +44 61 89 59 04 49 51 27 69 71 46 76 44 04 09 34 56 39 15 06 94 91 75 90 65 27 56 23 74 06 23 33 36 69 14 39 05 34 35 57 33 22 76 46 56 10 61 65 98 09 16 69 04 62 65 18 99 76 49 18 72 66 73 83 82 40 76 31 89 91 27 88 17 35 41 35 32 51 32 67 52 68 74 85 80 57 07 11 62 66 47 22 67 +65 37 19 97 26 17 16 24 24 17 50 37 64 82 24 36 32 11 68 34 69 31 32 89 79 93 96 68 49 90 14 23 04 04 67 99 81 74 70 74 36 96 68 09 64 39 88 35 54 89 96 58 66 27 88 97 32 14 06 35 78 20 71 06 85 66 57 02 58 91 72 05 29 56 73 48 86 52 09 93 22 57 79 42 12 01 31 68 17 59 63 76 07 77 +73 81 14 13 17 20 11 09 01 83 08 85 91 70 84 63 62 77 37 07 47 01 59 95 39 69 39 21 99 09 87 02 97 16 92 36 74 71 90 66 33 73 73 75 52 91 11 12 26 53 05 26 26 48 61 50 90 65 01 87 42 47 74 35 22 73 24 26 56 70 52 05 48 41 31 18 83 27 21 39 80 85 26 08 44 02 71 07 63 22 05 52 19 08 20 +17 25 21 11 72 93 33 49 64 23 53 82 03 13 91 65 85 02 40 05 42 31 77 42 05 36 06 54 04 58 07 76 87 83 25 57 66 12 74 33 85 37 74 32 20 69 03 97 91 68 82 44 19 14 89 28 85 85 80 53 34 87 58 98 88 78 48 65 98 40 11 57 10 67 70 81 60 79 74 72 97 59 79 47 30 20 54 80 89 91 14 05 33 36 79 39 +60 85 59 39 60 07 57 76 77 92 06 35 15 72 23 41 45 52 95 18 64 79 86 53 56 31 69 11 91 31 84 50 44 82 22 81 41 40 30 42 30 91 48 94 74 76 64 58 74 25 96 57 14 19 03 99 28 83 15 75 99 01 89 85 79 50 03 95 32 67 44 08 07 41 62 64 29 20 14 76 26 55 48 71 69 66 19 72 44 25 14 01 48 74 12 98 07 +64 66 84 24 18 16 27 48 20 14 47 69 30 86 48 40 23 16 61 21 51 50 26 47 35 33 91 28 78 64 43 68 04 79 51 08 19 60 52 95 06 68 46 86 35 97 27 58 04 65 30 58 99 12 12 75 91 39 50 31 42 64 70 04 46 07 98 73 98 93 37 89 77 91 64 71 64 65 66 21 78 62 81 74 42 20 83 70 73 95 78 45 92 27 34 53 71 15 +30 11 85 31 34 71 13 48 05 14 44 03 19 67 23 73 19 57 06 90 94 72 57 69 81 62 59 68 88 57 55 69 49 13 07 87 97 80 89 05 71 05 05 26 38 40 16 62 45 99 18 38 98 24 21 26 62 74 69 04 85 57 77 35 58 67 91 79 79 57 86 28 66 34 72 51 76 78 36 95 63 90 08 78 47 63 45 31 22 70 52 48 79 94 15 77 61 67 68 +23 33 44 81 80 92 93 75 94 88 23 61 39 76 22 03 28 94 32 06 49 65 41 34 18 23 08 47 62 60 03 63 33 13 80 52 31 54 73 43 70 26 16 69 57 87 83 31 03 93 70 81 47 95 77 44 29 68 39 51 56 59 63 07 25 70 07 77 43 53 64 03 94 42 95 39 18 01 66 21 16 97 20 50 90 16 70 10 95 69 29 06 25 61 41 26 15 59 63 35 +]] +--This is done using a breadth first search +--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 . +]] + + +require "Stopwatch" + +--[[ This is what locations should look like +location = { + xLocation = 0, + yLocation = 0, + total = 0, + fromRight = false +}; +]] + +function invert(list) + for rowCnt=1,NUM_ROWS do + for colCnt=1,#list[rowCnt] do + list[rowCnt][colCnt] = 100 - list[rowCnt][colCnt]; + end + end +end + +function foundInList(list, loc) + for location=1,#list do + if((list[location].xLocation == loc.xLocation) and (list[location].yLocation == loc.yLocation)) then + return true; + end + end + return false; +end + +function remove_if(list, loc) + location = 1; + while(location <= #list) do + if((list[location].xLocation == loc.xLocation) and (list[location].yLocation == loc.yLocation)) then + table.remove(list, location); + else + location = location + 1; + end + end +end + +--Create a timer and time the algorithm +timer = Stopwatch:create(); +timer:start(); + +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 all elements are 100 - element +invert(list); + +foundPoints = {}; --This is a table of locations +foundPoints[1] = {xLocation = 1, yLocation = 1, total = list[1][1], fromRight = false}; +possiblePoints = {}; --This is a table of locations +--Add the second row as possible points +possiblePoints[1] = {xLocation = 1, yLocation = 2, total = (list[1][1] + list[2][1]), fromRight = true}; +possiblePoints[2] = {xLocation = 2, yLocation = 2, total = (list[1][1] + list[2][2]), fromRight = false}; +foundBottom = false; --Used when you find a point at the bottom + +--Loop until you find the bottom +while(not foundBottom) do + --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,#possiblePoints do + if(possiblePoints[loc].total < minLoc.total) then + minLoc = possiblePoints[loc]; + end + end + + --Remove it from the list of possible points + remove_if(possiblePoints, minLoc); + + table.insert(foundPoints, 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 to the next row + if(yLoc > NUM_ROWS) then + foundBottom = true; + else + table.insert(possiblePoints, {xLocation = xLoc, yLocation = yLoc, total = (minLoc.total + list[yLoc][xLoc]), fromRight = true}); + xLoc = xLoc + 1; --Advance the x location to simulate going right + table.insert(possiblePoints, {xLocation = xLoc, yLocation = yLoc, total = (minLoc.total + list[yLoc][xLoc]), fromRight = false}); + end +end + +actualTotal = ((100 * (NUM_ROWS)) - foundPoints[#foundPoints].total); + +--Stop the timer +timer:stop(); + +--Reinvert the list so it will print propperly +invert(list); + +--Print the results +print("The value of the longest path is " .. actualTotal); +print("It took " .. timer:getSeconds() .. " seconds to run this algorithm"); + + +--[[ Results: +The value of the longest path is 7273 +It took 8.145 seconds to run this algorithm +]] diff --git a/Problem7.lua b/Problem7.lua new file mode 100644 index 0000000..5ff8c83 --- /dev/null +++ b/Problem7.lua @@ -0,0 +1,45 @@ +--ProjectEuler/lua/Problem7.lua +--Matthew Ellison +-- Created: 02-05-19 +--Modified: 03-28-19 +--What is the 10001th prime number? +--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 . +]] + + +require "Stopwatch" +require "Algorithms" + + +timer = Stopwatch:create(); +timer:start(); + +NUM_PRIMES = 10001; --The number of the prime number desired +--Get the correct number of primes +primes = getNumPrimes(NUM_PRIMES); + +timer:stop(); + +--Print the results +print("The " .. NUM_PRIMES .. "th prime number is " .. primes[NUM_PRIMES]); +print("It took " .. timer:getMilliseconds() .. " milliseconds to run this algorithm"); + +--[[Results: +The 10001th prime number is 104743 +It took 127.505 milliseconds to run this algorithm +]] diff --git a/Problem8.lua b/Problem8.lua new file mode 100644 index 0000000..13aadd2 --- /dev/null +++ b/Problem8.lua @@ -0,0 +1,81 @@ +--ProjectEuler/lua/Problem8.lua +--Matthew Ellison +-- Created: 02-06-19 +--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 +]] +--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 . +]] + + +require "Stopwatch" + + +timer = Stopwatch:create(); +timer:start(); + +--Put the number into a variable. A string will do for now +NUMBER = "7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450"; +local maxNum = ""; --Holds the largest number product we have found so far +local maxProduct = 0; --Holds the product of what is currently stored in maxNum + +--Loop through all elements in the number string +for location=13,string.len(NUMBER) do + --Added 13 elements to it's own table + local currentProduct = string.sub(NUMBER, location, location) * string.sub(NUMBER, location - 1, location - 1) * string.sub(NUMBER, location - 2, location - 2) * string.sub(NUMBER, location - 3, location - 3) * string.sub(NUMBER, location - 4, location - 4) * string.sub(NUMBER, location - 5, location - 5) * string.sub(NUMBER, location - 6, location - 6) * string.sub(NUMBER, location - 7, location - 7) * string.sub(NUMBER, location - 8, location - 8) * string.sub(NUMBER, location - 9, location - 9) * string.sub(NUMBER, location - 10, location - 10) * string.sub(NUMBER, location - 11, location - 11) * string.sub(NUMBER, location - 12, location - 12); + --If the number is larger than the current max make it the max + if(currentProduct > maxProduct) then + maxProduct = currentProduct; + maxNum = string.sub(NUMBER, location - 12, location); + end +end + +timer:stop(); + +--Print the results +print("The largest product of 13 adjacent digits in the number is " .. math.floor(maxProduct)) +print("The numbers are " .. maxNum); +print("It took " .. timer:getMilliseconds() .. " milliseconds to run this algorithm"); + + +--[[Results: +The largest product of 13 adjacent digits in the number is 23514624000 +The numbers are 5576689664895 +It took 2.662 milliseconds to run this algorithm +]] diff --git a/Problem9.lua b/Problem9.lua new file mode 100644 index 0000000..4153b13 --- /dev/null +++ b/Problem9.lua @@ -0,0 +1,72 @@ +--ProjectEuler/lua/Problem9.lua +--Matthew Ellison +-- Created: 02-06-19 +--Modified: 03-28-19 +--There exists exactly one Pythagorean triplet for which a + b + c = 1000. Find the product abc. +--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 . +]] + + +require "Stopwatch" + +timer = Stopwatch:create(); +timer:start(); + +local foundTriplet = false; --A simple flag to determine if we have found what we are looking for +local sideA = 1; --Start with the lowest possible a and search for the b that completes the triplet +local sideB = 0; --Holds the second side of the triangle +local sideC = 0; --Holds the hyp +while((sideA <= (1000 / 3)) and (not foundTriplet)) do + --Setup sides b and c + sideB = sideA + 1; + sideC = math.sqrt(sideA^2 + sideB^2); --Get the hyp + if((sideC % 1) == 0) then --If the hyp is an integer then make it one + sideC = math.floor(sideC); + end + --Loop through all possible b's and calculate c's until you find a number >= 1000 + while((sideA + sideB + sideC) < 1000) do + sideB = sideB + 1; + sideC = math.sqrt(sideA^2 + sideB^2); --Get the hyp + if((sideC % 1) == 0) then --If the hyp is an integer then make it one + sideC = math.floor(sideC); + end + end + --Check if the correct sides were found, otherwise continue to the next possible side + if((sideA + sideB + sideC) == 1000) then + foundTriplet = true; + else + sideA = sideA + 1; + end +end + +timer:stop(); +--Print the results +if(foundTriplet) then + print("The Pythagorean triplet where a + b + c = 1000 is " .. sideA .. ' ' .. sideB .. ' ' .. sideC); + print("The product of those numbers is " .. sideA * sideB * sideC); +else + print("Could not find the Pythagorean triplet where a + b + c = 1000"); +end + +print("It took " .. timer:getMilliseconds() .. " milliseconds to run this algorithm"); + +--[[Results +The Pythagorean triplet where a + b + c = 1000 is 200 375 425 +The product of those numbers is 31875000 +It took 17.104 milliseconds to run this algorithm +]]