From d416b0fe5305ca7faf8b61a02234983d0b0b74f3 Mon Sep 17 00:00:00 2001 From: Mattrixwv Date: Sat, 6 Jun 2020 16:59:20 -0400 Subject: [PATCH] Inital commit with existing files --- .gitignore | 6 + Headers/Problem.hpp | 42 ++++ Headers/Problem1.hpp | 52 +++++ Headers/Problem10.hpp | 50 +++++ Headers/Problem11.hpp | 76 +++++++ Headers/Problem12.hpp | 59 ++++++ Headers/Problem13.hpp | 162 +++++++++++++++ Headers/Problem14.hpp | 60 ++++++ Headers/Problem15.hpp | 53 +++++ Headers/Problem16.hpp | 58 ++++++ Headers/Problem17.hpp | 53 +++++ Headers/Problem18.hpp | 86 ++++++++ Headers/Problem19.hpp | 69 +++++++ Headers/Problem2.hpp | 50 +++++ Headers/Problem20.hpp | 59 ++++++ Headers/Problem21.hpp | 66 ++++++ Headers/Problem22.hpp | 54 +++++ Headers/Problem23.hpp | 54 +++++ Headers/Problem24.hpp | 53 +++++ Headers/Problem25.hpp | 58 ++++++ Headers/Problem26.hpp | 53 +++++ Headers/Problem27.hpp | 56 +++++ Headers/Problem28.hpp | 54 +++++ Headers/Problem29.hpp | 62 ++++++ Headers/Problem3.hpp | 55 +++++ Headers/Problem30.hpp | 57 +++++ Headers/Problem4.hpp | 54 +++++ Headers/Problem5.hpp | 50 +++++ Headers/Problem6.hpp | 56 +++++ Headers/Problem67.hpp | 168 +++++++++++++++ Headers/Problem7.hpp | 51 +++++ Headers/Problem8.hpp | 78 +++++++ Headers/Problem9.hpp | 59 ++++++ LICENSE | 165 +++++++++++++++ Source/Problem1.cpp | 86 ++++++++ Source/Problem10.cpp | 74 +++++++ Source/Problem11.cpp | 204 ++++++++++++++++++ Source/Problem12.cpp | 111 ++++++++++ Source/Problem13.cpp | 295 ++++++++++++++++++++++++++ Source/Problem14.cpp | 111 ++++++++++ Source/Problem15.cpp | 99 +++++++++ Source/Problem16.cpp | 97 +++++++++ Source/Problem17.cpp | 212 +++++++++++++++++++ Source/Problem18.cpp | 226 ++++++++++++++++++++ Source/Problem19.cpp | 191 +++++++++++++++++ Source/Problem2.cpp | 82 ++++++++ Source/Problem20.cpp | 103 +++++++++ Source/Problem21.cpp | 115 +++++++++++ Source/Problem22.cpp | 470 ++++++++++++++++++++++++++++++++++++++++++ Source/Problem23.cpp | 118 +++++++++++ Source/Problem24.cpp | 86 ++++++++ Source/Problem25.cpp | 119 +++++++++++ Source/Problem26.cpp | 119 +++++++++++ Source/Problem27.cpp | 110 ++++++++++ Source/Problem28.cpp | 160 ++++++++++++++ Source/Problem29.cpp | 120 +++++++++++ Source/Problem3.cpp | 92 +++++++++ Source/Problem30.cpp | 127 ++++++++++++ Source/Problem4.cpp | 104 ++++++++++ Source/Problem5.cpp | 94 +++++++++ Source/Problem6.cpp | 96 +++++++++ Source/Problem67.cpp | 405 ++++++++++++++++++++++++++++++++++++ Source/Problem7.cpp | 75 +++++++ Source/Problem8.cpp | 114 ++++++++++ Source/Problem9.cpp | 119 +++++++++++ main.cpp | 256 +++++++++++++++++++++++ makefile | 29 +++ 67 files changed, 7057 insertions(+) create mode 100644 .gitignore create mode 100644 Headers/Problem.hpp create mode 100644 Headers/Problem1.hpp create mode 100644 Headers/Problem10.hpp create mode 100644 Headers/Problem11.hpp create mode 100644 Headers/Problem12.hpp create mode 100644 Headers/Problem13.hpp create mode 100644 Headers/Problem14.hpp create mode 100644 Headers/Problem15.hpp create mode 100644 Headers/Problem16.hpp create mode 100644 Headers/Problem17.hpp create mode 100644 Headers/Problem18.hpp create mode 100644 Headers/Problem19.hpp create mode 100644 Headers/Problem2.hpp create mode 100644 Headers/Problem20.hpp create mode 100644 Headers/Problem21.hpp create mode 100644 Headers/Problem22.hpp create mode 100644 Headers/Problem23.hpp create mode 100644 Headers/Problem24.hpp create mode 100644 Headers/Problem25.hpp create mode 100644 Headers/Problem26.hpp create mode 100644 Headers/Problem27.hpp create mode 100644 Headers/Problem28.hpp create mode 100644 Headers/Problem29.hpp create mode 100644 Headers/Problem3.hpp create mode 100644 Headers/Problem30.hpp create mode 100644 Headers/Problem4.hpp create mode 100644 Headers/Problem5.hpp create mode 100644 Headers/Problem6.hpp create mode 100644 Headers/Problem67.hpp create mode 100644 Headers/Problem7.hpp create mode 100644 Headers/Problem8.hpp create mode 100644 Headers/Problem9.hpp create mode 100644 LICENSE create mode 100644 Source/Problem1.cpp create mode 100644 Source/Problem10.cpp create mode 100644 Source/Problem11.cpp create mode 100644 Source/Problem12.cpp create mode 100644 Source/Problem13.cpp create mode 100644 Source/Problem14.cpp create mode 100644 Source/Problem15.cpp create mode 100644 Source/Problem16.cpp create mode 100644 Source/Problem17.cpp create mode 100644 Source/Problem18.cpp create mode 100644 Source/Problem19.cpp create mode 100644 Source/Problem2.cpp create mode 100644 Source/Problem20.cpp create mode 100644 Source/Problem21.cpp create mode 100644 Source/Problem22.cpp create mode 100644 Source/Problem23.cpp create mode 100644 Source/Problem24.cpp create mode 100644 Source/Problem25.cpp create mode 100644 Source/Problem26.cpp create mode 100644 Source/Problem27.cpp create mode 100644 Source/Problem28.cpp create mode 100644 Source/Problem29.cpp create mode 100644 Source/Problem3.cpp create mode 100644 Source/Problem30.cpp create mode 100644 Source/Problem4.cpp create mode 100644 Source/Problem5.cpp create mode 100644 Source/Problem6.cpp create mode 100644 Source/Problem67.cpp create mode 100644 Source/Problem7.cpp create mode 100644 Source/Problem8.cpp create mode 100644 Source/Problem9.cpp create mode 100644 main.cpp create mode 100644 makefile diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..5e74940 --- /dev/null +++ b/.gitignore @@ -0,0 +1,6 @@ +#Visual Studio Code +.vscode + +#Binary Files +lib/* +*.exe diff --git a/Headers/Problem.hpp b/Headers/Problem.hpp new file mode 100644 index 0000000..848753c --- /dev/null +++ b/Headers/Problem.hpp @@ -0,0 +1,42 @@ +//ProjectEuler/C++/Headers/Problem.hpp +//Matthew Ellison +// Created: 07-04-19 +//Modified: 07-10-19 +//This is an abstract base class to allow polymorphism for the individual problems + +#ifndef PROBLEM_HPP +#define PROBLEM_HPP + + +#include +#include "Stopwatch.hpp" + + +class Problem{ +protected: + const std::string description; //Holds the description of the problem + mee::Stopwatch timer; //Used to determine your algorithm's run time + bool solved; //Holds true after the problem has been solved + class unsolved{}; //An exception class thrown if you try to access something before it has been solved +public: + //Constructors + Problem() : solved(false){ + + } + Problem(std::string description) : description(description), solved(false){ + + } + virtual ~Problem(){ + + } + virtual std::string getDescription() const{ + return description; + } + virtual std::string getTime(){ + return timer.getStr(); + } + virtual void solve() = 0; + virtual std::string getString() const = 0; +}; + +#endif //PROBLEM_HPP diff --git a/Headers/Problem1.hpp b/Headers/Problem1.hpp new file mode 100644 index 0000000..6236a2f --- /dev/null +++ b/Headers/Problem1.hpp @@ -0,0 +1,52 @@ +//ProjectEuler/C++/Headers/Problem1.hpp +//Matthew Ellison +// Created: 09-28-18 +//Modified: 07-14-19 +//What is the sum of all the multiples of 3 or 5 that are less than 1000 +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + +#ifndef PROBLEM1_HPP +#define PROBLEM1_HPP + + +#include +#include +#include +#include "Problem.hpp" + + +class Problem1: public Problem{ +private: + static uint64_t MAX_NUMBER; + uint64_t fullSum; //For the sum of all the numbers + std::vector numbers; //Holds all the numbers +public: + Problem1(); + virtual void solve(); + virtual std::string getString() const; + //Returns the requested sum + uint64_t getSum() const; +}; + +/* Results: +The sum of all the numbers < 1000 that are divisible by 3 or 5 is 233168 +It took 4.500 microseconds to solve this problem. +*/ + +#endif //PROBLEM1_HPP diff --git a/Headers/Problem10.hpp b/Headers/Problem10.hpp new file mode 100644 index 0000000..ffcad97 --- /dev/null +++ b/Headers/Problem10.hpp @@ -0,0 +1,50 @@ +//ProjectEuler/C++/Headers/Problem10.hpp +//Matthew Ellison +// Created: 09-28-18 +//Modified: 07-14-19 +//Find the sum of all the primes below two million +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + +#ifndef PROBLEM10_HPP +#define PROBLEM10_HPP + + +#include +#include +#include "Problem.hpp" + + +class Problem10 : public Problem{ +private: + static uint64_t GOAL_NUMBER; + uint64_t sum; +public: + Problem10(); + virtual void solve(); + virtual std::string getString() const; + //Returns the sum that was requested + uint64_t getSum() const; +}; + +/* Results: +The sum of all the primes less than 2000000 is 142913828922 +It took 162.240 milliseconds to solve this problem. +*/ + +#endif //PROBLEM10_HPP diff --git a/Headers/Problem11.hpp b/Headers/Problem11.hpp new file mode 100644 index 0000000..dc0ed5f --- /dev/null +++ b/Headers/Problem11.hpp @@ -0,0 +1,76 @@ +//ProjectEuler/C++/Headers/Problem11.hpp +//MatthewEllison +// Created: 09-29-18 +//Modified: 07-14-19 +//What is the greatest product of four adjacent numbers in the same direction (up, down, left, right, or diagonally) in the 20×20 grid? +/* +08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08 +49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00 +81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65 +52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91 +22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80 +24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50 +32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70 +67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21 +24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72 +21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95 +78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92 +16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57 +86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58 +19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40 +04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66 +88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69 +04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36 +20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16 +20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54 +01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48 +*/ +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + +#ifndef PROBLEM11_HPP +#define PROBLEM11_HPP + + +#include +#include +#include "Problem.hpp" + + +class Problem11 : public Problem{ +private: + //This is the grid of number that we will be working with + static std::vector grid[20]; + std::vector greatestProduct; //This is a vector containing the largest product we have found so far +public: + Problem11(); + virtual void solve(); + virtual std::string getString() const; + //Returns the numbers that were being searched + std::vector getNumbers() const; + //Returns the product that was requested + int getProduct() const; +}; + +/* Results: +The greatest product of 4 number in a line is 70600674 +The numbers are 89 94 97 87 +It took 12.900 microseconds to solve this problem +*/ + +#endif //PROBLEM11_HPP diff --git a/Headers/Problem12.hpp b/Headers/Problem12.hpp new file mode 100644 index 0000000..f12152a --- /dev/null +++ b/Headers/Problem12.hpp @@ -0,0 +1,59 @@ +//ProjectEuler/C++/Headers/Problem12.hpp +//Matthew Ellison +// Created: 09-27-18 +//Modified: 07-14-19 +//What is the value of the first triangle number to have over five hundred divisors? +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* 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 . +*/ + +#ifndef PROBLEM12_HPP +#define PROBLEM12_HPP + + +#include +#include +#include +#include "Problem.hpp" + + +class Problem12 : public Problem{ +private: + static uint64_t GOAL_DIVISORS; //The number of divisors that you want + int64_t sum; //The sum of the numbers up to counter + int64_t counter; //The next number to be added to sum + std::vector divisors; //Holds the divisors of the triangular number sum +public: + Problem12(); + virtual void solve(); + virtual std::string getString() const; + //Returns the triangular number + int64_t getTriangularNumber() const; + //Get the final number that was added to the triangular number + int64_t getLastNumberAdded() const; + //Returns the list of divisors of the requested number + std::vector getDivisorsOfTriangularNumber() const; + //Returns the number of divisors of the requested number + size_t getNumberOfDivisors() const; +}; + + +/* Results: +The triangular number 76576500 is a sum of all numbers >= 12375 and has 576 divisors +It took 262.765 milliseconds to solve this problem. +*/ + +#endif //PROBLEM12_HPP diff --git a/Headers/Problem13.hpp b/Headers/Problem13.hpp new file mode 100644 index 0000000..5205d51 --- /dev/null +++ b/Headers/Problem13.hpp @@ -0,0 +1,162 @@ +//ProjectEuler/C++/Headers/Problem13.hpp +//Matthew Ellison +// Created: 09-29-18 +//Modified: 07-14-19 +//Work out the first ten digits of the sum of the following one-hundred 50-digit numbers +/* +37107287533902102798797998220837590246510135740250 +46376937677490009712648124896970078050417018260538 +74324986199524741059474233309513058123726617309629 +91942213363574161572522430563301811072406154908250 +23067588207539346171171980310421047513778063246676 +89261670696623633820136378418383684178734361726757 +28112879812849979408065481931592621691275889832738 +44274228917432520321923589422876796487670272189318 +47451445736001306439091167216856844588711603153276 +70386486105843025439939619828917593665686757934951 +62176457141856560629502157223196586755079324193331 +64906352462741904929101432445813822663347944758178 +92575867718337217661963751590579239728245598838407 +58203565325359399008402633568948830189458628227828 +80181199384826282014278194139940567587151170094390 +35398664372827112653829987240784473053190104293586 +86515506006295864861532075273371959191420517255829 +71693888707715466499115593487603532921714970056938 +54370070576826684624621495650076471787294438377604 +53282654108756828443191190634694037855217779295145 +36123272525000296071075082563815656710885258350721 +45876576172410976447339110607218265236877223636045 +17423706905851860660448207621209813287860733969412 +81142660418086830619328460811191061556940512689692 +51934325451728388641918047049293215058642563049483 +62467221648435076201727918039944693004732956340691 +15732444386908125794514089057706229429197107928209 +55037687525678773091862540744969844508330393682126 +18336384825330154686196124348767681297534375946515 +80386287592878490201521685554828717201219257766954 +78182833757993103614740356856449095527097864797581 +16726320100436897842553539920931837441497806860984 +48403098129077791799088218795327364475675590848030 +87086987551392711854517078544161852424320693150332 +59959406895756536782107074926966537676326235447210 +69793950679652694742597709739166693763042633987085 +41052684708299085211399427365734116182760315001271 +65378607361501080857009149939512557028198746004375 +35829035317434717326932123578154982629742552737307 +94953759765105305946966067683156574377167401875275 +88902802571733229619176668713819931811048770190271 +25267680276078003013678680992525463401061632866526 +36270218540497705585629946580636237993140746255962 +24074486908231174977792365466257246923322810917141 +91430288197103288597806669760892938638285025333403 +34413065578016127815921815005561868836468420090470 +23053081172816430487623791969842487255036638784583 +11487696932154902810424020138335124462181441773470 +63783299490636259666498587618221225225512486764533 +67720186971698544312419572409913959008952310058822 +95548255300263520781532296796249481641953868218774 +76085327132285723110424803456124867697064507995236 +37774242535411291684276865538926205024910326572967 +23701913275725675285653248258265463092207058596522 +29798860272258331913126375147341994889534765745501 +18495701454879288984856827726077713721403798879715 +38298203783031473527721580348144513491373226651381 +34829543829199918180278916522431027392251122869539 +40957953066405232632538044100059654939159879593635 +29746152185502371307642255121183693803580388584903 +41698116222072977186158236678424689157993532961922 +62467957194401269043877107275048102390895523597457 +23189706772547915061505504953922979530901129967519 +86188088225875314529584099251203829009407770775672 +11306739708304724483816533873502340845647058077308 +82959174767140363198008187129011875491310547126581 +97623331044818386269515456334926366572897563400500 +42846280183517070527831839425882145521227251250327 +55121603546981200581762165212827652751691296897789 +32238195734329339946437501907836945765883352399886 +75506164965184775180738168837861091527357929701337 +62177842752192623401942399639168044983993173312731 +32924185707147349566916674687634660915035914677504 +99518671430235219628894890102423325116913619626622 +73267460800591547471830798392868535206946944540724 +76841822524674417161514036427982273348055556214818 +97142617910342598647204516893989422179826088076852 +87783646182799346313767754307809363333018982642090 +10848802521674670883215120185883543223812876952786 +71329612474782464538636993009049310363619763878039 +62184073572399794223406235393808339651327408011116 +66627891981488087797941876876144230030984490851411 +60661826293682836764744779239180335110989069790714 +85786944089552990653640447425576083659976645795096 +66024396409905389607120198219976047599490197230297 +64913982680032973156037120041377903785566085089252 +16730939319872750275468906903707539413042652315011 +94809377245048795150954100921645863754710598436791 +78639167021187492431995700641917969777599028300699 +15368713711936614952811305876380278410754449733078 +40789923115535562561142322423255033685442488917353 +44889911501440648020369068063960672322193204149535 +41503128880339536053299340368006977710650566631954 +81234880673210146739058568557934581403627822703280 +82616570773948327592232845941706525094512325230608 +22918802058777319719839450180888072429661980811197 +77158542502016545090413245809786882778948721859617 +72107838435069186155435662884062257473692284509516 +20849603980134001723930671666823555245252804609722 +53503534226472524250874054075591789781264330331690 +*/ +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +//This file contains a header from the gmp library. The library is used for large integers. +//You can find more information about them at https://gmplib.org/ +//When compiling this file you need to have the gmp library installed as well as linking the libraries to your executable using the -lgmpxx and -lgmp flags +/* + 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 . +*/ + +#ifndef PROBLEM13_HPP +#define PROBLEM13_HPP + + +#include +#include +#include +#include "gmpxx.h" //This is part of the gmp library +#include "Problem.hpp" + + +class Problem13 : public Problem{ +private: + //A vector to hold all of the numbers + static std::vector nums; + mpz_class sum; +public: + Problem13(); + virtual void solve(); + virtual std::string getString() const; + //Returns the list 50-digit numbers + std::vector getNumbers() const; + //Returns the sum of the 50-digit numbers + mpz_class getSum() const; +}; + + +/* Results: +The sum of all 100 numbers is 5537376230390876637302048746832985971773659831892672 +The first 10 digits of the sum of the numbers is 5537376230 +It took 10.000 microseconds to solve this problem. +*/ + +#endif //PROBLEM13_HPP diff --git a/Headers/Problem14.hpp b/Headers/Problem14.hpp new file mode 100644 index 0000000..35dee86 --- /dev/null +++ b/Headers/Problem14.hpp @@ -0,0 +1,60 @@ +//ProjectEuler/C++/Headers/Problem14.hpp +//Matthew Ellison +// Created: 09-29-18 +//Modified: 07-14-19 +/* +The following iterative sequence is defined for the set of positive integers: +n → n/2 (n is even) +n → 3n + 1 (n is odd) +Which starting number, under one million, produces the longest chain? +*/ +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + +#ifndef PROBLEM14_HPP +#define PROBLEM14_HPP + + +#include +#include +#include "Problem.hpp" + + +class Problem14 : public Problem{ +private: + //This function follows the rules of the sequence and returns its length + uint64_t checkSeries(uint64_t num); + static uint64_t MAX_NUM; //This is the top number that you will be checking against the series + uint64_t maxLength; //This is the length of the longest chain + uint64_t maxNum; //This is the starting number of the longest chain +public: + Problem14(); + virtual void solve(); + virtual std::string getString() const; + //Returns the length of the requested chain + uint64_t getLength() const; + //Returns the starting number of the requested chain + uint64_t getStartingNumber() const; +}; + +/* Results: +The number 837799 produced a chain of 525 steps +It took 179.333 milliseconds to solve this problem. +*/ + +#endif //PROBLEM14_HPP diff --git a/Headers/Problem15.hpp b/Headers/Problem15.hpp new file mode 100644 index 0000000..c4a07f3 --- /dev/null +++ b/Headers/Problem15.hpp @@ -0,0 +1,53 @@ +//ProjectEuler/C++/Headers/Problem15.hpp +//Matthew Ellison +// Created: 09-29-18 +//Modified: 07-14-19 +//How many routes from the top left corner to the bottom right corner are there through a 20×20 grid if you can only move right and down? +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + +#ifndef PROBLEM15_HPP +#define PROBLEM15_HPP + + +#include +#include +#include "Problem.hpp" + + +class Problem15 : public Problem{ +private: + static int WIDTH; //The width of the grid + static int LENGTH; //The length of the grid + uint64_t numOfRoutes; //The number of routes from 0, 0 to 20, 20 + //This function acts as a handler for moving the position on the grid and counting the distance + //If moves right first, then down + void move(int currentX, int currentY, uint64_t& numOfRoutes); +public: + Problem15(); + virtual void solve(); + virtual std::string getString() const; + //Returns the number of routes found + uint64_t getNumberOfRoutes() const; +}; +/* Results: +The number of routes is 137846528820 +It took 12.1234 minutes to run this algorithm +*/ + +#endif //PROBLEM15_HPP diff --git a/Headers/Problem16.hpp b/Headers/Problem16.hpp new file mode 100644 index 0000000..777ef0c --- /dev/null +++ b/Headers/Problem16.hpp @@ -0,0 +1,58 @@ +//ProjectEuler/C++/Headers/Problem16.hpp +//Matthew Ellison +// Created: 09-28-18 +//Modified: 07-14-19 +//What is the sum of the digits of the number 2^1000? +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +//This file contains a header from the gmp library. The library is used for large integers. +//You can find more information about them at https://gmplib.org/ +//When compiling this file you need to have the gmp library installed as well as linking the libraries to your executable using the -lgmpxx and -lgmp flags +/* + 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 . +*/ + +#ifndef PROBLEM16_HPP +#define PROBLEM16_HPP + + +#include +#include +#include "Problem.hpp" + + +class Problem16 : public Problem{ +private: + static int NUM_TO_POWER; //The number that is going to be raised to a power + static int POWER; //The power that the number is going to be raised to + mpz_class num; //The number to be calculated + int sumOfElements; //The sum of all digits in the number +public: + Problem16(); + virtual void solve(); + virtual std::string getString() const; + //Returns the number that was calculated + mpz_class getNumber() const; + //Return the sum of the digits of the number + int getSum() const; +}; + +/* Results: +2^1000 = 10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831652624386837205668069376 +The sum of the elements is 1366 +It took 7.300 microseconds to solve this problem. +*/ + +#endif //PROBLEM16_HPP diff --git a/Headers/Problem17.hpp b/Headers/Problem17.hpp new file mode 100644 index 0000000..e68bc96 --- /dev/null +++ b/Headers/Problem17.hpp @@ -0,0 +1,53 @@ +//ProjectEuler/C++/Headers/Problem17.hpp +//Matthew Ellison +// Created: 10-05-18 +//Modified: 07-14-19 +//If all the numbers from 1 to 1000 (one thousand) inclusive were written out in words, how many letters would be used? +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + +#ifndef PROBLEM17_HPP +#define PROBLEM17_HPP + + +#include +#include +#include "Problem.hpp" + + +class Problem17 : public Problem{ +private: + std::string makeWord(int num); + std::string wordHelper(int num); + uint64_t countLetters(std::string str); + + static int TOP_NUM; //This is the largest number to get the words of + uint64_t letterCount; //This is the cumulative number of letters in the words of the numbers +public: + Problem17(); + virtual void solve(); + virtual std::string getString() const; + //Returns the number of letters asked for + uint64_t getLetterCount() const; +}; +/* Results: +The number of letters is 21124 +It took 217.500 microseconds to solve this problem. +*/ + +#endif //Problem17_HPP diff --git a/Headers/Problem18.hpp b/Headers/Problem18.hpp new file mode 100644 index 0000000..e39a7f3 --- /dev/null +++ b/Headers/Problem18.hpp @@ -0,0 +1,86 @@ +//ProjectEuler/C++/Headers/Problem18.hpp +//Matthew Ellison +// Created: 11-01-18 +//Modified: 07-14-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 +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + +#ifndef PROBLEM18_HPP +#define PROBLEM18_HPP + + +#include +#include +#include +#include "Problem.hpp" + + +class Problem18 : public Problem{ +private: + struct location{ + int xLocation; + int yLocation; + int total; + bool fromRight; + location(int x, int y, int t, bool r) : xLocation(x), yLocation(y), total(t), fromRight(r){ } + }; + //This list turns every number in the vector into 100 - num + void invert(); + static const int NUM_ROWS = 15; //The number of rows in the array + //Setup the list you are trying to find a path through + static std::vector list[NUM_ROWS]; + std::list foundPoints; //For the points that I have already found the shortest distance to + std::list possiblePoints; //For the locations you are checking this round + int actualTotal; //The true total of the path from the top to the bottom +public: + Problem18(); + virtual void solve(); + virtual std::string getString() const; + //Returns the pyramid that was traversed as a string + std::string getPyramid(); + //Returns the trail the algorithm took as a string + std::string getTrail(); + //Returns the total that was asked for + int getTotal() const; +}; + +/* Results: +The value of the longest path is 1074 +It took 16.500 microseconds to solve this problem. +*/ + +#endif //PROBLEM18_HPP diff --git a/Headers/Problem19.hpp b/Headers/Problem19.hpp new file mode 100644 index 0000000..014c6ca --- /dev/null +++ b/Headers/Problem19.hpp @@ -0,0 +1,69 @@ +//ProjectEuler/C++/Headers/Problem19.hpp +//Matthew Ellison +// Created: 09-28-18 +//Modified: 07-14-19 +//How many Sundays fell on the first of the month during the twentieth century (1 Jan 1901 to 31 Dec 2000)? +/* +You are given the following information, but you may prefer to do some research for yourself. +1 Jan 1900 was a Monday. +Thirty days has September, +April, June and November. +All the rest have thirty-one, +Saving February alone, +Which has twenty-eight, rain or shine. +And on leap years, twenty-nine. +A leap year occurs on any year evenly divisible by 4, but not on a century unless it is divisible by 400. +*/ +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + +#ifndef PROBLEM19_HPP +#define PROBLEM19_HPP + + +#include +#include +#include "Problem.hpp" + + +class Problem19 : public Problem{ +private: +//Variables + //An easier way to return the days + enum DAYS {SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, NUMBER_OF_DAYS, ERROR}; + static unsigned int START_YEAR; //The start year + static unsigned int END_YEAR; //The stop year + uint64_t totalSundays; //Keep track of the number of sundays +//Functions + //Return the day of the week that the date you pass into it is on + DAYS getDay(unsigned int month, unsigned int day, unsigned int year); + //Returns true if the year passed to it is a leap year + bool isLeapYear(unsigned int year); +public: + Problem19(); + virtual void solve(); + virtual std::string getString() const; + //Returns the total sundays that were asked for + uint64_t getTotalSundays() const; +}; +/* Results +There are 171 Sundays that landed on the first of the months from 1901 to 2000 +It took 4.579 milliseconds to solve this problem. +*/ + +#endif //PROBLEM19_HPP diff --git a/Headers/Problem2.hpp b/Headers/Problem2.hpp new file mode 100644 index 0000000..893c1ce --- /dev/null +++ b/Headers/Problem2.hpp @@ -0,0 +1,50 @@ +//ProjectEuler/C++/Headers/Problem2.hpp +//Matthew Ellison +// Created: 09-28-18 +//Modified: 07-14-19 +//The sum of the even Fibonacci numbers less than 4,000,000 +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + + +#ifndef PROBLEM2_HPP +#define PROBLEM2_HPP + +#include +#include +#include "Problem.hpp" + + +class Problem2 : public Problem{ +private: + static uint64_t TOP_NUM; //Holds the largest number that we are looking for + uint64_t fullSum; //Holds the sum of all the numbers +public: + Problem2(); + virtual void solve(); + virtual std::string getString() const; + //Returns the requested sum + uint64_t getSum() const; +}; + +/* Results: +The sum of the even Fibonacci numbers less than 4,000,000 is 4613732 +It took 2.200 microseconds to solve this problem. +*/ + +#endif //PROBLEM2_HPP diff --git a/Headers/Problem20.hpp b/Headers/Problem20.hpp new file mode 100644 index 0000000..a090b28 --- /dev/null +++ b/Headers/Problem20.hpp @@ -0,0 +1,59 @@ +//ProjectEuler/C++/Headers/Problem20.hpp +//Matthew Ellison +// Created: 11-07-18 +//Modified: 07-14-19 +//What is the sum of the digits of 100!? +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +//This file contains a header from the gmp library. The library is used for large integers. +//You can find more information about them at https://gmplib.org/ +//When compiling this file you need to have the gmp library installed as well as linking the libraries to your executable using the -lgmpxx and -lgmp flags +/* + 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 . +*/ + +#ifndef PROBLEM20_HPP +#define PROBLEM20_HPP + + +#include +#include +#include "gmpxx.h" +#include "Problem.hpp" + + +class Problem20 : public Problem{ +private: + mpz_class num; //Holds the number 100! + uint64_t sum; //The sum of the digits of num +public: + Problem20(); + virtual void solve(); + virtual std::string getString() const; + //Returns the number 100! + mpz_class getNumber() const; + //Returns the number 100! in a string + std::string getNumberString() const; + //Returns the sum of the digits of 100! + uint64_t getSum() const; +}; + +/* Results: +100! = 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000 +The sum of the digits is: 648 +It took 8.300 microseconds to solve this problem. +*/ + +#endif //PROBLEM20_HPP diff --git a/Headers/Problem21.hpp b/Headers/Problem21.hpp new file mode 100644 index 0000000..04e3b4e --- /dev/null +++ b/Headers/Problem21.hpp @@ -0,0 +1,66 @@ +//ProjectEuler/C++/Headers/Problem21.hpp +//Matthew Ellison +// Created: 11-08-18 +//Modified: 07-14-19 +//Evaluate the sum of all the amicable numbers under 10000 +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + +#ifndef PROBLEM21_HPP +#define PROBLEM21_HPP + + +#include +#include +#include +#include "Problem.hpp" + + +class Problem21 : public Problem{ +private: + static int LIMIT; //The top number that will be evaluated + std::vector divisorSum; //Holds the sum of the divisors of the subscript number + std::vector amicable; //Holds all amicable numbers +public: + Problem21(); + virtual void solve(); + virtual std::string getString() const; + //Returns a vector with all of the amicable numbers calculated + std::vector getAmicable() const; + //Returns the sum of all of the amicable numbers + uint64_t getSum() const; +}; + + +/* 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 4.083 milliseconds to solve this problem. +*/ + +#endif //PROBLEM21_HPP diff --git a/Headers/Problem22.hpp b/Headers/Problem22.hpp new file mode 100644 index 0000000..6848b4f --- /dev/null +++ b/Headers/Problem22.hpp @@ -0,0 +1,54 @@ +//ProjectEuler/C++/Headers/Problem22.hpp +//Matthew Ellison +// Created: 11-09-18 +//Modified: 07-14-19 +//What is the total of all the name scores in the file? +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + +#ifndef PROBLEM22_HPP +#define PROBLEM22_HPP + + +#include +#include +#include +#include "Problem.hpp" + + +class Problem22 : public Problem{ +private: + std::vector sums; //Holds the score based on the sum of the characters in the name + std::vector prod; //Holds the score based on the sum of the characters and the location in alphabetical order + static std::vector names; //Holds the names that will be scored +public: + Problem22(); + virtual void solve(); + virtual std::string getString() const; + //Returns the vector of the names being scored + std::vector getNames() const; + //Returns the sum of the names scores + uint64_t getNameScoreSum() const; +}; + +/* Results: +The answer to the question is 871198282 +It took 638.400 microseconds to solve this problem. +*/ + +#endif //Problem22 diff --git a/Headers/Problem23.hpp b/Headers/Problem23.hpp new file mode 100644 index 0000000..2c950b8 --- /dev/null +++ b/Headers/Problem23.hpp @@ -0,0 +1,54 @@ +//ProjectEuler/C++/Headers/Problem23.hpp +//Matthew Ellison +// Created: 11-09-18 +//Modified: 07-14-19 +//Find the sum of all the positive integers which cannot be written as the sum of two abundant numbers +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + +#ifndef PROBLEM23_HPP +#define PROBLEM23_HPP + + +#include +#include +#include +#include "Problem.hpp" + + +class Problem23 : public Problem{ +private: + static int MAX_NUM; + std::vector divisorSums; //This gives the sum of the divisors at subscripts + uint64_t sum; //The sum of all the numbers we are looking for + //A function that returns true if num can be created by adding two elements from abund and false if it cannot + bool isSum(const std::vector& abund, int num); +public: + Problem23(); + virtual void solve(); + virtual std::string getString() const; + //Returns the sum of the numbers asked for + uint64_t getSum() const; +}; + +/* Results: +The answer is 4179871 +It took 4.888 seconds to solve this problem. +*/ + +#endif //PROBLEM23_HPP diff --git a/Headers/Problem24.hpp b/Headers/Problem24.hpp new file mode 100644 index 0000000..58f2bf4 --- /dev/null +++ b/Headers/Problem24.hpp @@ -0,0 +1,53 @@ +//ProjectEuler/C++/Headers/Problem24.hpp +//Matthew Ellison +// Created: 11-11-18 +//Modified: 07-14-19 +//What is the millionth lexicographic permutation of the digits 0, 1, 2, 3, 4, 5, 6, 7, 8 and 9? +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + +#ifndef PROBLEM24_HPP +#define PROBLEM24_HPP + + +#include +#include +#include "Problem.hpp" + + +class Problem24 : public Problem{ +private: + static int NEEDED_PERM; //The number of the permutation that you need + static std::string nums; //All of the characters that we need to get the permutations of + std::vector permutations; //Holds all of the permutations of the string nums +public: + Problem24(); + virtual void solve(); + virtual std::string getString() const; + //Returns a vector with all of the permutations + std::vector getPermutationsList() const; + //Returns the specific permutations you are looking for + std::string getPermutation() const; +}; + +/* Results +The 1 millionth permutation is 2783915460 +It took 1.166 seconds to solve this problem. +*/ + +#endif //PROBLEM24_HPP diff --git a/Headers/Problem25.hpp b/Headers/Problem25.hpp new file mode 100644 index 0000000..dd22363 --- /dev/null +++ b/Headers/Problem25.hpp @@ -0,0 +1,58 @@ +//ProjectEuler/C++/Headers/Problem25.hpp +//Matthew Ellison +// Created: 11-13-18 +//Modified: 07-14-19 +//What is the index of the first term in the Fibonacci sequence to contain 1000 digits? +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +//This file contains a header from the gmp library. The library is used for large integers. +//You can find more information about them at https://gmplib.org/ +//When compiling this file you need to have the gmp library installed as well as linking the libraries to your executable using the -lgmpxx and -lgmp flags +/* + 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 . +*/ + +#ifndef PROBLEM25_HPP +#define PROBLEM25_HPP + + +#include +#include "gmpxx.h" +#include "Problem.hpp" + + +class Problem25 : public Problem{ +private: + static unsigned int NUM_DIGITS; //The number of digits to calculate up to + mpz_class number; //The current Fibonacci number + mpz_class index; //The index of the current Fibonacci number just calculated +public: + Problem25(); + virtual void solve(); + virtual std::string getString() const; + mpz_class getNumber() const; //Returns the Fibonacci number asked for + std::string getNumberString() const; //Returns the Fibonacci number asked for as a string + mpz_class getIndex() const; //Returns the index of the requested Fibonacci number + std::string getIndexString() const; //Returns the index of the requested Fibonacci number as a string + uint64_t getIndexInt() const; //Returns the index of the requested Fibonacci number as a uint64_t +}; + +/* Results: +The first Fibonacci number with 1000 digits is 1070066266382758936764980584457396885083683896632151665013235203375314520604694040621889147582489792657804694888177591957484336466672569959512996030461262748092482186144069433051234774442750273781753087579391666192149259186759553966422837148943113074699503439547001985432609723067290192870526447243726117715821825548491120525013201478612965931381792235559657452039506137551467837543229119602129934048260706175397706847068202895486902666185435124521900369480641357447470911707619766945691070098024393439617474103736912503231365532164773697023167755051595173518460579954919410967778373229665796581646513903488154256310184224190259846088000110186255550245493937113651657039447629584714548523425950428582425306083544435428212611008992863795048006894330309773217834864543113205765659868456288616808718693835297350643986297640660000723562917905207051164077614812491885830945940566688339109350944456576357666151619317753792891661581327159616877487983821820492520348473874384736771934512787029218636250627816 +Its index is 4782 +It took 188.246 milliseconds to solve this problem. +*/ + +#endif //PROBLEM25_HPP diff --git a/Headers/Problem26.hpp b/Headers/Problem26.hpp new file mode 100644 index 0000000..628484b --- /dev/null +++ b/Headers/Problem26.hpp @@ -0,0 +1,53 @@ +//ProjectEuler/C++/Headers/Problem26.hpp +//Matthew Ellison +// Created: 07-28-19 +//Modified: 07-28-19 +//Find the value of d < 1000 for which 1/d contains the longest recurring cycle in its decimal fraction part. +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + + +#ifndef PROBLEM26_HPP +#define PROBLEM26_HPP + + +#include +#include "Problem.hpp" + + +class Problem26 : public Problem{ +private: + static unsigned int TOP_NUMBER; //Holds the highest denominator we will check + unsigned int longestCycle; //The length of the longest cycle + unsigned int longestNumber; //The starting denominator of the longest cycle +public: + Problem26(); + virtual void solve(); + virtual std::string getString() const; + unsigned int getLongestCycle() const; //Returns the length of the longest cycle + unsigned int getLongestNumber() const; //Returns the denominator that starts the longest cycle +}; + + +/* Results: +The longest cycle is 982 digits long +It is started with the number 983 +It took 6.865 milliseconds to solve this problem. +*/ + +#endif //PROBLEM26_HPP diff --git a/Headers/Problem27.hpp b/Headers/Problem27.hpp new file mode 100644 index 0000000..828df5d --- /dev/null +++ b/Headers/Problem27.hpp @@ -0,0 +1,56 @@ +//ProjectEuler/C++/Headers/Problem27.hpp +//Matthew Ellison +// Created: 09-14-19 +//Modified: 09-14-19 +//Find the product of the coefficients, |a| < 1000 and |b| <= 1000, for the quadratic expression that produces the maximum number of primes for consecutive values of n, starting with n=0. +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + +#ifndef PROBLEM27_HPP +#define PROBLEM27_HPP + + +#include +#include +#include +#include "Problem.hpp" + + +class Problem27 : public Problem{ +private: + int64_t topA; //The A for the most n's generated + int64_t topB; //The B for the most n's generated + int64_t topN; //The most n's generated + std::vector primes; //A list of all primes that could possibly be generated with this formula +public: + Problem27(); + virtual void solve(); + virtual std::string getString() const; + int64_t getTopA() const; + int64_t getTopB() const; + int64_t getTopN() const; +}; + +/* 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 2.076 seconds to solve this problem. +*/ + +#endif //PROBLEM27_HPP diff --git a/Headers/Problem28.hpp b/Headers/Problem28.hpp new file mode 100644 index 0000000..496e4b6 --- /dev/null +++ b/Headers/Problem28.hpp @@ -0,0 +1,54 @@ +//ProjectEuler/C++/Headers/Problem28.hpp +//Matthew Ellison +// Created: 09-21-19 +//Modified: 09-21-19 +//What is the sum of the numbers on the diagonals in a 1001 by 1001 spiral formed by starting with the number 1 and moving to the right in a clockwise direction a 5 by 5 spiral +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + + +#ifndef PROBLEM28_HPP +#define PROBLEM28_HPP + + +#include +#include +#include +#include "Problem.hpp" + + +class Problem28 : public Problem{ +private: + std::vector> grid; //Holds the grid that we will be filling and searching + uint64_t sumOfDiagonals; //Holds the sum of the diagonals of the grid + void setupGrid(); //Sets up the grid + void findSum(); //Finds the sum of the diagonals in the grid +public: + Problem28(); + virtual void solve(); + virtual std::string getString() const; + std::vector> getGrid() const; //Returns the grid + uint64_t getSum() const; //Returns the sum of the diagonals +}; + +/* Results: +The sum of the diagonals in the given grid is 669171001 +It took 913.800 microseconds to solve this problem. +*/ + +#endif //PROBLEM28_HPP diff --git a/Headers/Problem29.hpp b/Headers/Problem29.hpp new file mode 100644 index 0000000..22b6bc9 --- /dev/null +++ b/Headers/Problem29.hpp @@ -0,0 +1,62 @@ +//ProjectEuler/C++/Headers/Problem29.hpp +//Matthew Ellison +// Created: 10-06-19 +//Modified: 10-06-19 +//How many distinct terms are in the sequence generated by a^b for 2 <= a <= 100 and 2 <= b <= 100? +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +//This file contains a header from the gmp library. The library is used for large integers. +//You can find more information about them at https://gmplib.org/ +//When compiling this file you need to have the gmp library installed as well as linking the libraries to your executable using the -lgmpxx and -lgmp flags +/* + 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 . +*/ + + +#ifndef PROBLEM29_HPP +#define PROBLEM29_HPP + + +#include +#include +#include +#include +#include "Problem.hpp" + + +class Problem29 : public Problem{ +private: + static const unsigned int BOTTOM_A = 2; //The lowest possible value for a + static const unsigned int TOP_A = 100; //The highest possible value for a + static const unsigned int BOTTOM_B = 2; //The lowest possible value for b + static const unsigned int TOP_B = 100; //The highest possible value for b + std::vector unique; //Holds all values in powers, except repeats +public: + Problem29(); + virtual void solve(); + virtual std::string getString() const; + unsigned int getBottomA() const; + unsigned int getTopA() const; + unsigned int getBottomB() const; + unsigned int getTopB() const; + std::vector getUnique() const; +}; + +/* Results: +The number of unique values generated by a^b for 2 <= a <= 100 and 2 <= b <= 100 is 9183 +It took 1.464 seconds to solve this problem. +*/ + +#endif //PROBLEM29_HPP diff --git a/Headers/Problem3.hpp b/Headers/Problem3.hpp new file mode 100644 index 0000000..95adad9 --- /dev/null +++ b/Headers/Problem3.hpp @@ -0,0 +1,55 @@ +//ProjectEuler/C++/Headers/Problem3.hpp +//Matthew Ellison +// Created: 09-28-18 +//Modified: 07-14-19 +//The largest prime factor of 600851475143 +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + +#ifndef PROBLEM3_HPP +#define PROBLEM3_HPP + + +#include +#include +#include +#include "Problem.hpp" + + +class Problem3 : public Problem{ +private: + static uint64_t GOAL_NUMBER; //The number you are trying to find the factors of + std::vector factors; //Holds the factors of goalNumber +public: + Problem3(); + virtual void solve(); + virtual std::string getString() const; + //Returns the list of factors of the number + std::vector getFactors() const; + //Returns the largest factor of the number + uint64_t getLargestFactor() const; + //Returns the number + uint64_t getGoalNumber() const; +}; + +/* Results: +The largest factor of the number 600851475143 is 6857 +It took 46.738 milliseconds to solve this problem. +*/ + +#endif //PROBLEM3_HPP diff --git a/Headers/Problem30.hpp b/Headers/Problem30.hpp new file mode 100644 index 0000000..07fe6c0 --- /dev/null +++ b/Headers/Problem30.hpp @@ -0,0 +1,57 @@ +//ProjectEuler/C++/Headers/Problem30.hpp +//Matthew Ellison +// Created: 10-27-19 +//Modified: 10-27-19 +//Find the sum of all the numbers that can be written as the sum of the fifth powers of their digits. +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + +#ifndef PROBLEM30_HPP +#define PROBLEM30_HPP + + +#include +#include +#include +#include "Problem.hpp" + + +class Problem30 : public Problem{ +private: + static const uint64_t TOP_NUM = 1000000; //This is the largest number that will be checked + static const uint64_t BOTTOM_NUM = 2; //Start with 2 because 0 and 1 don't count + static const uint64_t POWER_RAISED = 5; //This is the power that the digits are raised to + std::vector sumOfFifthNumbers; //This is a vector of the numbers that are the sum of the fifth power of their digits + std::vector getDigits(uint64_t num); //Returns a vector with the indivitual digits of the number passed into it +public: + Problem30(); + virtual void solve(); + virtual std::string getString() const; + uint64_t getTopNum() const; //This returns the top number to be checked + std::vector getListOfSumOfFifths() const; //This returns a copy of the vector holding all the numbers that are the sum of the fifth power of their digits + uint64_t getSumOfList() const; //This returns the sum of all entries in sumOfFifthNumbers +}; + + +/* 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 280.300 milliseconds to solve this problem. +*/ + + +#endif //PROBLEM30_HPP diff --git a/Headers/Problem4.hpp b/Headers/Problem4.hpp new file mode 100644 index 0000000..2b1d0a8 --- /dev/null +++ b/Headers/Problem4.hpp @@ -0,0 +1,54 @@ +//ProjectEuler/C++/Headers/Problem4.hpp +//Matthew Ellison +// Created: 09-28-18 +//Modified: 07-14-19 +//Find the largest palindrome made from the product of two 3-digit numbers +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + +#ifndef PROBLEM4_HPP +#define PROBLEM4_HPP + + +#include +#include +#include "Problem.hpp" + + +class Problem4 : public Problem{ +private: + static int START_NUM; + static int END_NUM; + std::vector palindromes; //Holds all numbers that turn out to be palindromes +public: + Problem4(); + virtual void solve(); + virtual std::string getString() const; + //Returns the list of all palindromes + std::vector getPalindromes() const; + //Returns the largest palindrome + uint64_t getLargestPalindrome() const; +}; + + +/* Results: +The largest palindrome is 906609 +It took 31.904 milliseconds to solve this problem. +*/ + +#endif //PROBLEM4_HPP diff --git a/Headers/Problem5.hpp b/Headers/Problem5.hpp new file mode 100644 index 0000000..a75a301 --- /dev/null +++ b/Headers/Problem5.hpp @@ -0,0 +1,50 @@ +//ProjectEuler/C++/Headers/Problem5.hpp +//Matthew Ellison +// Created: 09-28-18 +//Modified: 07-14-19 +//What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20? +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + +#ifndef PROBLEM5_HPP +#define PROBLEM5_HPP + + +#include +#include +#include +#include "Problem.hpp" + + +class Problem5 : public Problem{ +private: + int smallestNum; +public: + Problem5(); + virtual void solve(); + virtual std::string getString() const; + //Returns the requested number + int getNumber() const; +}; + +/* Results: +The smallest positive number evenly divisible by all numbers 1-20 is 232792560 +It took 748.245 milliseconds to run this algorithm +*/ + +#endif //PROBLEM5_HPP diff --git a/Headers/Problem6.hpp b/Headers/Problem6.hpp new file mode 100644 index 0000000..2434e2c --- /dev/null +++ b/Headers/Problem6.hpp @@ -0,0 +1,56 @@ +//ProjectEuler/C++/Headers/Problem6.hpp +//Matthew Ellison +// Created: 09-28-18 +//Modified: 07-14-19 +//Find the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum. +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + +#ifndef PROBLEM6_HPP +#define PROBLEM6_HPP + + +#include +#include +#include "Problem.hpp" + + +class Problem6 : public Problem{ +private: + static int START_NUM; + static int END_NUM; + uint64_t sumOfSquares; //Holds the sum of the squares of all the numbers + uint64_t squareOfSum; //Holds the square of the sum of all the numbers +public: + Problem6(); + virtual void solve(); + virtual std::string getString() const; + //Returns the sum of all the squares + uint64_t getSumOfSquares() const; + //Returns the square of all of the sums + uint64_t getSquareOfSum() const; + //Returns the requested difference + uint64_t getDifference() const; +}; + +/* Result +The difference between the sum of the squares and the square of the sum of all numbers from 1-100 is 25164150 +It took 1.000 microseconds to solve this problem. +*/ + +#endif //PROBLEM6_HPP diff --git a/Headers/Problem67.hpp b/Headers/Problem67.hpp new file mode 100644 index 0000000..d28956e --- /dev/null +++ b/Headers/Problem67.hpp @@ -0,0 +1,168 @@ +//ProjectEuler/C++/Headers/Problem67.hpp +//Matthew Ellison +// Created: 11-02-18 +//Modified: 07-14-19 +//The way to do this is using a breadth first search +/* +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 +*/ +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + +#ifndef PROBLEM67_HPP +#define PROBLEM67_HPP + + +#include +#include +#include +#include "Problem.hpp" + + +class Problem67 : public Problem{ +private: + struct location{ + int xLocation; + int yLocation; + int total; + bool fromRight; + location(int x, int y, int t, bool r) : xLocation(x), yLocation(y), total(t), fromRight(r){ } + }; + //This function takes every number in the vector and changes it to 100 - the number + void invert(); + static const int NUM_ROWS = 100; //The number of rows in the list of numbers + std::list foundPoints; //For the points that I have already found the shortest distance to + std::list possiblePoints; //For the locations you are checking this round + int actualTotal; //The true total of the path from the top to the bottom + //This is the list you are trying to find a path through + static std::vector list[NUM_ROWS]; +public: + Problem67(); + virtual void solve(); + virtual std::string getString() const; + std::string getPyramid() const; //Returns the pyramid that was traversed as a string + std::string getTrail(); //Returns the trail the algorithm took as a string + int getTotal() const; //Returns the total that was asked for +}; + +/* Results: +The value of the longest path is 7273 +It took 208.728 milliseconds to solve this problem. +*/ + +#endif //PROBLEM67_HPP diff --git a/Headers/Problem7.hpp b/Headers/Problem7.hpp new file mode 100644 index 0000000..6b46d2c --- /dev/null +++ b/Headers/Problem7.hpp @@ -0,0 +1,51 @@ +//ProjectEuler/C++/Headers/Problem7.hpp +//Matthew Ellison +// Created: 09-28-18 +//Modified: 07-14-19 +//What is the 10001th prime number? +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + +#ifndef PROBLEM7_HPP +#define PROBLEM7_HPP + + +#include +#include +#include +#include "Problem.hpp" + + +class Problem7: public Problem{ +private: + static uint64_t NUMBER_OF_PRIMES; + std::vector primes; //Holds the prime numbers +public: + Problem7(); + virtual void solve(); + virtual std::string getString() const; + //Returns the requested prime number + uint64_t getPrime() const; +}; + +/* Results +The 10001th prime number is 104743 +It took 3.551 milliseconds to solve this problem. +*/ + +#endif //PROBLEM7_HPP diff --git a/Headers/Problem8.hpp b/Headers/Problem8.hpp new file mode 100644 index 0000000..5497a99 --- /dev/null +++ b/Headers/Problem8.hpp @@ -0,0 +1,78 @@ +//ProjectEuler/C++/Headers/Problem8.hpp +//Matthew Ellison +// Created: 09-28-18 +//Modified: 07-14-19 +//Find the thirteen adjacent digits in the 1000-digit number that have the greatest product. What is the value of this product? +/* +73167176531330624919225119674426574742355349194934 +96983520312774506326239578318016984801869478851843 +85861560789112949495459501737958331952853208805511 +12540698747158523863050715693290963295227443043557 +66896648950445244523161731856403098711121722383113 +62229893423380308135336276614282806444486645238749 +30358907296290491560440772390713810515859307960866 +70172427121883998797908792274921901699720888093776 +65727333001053367881220235421809751254540594752243 +52584907711670556013604839586446706324415722155397 +53697817977846174064955149290862569321978468622482 +83972241375657056057490261407972968652414535100474 +82166370484403199890008895243450658541227588666881 +16427171479924442928230863465674813919123162824586 +17866458359124566529476545682848912883142607690042 +24219022671055626321111109370544217506941658960408 +07198403850962455444362981230987879927244284909188 +84580156166097919133875499200524063689912560717606 +05886116467109405077541002256983155200055935729725 +71636269561882670428252483600823257530420752963450 +*/ +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + +#ifndef PROBLEM8_HPP +#define PROBLEM8_HPP + + +#include +#include +#include +#include "Problem.hpp" + + +class Problem8 : public Problem{ +private: + static std::string number; + std::string maxNums; //Holds the string of the largest product + uint64_t maxProduct; //Holds the largest product of 13 numbers +public: + Problem8(); + virtual void solve(); + virtual std::string getString() const; + //Returns the string of numbers that produces the largest product + std::string getLargestNums() const; + //Returns the requested product + uint64_t getLargestProduct() const; +}; + + +/* Results +The greatest product is 23514624000 +The numbers are 5576689664895 +It took 124.900 microseconds to solve this problem. +*/ + +#endif //PROBLEM8_HPP diff --git a/Headers/Problem9.hpp b/Headers/Problem9.hpp new file mode 100644 index 0000000..045fee4 --- /dev/null +++ b/Headers/Problem9.hpp @@ -0,0 +1,59 @@ +//ProjectEuler/C++/Headers/Problem9.hpp +//Matthew Ellison +// Created: 09-28-18 +//Modified: 07-14-19 +//There exists exactly one Pythagorean triplet for which a + b + c = 1000. Find the product of abc. +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + +#ifndef PROBLEM9_HPP +#define PROBLEM9_HPP + + +#include +#include +#include "Problem.hpp" + + +class Problem9 : public Problem{ +private: + int a; //Holds the position on the first side + int b; //Holds the position on the second side + double c; //Holds the hyp + bool found; //A flag to determine if we have found the solution yet +public: + Problem9(); + virtual void solve(); + virtual std::string getString() const; + //Returns the length of the first side + int getSideA() const; + //Returns the length of the second side + int getSideB() const; + //Returns the length of the hyp + int getSideC() const; + //Returns the product of the 3 sides + int getProduct() const; +}; + +/* Results: +The Pythagorean triplet is 200 375 425 +The numbers' product is 31875000 +It took 146.100 microseconds to solve this problem. +*/ + +#endif //PROBLEM9_HPP 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/Source/Problem1.cpp b/Source/Problem1.cpp new file mode 100644 index 0000000..53b987d --- /dev/null +++ b/Source/Problem1.cpp @@ -0,0 +1,86 @@ +//ProjectEuler/C++/Source/Problem1.cpp +//Matthew Ellison +// Created: 07-10-19 +//Modified: 07-10-19 +//What is the sum of all the multiples of 3 or 5 that are less than 1000 +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + + +#include +#include +#include +#include +#include "Stopwatch.hpp" +#include "../Headers/Problem.hpp" +#include "../Headers/Problem1.hpp" + + +uint64_t Problem1::MAX_NUMBER = 1000; + +Problem1::Problem1() : Problem("What is the sum of all the multiples of 3 or 5 that are less than 1000?"), fullSum(0){ + +} + +void Problem1::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + //Start the timer + timer.start(); + + //Step through every number < 1000 and see if either 3 or 5 divide it evenly + for(uint64_t cnt = 1;cnt < MAX_NUMBER;++cnt){ + //If either divides it then add it to the vector + if((cnt % 3) == 0){ + numbers.push_back(cnt); + } + else if((cnt % 5) == 0){ + numbers.push_back(cnt); + } + } + + //Get the sum of all numbers + for(uint64_t num : numbers){ + fullSum += num; + } + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem1::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + std::stringstream results; + results << "The sum of all the numbers < 1000 that are divisible by 3 or 5 is " << fullSum; + return results.str(); +} + +uint64_t Problem1::getSum() const{ + if(!solved){ + throw unsolved(); + } + return fullSum; +} diff --git a/Source/Problem10.cpp b/Source/Problem10.cpp new file mode 100644 index 0000000..cf7d575 --- /dev/null +++ b/Source/Problem10.cpp @@ -0,0 +1,74 @@ +//ProjectEuler/C++/Source/Problem10.cpp +//Matthew Ellison +// Created: 09-28-18 +//Modified: 07-14-19 +//Find the sum of all the primes below two million +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + + +#include +#include +#include +#include "Stopwatch.hpp" +#include "Algorithms.hpp" +#include "../Headers/Problem.hpp" +#include "../Headers/Problem10.hpp" + + +uint64_t Problem10::GOAL_NUMBER = 2000000; + +Problem10::Problem10() : Problem("Find the sum of all the primes below two million"), sum(0){ + +} + +void Problem10::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + //Start the timer + timer.start(); + + //Get the sum of all prime numbers < GOAL_NUMBER + sum = mee::getSum(mee::getPrimes(GOAL_NUMBER - 1)); //Subtract 1 because it is supposed to be < 2000000 + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem10::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + std::stringstream results; + results << "The sum of all the primes less than " << GOAL_NUMBER << " is " << sum; + return results.str(); +} + +uint64_t Problem10::getSum() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return sum; +} diff --git a/Source/Problem11.cpp b/Source/Problem11.cpp new file mode 100644 index 0000000..05a236f --- /dev/null +++ b/Source/Problem11.cpp @@ -0,0 +1,204 @@ +//ProjectEuler/C++/Source/Problem11.cpp +//MatthewEllison +// Created: 09-29-18 +//Modified: 07-14-19 +//What is the greatest product of four adjacent numbers in the same direction (up, down, left, right, or diagonally) in the 20×20 grid? +/* +08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08 +49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00 +81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65 +52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91 +22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80 +24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50 +32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70 +67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21 +24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72 +21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95 +78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92 +16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57 +86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58 +19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40 +04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66 +88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69 +04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36 +20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16 +20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54 +01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48 +*/ +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + + +#include +#include +#include +#include "Stopwatch.hpp" +#include "Algorithms.hpp" +#include "../Headers/Problem.hpp" +#include "../Headers/Problem11.hpp" + + +std::vector Problem11::grid[20] = {{ 8, 02, 22, 97, 38, 15, 00, 40, 00, 75, 04, 05, 07, 78, 52, 12, 50, 77, 91, 8}, + {49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48, 04, 56, 62, 00}, + {81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30, 03, 49, 13, 36, 65}, + {52, 70, 95, 23, 04, 60, 11, 42, 69, 24, 68, 56, 01, 32, 56, 71, 37, 02, 36, 91}, + {22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80}, + {24, 47, 32, 60, 99, 03, 45, 02, 44, 75, 33, 53, 78, 36, 84, 20, 35, 17, 12, 50}, + {32, 98, 81, 28, 64, 23, 67, 10, 26, 38, 40, 67, 59, 54, 70, 66, 18, 38, 64, 70}, + {67, 26, 20, 68, 02, 62, 12, 20, 95, 63, 94, 39, 63, 8, 40, 91, 66, 49, 94, 21}, + {24, 55, 58, 05, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72}, + {21, 36, 23, 9, 75, 00, 76, 44, 20, 45, 35, 14, 00, 61, 33, 97, 34, 31, 33, 95}, + {78, 17, 53, 28, 22, 75, 31, 67, 15, 94, 03, 80, 04, 62, 16, 14, 9, 53, 56, 92}, + {16, 39, 05, 42, 96, 35, 31, 47, 55, 58, 88, 24, 00, 17, 54, 24, 36, 29, 85, 57}, + {86, 56, 00, 48, 35, 71, 89, 07, 05, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58}, + {19, 80, 81, 68, 05, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77, 04, 89, 55, 40}, + {04, 52, 8, 83, 97, 35, 99, 16, 07, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66}, + {88, 36, 68, 87, 57, 62, 20, 72, 03, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69}, + {04, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18, 8, 46, 29, 32, 40, 62, 76, 36}, + {20, 69, 36, 41, 72, 30, 23, 88, 34, 62, 99, 69, 82, 67, 59, 85, 74, 04, 36, 16}, + {20, 73, 35, 29, 78, 31, 90, 01, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57, 05, 54}, + {01, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52, 01, 89, 19, 67, 48}}; + +Problem11::Problem11() : Problem("What is the greatest product of four adjacent numbers in the same direction (up, down, left, right, or diagonally) in the 20x20 grid?"){ + +} + +void Problem11::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + std::vector currentProduct; //This is a vector containing the numbers we are working on right now + //Make sure both vectors have 4 slots + for(int cnt = 0;cnt < 4;++cnt){ + greatestProduct.push_back(0); + currentProduct.push_back(0); + } + + //Start the timer + timer.start(); + + //Loop through every row and column + for(unsigned int row = 0;row < 20;++row){ + for(unsigned int col = 0;col < grid[row].size();++col){ + bool left = false; + bool right = false; + bool down = false; + + //Check which direction you will be able to move + ///This used to be (col - 3) >= 1 which was more clear (When col was an int instead of an unsigned int) + ///We just need to make sure col is large enough for us to be able to look left + if(col >= 4){ + left = true; + } + if((col + 3) < grid[row].size()){ + right = true; + } + if((row + 3) < 20){ + down = true; + } + + //Check the directions you are able to go + //Right + if(right){ + //Fill the product + currentProduct.at(0) = grid[row].at(col); + currentProduct.at(1) = grid[row].at(col + 1); + currentProduct.at(2) = grid[row].at(col + 2); + currentProduct.at(3) = grid[row].at(col + 3); + + //If the current numbers' product is greater than the greatest product replace it + if(mee::getProduct(currentProduct) > mee::getProduct(greatestProduct)){ + greatestProduct = currentProduct; + } + } + //Down + if(down){ + //Fill the product + currentProduct.at(0) = grid[row].at(col); + currentProduct.at(1) = grid[row + 1].at(col); + currentProduct.at(2) = grid[row + 2].at(col); + currentProduct.at(3) = grid[row + 3].at(col); + + //If the current numbers' product is greater than the greatest product replace it + if(mee::getProduct(currentProduct) > mee::getProduct(greatestProduct)){ + greatestProduct = currentProduct; + } + } + //LeftDown + if(left && down){ + //Fill the product + currentProduct.at(0) = grid[row].at(col); + currentProduct.at(1) = grid[row + 1].at(col - 1); + currentProduct.at(2) = grid[row + 2].at(col - 2); + currentProduct.at(3) = grid[row + 3].at(col - 3); + + //If the current numbers' product is greater than the greatest product replace it + if(mee::getProduct(currentProduct) > mee::getProduct(greatestProduct)){ + greatestProduct = currentProduct; + } + } + //RightDown + if(right && down){ + //Fill the product + currentProduct.at(0) = grid[row].at(col); + currentProduct.at(1) = grid[row + 1].at(col + 1); + currentProduct.at(2) = grid[row + 2].at(col + 2); + currentProduct.at(3) = grid[row + 3].at(col + 3); + + //If the current numbers' product is greater than the greatest product replace it + if(mee::getProduct(currentProduct) > mee::getProduct(greatestProduct)){ + greatestProduct = currentProduct; + } + } + } + } + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem11::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + std::stringstream results; + results << "The greatest product of 4 number in a line is " << mee::getProduct(greatestProduct) + << "\nThe numbers are " << greatestProduct.at(0) << ' ' << greatestProduct.at(1) << ' ' << greatestProduct.at(2) << ' ' << greatestProduct.at(3); + return results.str(); +} + +std::vector Problem11::getNumbers() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return greatestProduct; +} + +int Problem11::getProduct() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return mee::getProduct(greatestProduct); +} diff --git a/Source/Problem12.cpp b/Source/Problem12.cpp new file mode 100644 index 0000000..da0cf2b --- /dev/null +++ b/Source/Problem12.cpp @@ -0,0 +1,111 @@ +//ProjectEuler/C++/Source/Problem12.cpp +//Matthew Ellison +// Created: 09-27-18 +//Modified: 07-14-19 +//What is the value of the first triangle number to have over five hundred divisors? +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* 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 . +*/ + +#include +#include +#include +#include +#include "Stopwatch.hpp" +#include "Algorithms.hpp" +#include "../Headers/Problem.hpp" +#include "../Headers/Problem12.hpp" + + +uint64_t Problem12::GOAL_DIVISORS = 500; + +Problem12::Problem12() : Problem("What is the value of the first triangle number to have over five hundred divisors?"), sum(1), counter(2){ + +} + +void Problem12::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + + //Setup your variables + bool foundNumber = false; //To flag whether the number has been found + + //Start the timer + timer.start(); + + while(!foundNumber){ + divisors = mee::getDivisors(sum); + //If the number of divisors is correct set the flag. It must be > 500 + if(divisors.size() > GOAL_DIVISORS){ + foundNumber = true; + } + //Otherwise add to the sum and increase the next numeber + else{ + sum += counter; + ++counter; + } + } + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem12::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + std::stringstream results; + results << "The triangular number " << sum << " is a sum of all numbers >= " << counter - 1 << " and has " << divisors.size() << " divisors"; + return results.str(); +} + +int64_t Problem12::getTriangularNumber() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return sum; +} + +int64_t Problem12::getLastNumberAdded() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return counter - 1; +} + +std::vector Problem12::getDivisorsOfTriangularNumber() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return divisors; +} + +size_t Problem12::getNumberOfDivisors() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return divisors.size(); +} diff --git a/Source/Problem13.cpp b/Source/Problem13.cpp new file mode 100644 index 0000000..b7ca8fc --- /dev/null +++ b/Source/Problem13.cpp @@ -0,0 +1,295 @@ +//ProjectEuler/C++/Source/Problem13.cpp +//Matthew Ellison +// Created: 09-29-18 +//Modified: 07-14-19 +//Work out the first ten digits of the sum of the following one-hundred 50-digit numbers +/* +37107287533902102798797998220837590246510135740250 +46376937677490009712648124896970078050417018260538 +74324986199524741059474233309513058123726617309629 +91942213363574161572522430563301811072406154908250 +23067588207539346171171980310421047513778063246676 +89261670696623633820136378418383684178734361726757 +28112879812849979408065481931592621691275889832738 +44274228917432520321923589422876796487670272189318 +47451445736001306439091167216856844588711603153276 +70386486105843025439939619828917593665686757934951 +62176457141856560629502157223196586755079324193331 +64906352462741904929101432445813822663347944758178 +92575867718337217661963751590579239728245598838407 +58203565325359399008402633568948830189458628227828 +80181199384826282014278194139940567587151170094390 +35398664372827112653829987240784473053190104293586 +86515506006295864861532075273371959191420517255829 +71693888707715466499115593487603532921714970056938 +54370070576826684624621495650076471787294438377604 +53282654108756828443191190634694037855217779295145 +36123272525000296071075082563815656710885258350721 +45876576172410976447339110607218265236877223636045 +17423706905851860660448207621209813287860733969412 +81142660418086830619328460811191061556940512689692 +51934325451728388641918047049293215058642563049483 +62467221648435076201727918039944693004732956340691 +15732444386908125794514089057706229429197107928209 +55037687525678773091862540744969844508330393682126 +18336384825330154686196124348767681297534375946515 +80386287592878490201521685554828717201219257766954 +78182833757993103614740356856449095527097864797581 +16726320100436897842553539920931837441497806860984 +48403098129077791799088218795327364475675590848030 +87086987551392711854517078544161852424320693150332 +59959406895756536782107074926966537676326235447210 +69793950679652694742597709739166693763042633987085 +41052684708299085211399427365734116182760315001271 +65378607361501080857009149939512557028198746004375 +35829035317434717326932123578154982629742552737307 +94953759765105305946966067683156574377167401875275 +88902802571733229619176668713819931811048770190271 +25267680276078003013678680992525463401061632866526 +36270218540497705585629946580636237993140746255962 +24074486908231174977792365466257246923322810917141 +91430288197103288597806669760892938638285025333403 +34413065578016127815921815005561868836468420090470 +23053081172816430487623791969842487255036638784583 +11487696932154902810424020138335124462181441773470 +63783299490636259666498587618221225225512486764533 +67720186971698544312419572409913959008952310058822 +95548255300263520781532296796249481641953868218774 +76085327132285723110424803456124867697064507995236 +37774242535411291684276865538926205024910326572967 +23701913275725675285653248258265463092207058596522 +29798860272258331913126375147341994889534765745501 +18495701454879288984856827726077713721403798879715 +38298203783031473527721580348144513491373226651381 +34829543829199918180278916522431027392251122869539 +40957953066405232632538044100059654939159879593635 +29746152185502371307642255121183693803580388584903 +41698116222072977186158236678424689157993532961922 +62467957194401269043877107275048102390895523597457 +23189706772547915061505504953922979530901129967519 +86188088225875314529584099251203829009407770775672 +11306739708304724483816533873502340845647058077308 +82959174767140363198008187129011875491310547126581 +97623331044818386269515456334926366572897563400500 +42846280183517070527831839425882145521227251250327 +55121603546981200581762165212827652751691296897789 +32238195734329339946437501907836945765883352399886 +75506164965184775180738168837861091527357929701337 +62177842752192623401942399639168044983993173312731 +32924185707147349566916674687634660915035914677504 +99518671430235219628894890102423325116913619626622 +73267460800591547471830798392868535206946944540724 +76841822524674417161514036427982273348055556214818 +97142617910342598647204516893989422179826088076852 +87783646182799346313767754307809363333018982642090 +10848802521674670883215120185883543223812876952786 +71329612474782464538636993009049310363619763878039 +62184073572399794223406235393808339651327408011116 +66627891981488087797941876876144230030984490851411 +60661826293682836764744779239180335110989069790714 +85786944089552990653640447425576083659976645795096 +66024396409905389607120198219976047599490197230297 +64913982680032973156037120041377903785566085089252 +16730939319872750275468906903707539413042652315011 +94809377245048795150954100921645863754710598436791 +78639167021187492431995700641917969777599028300699 +15368713711936614952811305876380278410754449733078 +40789923115535562561142322423255033685442488917353 +44889911501440648020369068063960672322193204149535 +41503128880339536053299340368006977710650566631954 +81234880673210146739058568557934581403627822703280 +82616570773948327592232845941706525094512325230608 +22918802058777319719839450180888072429661980811197 +77158542502016545090413245809786882778948721859617 +72107838435069186155435662884062257473692284509516 +20849603980134001723930671666823555245252804609722 +53503534226472524250874054075591789781264330331690 +*/ +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +//This file contains a header from the gmp library. The library is used for large integers. +//You can find more information about them at https://gmplib.org/ +//When compiling this file you need to have the gmp library installed as well as linking the libraries to your executable using the -lgmpxx and -lgmp flags +/* + 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 . +*/ + + +#include +#include +#include +#include +#include "gmpxx.h" //This is part of the gmp library +#include "Stopwatch.hpp" +#include "Algorithms.hpp" +#include "../Headers/Problem.hpp" +#include "../Headers/Problem13.hpp" + + +std::vector Problem13::nums; + +Problem13::Problem13() : Problem("Work out the first ten digits of the sum of the one-hundred 50-digit numbers"), sum(0){ + //Make sure the vector is the correct size + nums.reserve(100); + nums.resize(100); + //Set the numbers + nums[0] = "37107287533902102798797998220837590246510135740250"; + nums[1] = "46376937677490009712648124896970078050417018260538"; + nums[2] = "74324986199524741059474233309513058123726617309629"; + nums[3] = "91942213363574161572522430563301811072406154908250"; + nums[4] = "23067588207539346171171980310421047513778063246676"; + nums[5] = "89261670696623633820136378418383684178734361726757"; + nums[6] = "28112879812849979408065481931592621691275889832738"; + nums[7] = "44274228917432520321923589422876796487670272189318"; + nums[8] = "47451445736001306439091167216856844588711603153276"; + nums[9] = "70386486105843025439939619828917593665686757934951"; + nums[10] = "62176457141856560629502157223196586755079324193331"; + nums[11] = "64906352462741904929101432445813822663347944758178"; + nums[12] = "92575867718337217661963751590579239728245598838407"; + nums[13] = "58203565325359399008402633568948830189458628227828"; + nums[14] = "80181199384826282014278194139940567587151170094390"; + nums[15] = "35398664372827112653829987240784473053190104293586"; + nums[16] = "86515506006295864861532075273371959191420517255829"; + nums[17] = "71693888707715466499115593487603532921714970056938"; + nums[18] = "54370070576826684624621495650076471787294438377604"; + nums[19] = "53282654108756828443191190634694037855217779295145"; + nums[20] = "36123272525000296071075082563815656710885258350721"; + nums[21] = "45876576172410976447339110607218265236877223636045"; + nums[22] = "17423706905851860660448207621209813287860733969412"; + nums[23] = "81142660418086830619328460811191061556940512689692"; + nums[24] = "51934325451728388641918047049293215058642563049483"; + nums[25] = "62467221648435076201727918039944693004732956340691"; + nums[26] = "15732444386908125794514089057706229429197107928209"; + nums[27] = "55037687525678773091862540744969844508330393682126"; + nums[28] = "18336384825330154686196124348767681297534375946515"; + nums[29] = "80386287592878490201521685554828717201219257766954"; + nums[30] = "78182833757993103614740356856449095527097864797581"; + nums[31] = "16726320100436897842553539920931837441497806860984"; + nums[32] = "48403098129077791799088218795327364475675590848030"; + nums[33] = "87086987551392711854517078544161852424320693150332"; + nums[34] = "59959406895756536782107074926966537676326235447210"; + nums[35] = "69793950679652694742597709739166693763042633987085"; + nums[36] = "41052684708299085211399427365734116182760315001271"; + nums[37] = "65378607361501080857009149939512557028198746004375"; + nums[38] = "35829035317434717326932123578154982629742552737307"; + nums[39] = "94953759765105305946966067683156574377167401875275"; + nums[40] = "88902802571733229619176668713819931811048770190271"; + nums[41] = "25267680276078003013678680992525463401061632866526"; + nums[42] = "36270218540497705585629946580636237993140746255962"; + nums[43] = "24074486908231174977792365466257246923322810917141"; + nums[44] = "91430288197103288597806669760892938638285025333403"; + nums[45] = "34413065578016127815921815005561868836468420090470"; + nums[46] = "23053081172816430487623791969842487255036638784583"; + nums[47] = "11487696932154902810424020138335124462181441773470"; + nums[48] = "63783299490636259666498587618221225225512486764533"; + nums[49] = "67720186971698544312419572409913959008952310058822"; + nums[50] = "95548255300263520781532296796249481641953868218774"; + nums[51] = "76085327132285723110424803456124867697064507995236"; + nums[52] = "37774242535411291684276865538926205024910326572967"; + nums[53] = "23701913275725675285653248258265463092207058596522"; + nums[54] = "29798860272258331913126375147341994889534765745501"; + nums[55] = "18495701454879288984856827726077713721403798879715"; + nums[56] = "38298203783031473527721580348144513491373226651381"; + nums[57] = "34829543829199918180278916522431027392251122869539"; + nums[58] = "40957953066405232632538044100059654939159879593635"; + nums[59] = "29746152185502371307642255121183693803580388584903"; + nums[60] = "41698116222072977186158236678424689157993532961922"; + nums[61] = "62467957194401269043877107275048102390895523597457"; + nums[62] = "23189706772547915061505504953922979530901129967519"; + nums[63] = "86188088225875314529584099251203829009407770775672"; + nums[64] = "11306739708304724483816533873502340845647058077308"; + nums[65] = "82959174767140363198008187129011875491310547126581"; + nums[66] = "97623331044818386269515456334926366572897563400500"; + nums[67] = "42846280183517070527831839425882145521227251250327"; + nums[68] = "55121603546981200581762165212827652751691296897789"; + nums[69] = "32238195734329339946437501907836945765883352399886"; + nums[70] = "75506164965184775180738168837861091527357929701337"; + nums[71] = "62177842752192623401942399639168044983993173312731"; + nums[72] = "32924185707147349566916674687634660915035914677504"; + nums[73] = "99518671430235219628894890102423325116913619626622"; + nums[74] = "73267460800591547471830798392868535206946944540724"; + nums[75] = "76841822524674417161514036427982273348055556214818"; + nums[76] = "97142617910342598647204516893989422179826088076852"; + nums[77] = "87783646182799346313767754307809363333018982642090"; + nums[78] = "10848802521674670883215120185883543223812876952786"; + nums[79] = "71329612474782464538636993009049310363619763878039"; + nums[80] = "62184073572399794223406235393808339651327408011116"; + nums[81] = "66627891981488087797941876876144230030984490851411"; + nums[82] = "60661826293682836764744779239180335110989069790714"; + nums[83] = "85786944089552990653640447425576083659976645795096"; + nums[84] = "66024396409905389607120198219976047599490197230297"; + nums[85] = "64913982680032973156037120041377903785566085089252"; + nums[86] = "16730939319872750275468906903707539413042652315011"; + nums[87] = "94809377245048795150954100921645863754710598436791"; + nums[88] = "78639167021187492431995700641917969777599028300699"; + nums[89] = "15368713711936614952811305876380278410754449733078"; + nums[90] = "40789923115535562561142322423255033685442488917353"; + nums[91] = "44889911501440648020369068063960672322193204149535"; + nums[92] = "41503128880339536053299340368006977710650566631954"; + nums[93] = "81234880673210146739058568557934581403627822703280"; + nums[94] = "82616570773948327592232845941706525094512325230608"; + nums[95] = "22918802058777319719839450180888072429661980811197"; + nums[96] = "77158542502016545090413245809786882778948721859617"; + nums[97] = "72107838435069186155435662884062257473692284509516"; + nums[98] = "20849603980134001723930671666823555245252804609722"; + nums[99] = "53503534226472524250874054075591789781264330331690"; +} + +void Problem13::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + + //Start the timer + timer.start(); + + //Get the sum of all the numbers + sum = mee::getSum(nums); + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem13::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + + std::stringstream results; + results << "The sum of all " << nums.size() << " numbers is " << sum + << "\nThe first 10 digits of the sum of the numbers is " << sum.get_str().substr(0, 10); + return results.str(); +} + +std::vector Problem13::getNumbers() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return nums; +} + +mpz_class Problem13::getSum() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return sum; +} diff --git a/Source/Problem14.cpp b/Source/Problem14.cpp new file mode 100644 index 0000000..1a52dd7 --- /dev/null +++ b/Source/Problem14.cpp @@ -0,0 +1,111 @@ +//ProjectEuler/C++/Source/Problem14.cpp +//Matthew Ellison +// Created: 09-29-18 +//Modified: 07-14-19 +/* +The following iterative sequence is defined for the set of positive integers: +n → n/2 (n is even) +n → 3n + 1 (n is odd) +Which starting number, under one million, produces the longest chain? +*/ +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + + +#include +#include +#include +#include "Stopwatch.hpp" +#include "../Headers/Problem.hpp" +#include "../Headers/Problem14.hpp" + + +uint64_t Problem14::MAX_NUM = 1000000; + +uint64_t Problem14::checkSeries(uint64_t num){ + uint64_t length = 1; //Start at 1 because you need to count the starting number + + //Follow the series, adding 1 for each step you take + while(num > 1){ + if((num % 2) == 0){ + num /= 2; + } + else{ + num = (3 * num) + 1; + } + ++length; + } + return length; +} + +Problem14::Problem14() : Problem("Which starting number, under one million, produces the longest chain using the itterative sequence?"), maxLength(0), maxNum(0){ + +} + +void Problem14::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + + //Start the timer + timer.start(); + + //Loop through all numbers less than 1000000 and check them agains the series + for(uint64_t currentNum = 1;currentNum < MAX_NUM;++currentNum){ + uint64_t currentLength = checkSeries(currentNum); + //If the current number has a longer series than the max then the current becomes the max + if(currentLength > maxLength){ + maxLength = currentLength; + maxNum = currentNum; + } + } + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem14::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + + std::stringstream results; + results << "The number " << maxNum << " produced a chain of " << maxLength << " steps"; + return results.str(); +} + +uint64_t Problem14::getLength() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return maxLength; +} + +uint64_t Problem14::getStartingNumber() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return maxNum; +} diff --git a/Source/Problem15.cpp b/Source/Problem15.cpp new file mode 100644 index 0000000..2b9bc5d --- /dev/null +++ b/Source/Problem15.cpp @@ -0,0 +1,99 @@ +//ProjectEuler/C++/Source/Problem15.hpp +//Matthew Ellison +// Created: 09-29-18 +//Modified: 07-14-19 +//How many routes from the top left corner to the bottom right corner are there through a 20×20 grid if you can only move right and down? +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + + +#include +#include +#include +#include "Stopwatch.hpp" +#include "../Headers/Problem.hpp" +#include "../Headers/Problem15.hpp" + + +int Problem15::WIDTH = 20; +int Problem15::LENGTH = 20; + +void Problem15::move(int currentX, int currentY, uint64_t& numOfRoutes){ + //Check if you are at the end + if((currentX == WIDTH) && (currentY == LENGTH)){ + ++numOfRoutes; + return; + } + + //Move right if possible + if(currentX < WIDTH){ + move(currentX + 1, currentY, numOfRoutes); + } + + //Move down if possible + if(currentY < LENGTH){ + move(currentX, currentY + 1, numOfRoutes); + } +} + +Problem15::Problem15() : Problem("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?"), numOfRoutes(0){ + +} + +void Problem15::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + + //Setup the variables + int currentX = 0; //The current x location on the grid + int currentY = 0; //The current y location on the grid + + //Start the timer + timer.start(); + + //We write this as a recursive function + //When in a location it always moves right first, then down + move(currentX, currentY, numOfRoutes); + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem15::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + + std::stringstream results; + results << "The number of routes is " << numOfRoutes; + return results.str(); +} + +uint64_t Problem15::getNumberOfRoutes() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return numOfRoutes; +} diff --git a/Source/Problem16.cpp b/Source/Problem16.cpp new file mode 100644 index 0000000..057c247 --- /dev/null +++ b/Source/Problem16.cpp @@ -0,0 +1,97 @@ +//ProjectEuler/C++/Source/Problem16.cpp +//Matthew Ellison +// Created: 09-28-18 +//Modified: 07-14-19 +//What is the sum of the digits of the number 2^1000? +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +//This file contains a header from the gmp library. The library is used for large integers. +//You can find more information about them at https://gmplib.org/ +//When compiling this file you need to have the gmp library installed as well as linking the libraries to your executable using the -lgmpxx and -lgmp flags +/* + 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 . +*/ + +#include +#include +#include +#include "Stopwatch.hpp" +#include "../Headers/Problem.hpp" +#include "../Headers/Problem16.hpp" + + +int Problem16::NUM_TO_POWER = 2; //The number that is going to be raised to a power +int Problem16::POWER = 1000; //The power that the number is going to be raised to + +Problem16::Problem16() : Problem("What is the sum of the digits of the number 2^1000?"), num(0), sumOfElements(0){ + +} + +void Problem16::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + + //Start the timer + timer.start(); + + //Get the number + mpz_ui_pow_ui(num.get_mpz_t(), NUM_TO_POWER, POWER); + + //Get a string of the number + std::string numString = num.get_str(); + + //Add up the individual characters of the string + for(char number : numString){ + std::string tempString; + tempString += number; + sumOfElements += std::stoi(tempString); + } + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem16::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + + std::stringstream results; + results << NUM_TO_POWER << '^' << POWER << " = " << num + << "\nThe sum of the elements is " << sumOfElements; + return results.str(); +} + +mpz_class Problem16::getNumber() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return num; +} + +int Problem16::getSum() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return sumOfElements; +} diff --git a/Source/Problem17.cpp b/Source/Problem17.cpp new file mode 100644 index 0000000..64c6e15 --- /dev/null +++ b/Source/Problem17.cpp @@ -0,0 +1,212 @@ +//ProjectEuler/C++/Source/Problem17.cpp +//Matthew Ellison +// Created: 10-05-18 +//Modified: 07-14-19 +//If all the numbers from 1 to 1000 (one thousand) inclusive were written out in words, how many letters would be used? +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + + +#include +#include +#include +#include "Stopwatch.hpp" +#include "../Headers/Problem.hpp" +#include "../Headers/Problem17.hpp" + + +int Problem17::TOP_NUM = 1000; + +Problem17::Problem17() : Problem("If all the numbers from 1 to 1000 inclusive were written out in words, how many letters would be used?"), letterCount(0){ + +} + +std::string Problem17::makeWord(int num){ + int currentDivider = 1000; + int currentNum; + bool teen = false; + std::string word = ""; + std::string currentWord = ""; + + + //Start at thousands + currentNum = num / currentDivider; + if(currentNum > 0 && num != 0){ + num -= currentNum * currentDivider; + currentWord = wordHelper(currentNum); + word += currentWord + " thousand "; + currentWord = ""; + } + + //Check for hundreds + currentDivider /= 10; + currentNum = num / currentDivider; + if(currentNum > 0 && num != 0){ + num -= currentNum * currentDivider; + currentWord = wordHelper(currentNum); + word += currentWord + " hundred "; + currentWord = ""; + } + + //Insert an and if there is a reason + if(word != "" && num > 0){ + word += " and "; + } + + //Check for double digits + currentDivider /= 10; + currentNum = num / currentDivider; + if(currentNum > 0 && num != 0){ + num -= currentNum * currentDivider; + currentWord = wordHelper(currentNum); + } + if(currentWord != ""){ + //For specialty numbers + if(currentNum == 8){ + word += "eighty "; + } + else if(currentNum == 5){ + word += "fifty "; + } + else if(currentNum == 4){ + word += "forty "; + } + else if(currentNum == 3){ + word += "thirty "; + } + else if(currentNum == 2){ + word += "twenty "; + } + //For teens + else if(currentNum == 1){ + if(num == 8){ + word += "eighteen"; + num = 0; + } + else if(num == 5){ + word += "fifteen"; + num = 0; + } + else if(num == 3){ + word += "thirteen"; + num = 0; + } + else if(num == 2){ + word += "twelve"; + num = 0; + } + else if(num == 1){ + word += "eleven"; + num = 0; + } + else if(num == 0){ + word += "ten"; + num = 0; + } + else{ + teen = true; + } + } + //For all other numbers > 30 + else{ + word += currentWord + "ty "; + } + currentWord = ""; + } + //Check for single digits + currentDivider /= 10; + currentNum = num / currentDivider; + if(currentNum > 0 && num != 0){ + num -= currentNum * currentDivider; + currentWord = wordHelper(currentNum); + word += currentWord; + if(teen){ + word += "teen"; + } + } + + return word; +} + +std::string Problem17::wordHelper(int num){ + std::string tempString; + switch(num){ + case 9: tempString += "nine"; break; + case 8: tempString += "eight"; break; + case 7: tempString += "seven"; break; + case 6: tempString += "six"; break; + case 5: tempString += "five"; break; + case 4: tempString += "four"; break; + case 3: tempString += "three"; break; + case 2: tempString += "two"; break; + case 1: tempString += "one"; break; + default: tempString += "ERROR"; break; + } + return tempString; +} + +uint64_t Problem17::countLetters(std::string str){ + uint64_t letterCount = 0; + //Step through every character in the string and count how many letters there are + for(unsigned int cnt = 0;cnt < str.size();++cnt){ + if(isalpha(str.at(cnt))){ + ++letterCount; + } + } + return letterCount; +} + +void Problem17::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + + //Start the timer + timer.start(); + + //Step through every element in nums and get the word representations of the numbers + for(int cnt = 1;cnt <= TOP_NUM;++cnt){ + std::string words = makeWord(cnt); //Get the words of each number in turn + letterCount += countLetters(words); //Add the number of letters to the running tally + } + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem17::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + std::stringstream results; + results << "The number of letters is " << letterCount; + return results.str(); +} + +uint64_t Problem17::getLetterCount() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return letterCount; +} diff --git a/Source/Problem18.cpp b/Source/Problem18.cpp new file mode 100644 index 0000000..e443f47 --- /dev/null +++ b/Source/Problem18.cpp @@ -0,0 +1,226 @@ +//ProjectEuler/C++/Source/Problem18.hpp +//Matthew Ellison +// Created: 11-01-18 +//Modified: 07-14-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 +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + + +#include +#include +#include +#include +#include "Stopwatch.hpp" +#include "../Headers/Problem18.hpp" + + +std::vector Problem18::list[NUM_ROWS] = + {{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, 9, 70, 98, 73, 93, 38, 53, 60, 04, 23}}; + +Problem18::Problem18() : Problem("Find the maximum total from the top to the bottom of the pyramid."), actualTotal(0){ + //The method that I am using looks for the smallest numbers, so I need to invert the numbers in this list + invert(); + //Now l[i][j] == 100 - l[i][j]; + //Add the top point because that is already the only path + foundPoints.emplace_back(0, 0, list[0][0], false); + //Add the second row as possible points + possiblePoints.emplace_back(0, 1, (list[0][0] + list[1][0]), true); + possiblePoints.emplace_back(1, 1, (list[0][0] + list[1][1]), false); +} + +void Problem18::invert(){ + for(unsigned int rowCnt = 0;rowCnt < NUM_ROWS;++rowCnt){ + for(unsigned int colCnt = 0;colCnt < list[rowCnt].size();++colCnt){ + list[rowCnt][colCnt] = 100 - list[rowCnt][colCnt]; + } + } +} + +void Problem18::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + + //Start the timer + timer.start(); + + bool foundBottom = false; //Used when you find a point at the bottom + + //Loop until you find the bottom + while(!foundBottom){ + //Check which possible point gives us the lowest number. If more than one has the same number simply keep the first one + location minLoc = possiblePoints.front(); + for(location loc : possiblePoints){ + if(loc.total < minLoc.total){ + minLoc = loc; + } + } + + //Remove it from the list of possible points + possiblePoints.remove_if([minLoc](location loc){return (loc.xLocation == minLoc.xLocation) &&(loc.yLocation == minLoc.yLocation);}); + + foundPoints.push_back(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 + int xLoc = minLoc.xLocation; + int yLoc = minLoc.yLocation + 1; //Add one because you will always be moving to the next row + if(yLoc >= NUM_ROWS){ + foundBottom = true; + } + else{ + possiblePoints.emplace_back(xLoc, yLoc, minLoc.total + list[yLoc][xLoc], true); + ++xLoc; //Advance the x location to simulate going right + possiblePoints.emplace_back(xLoc, yLoc, minLoc.total + list[yLoc][xLoc], false); + } + } + + actualTotal = ((100 * NUM_ROWS) - foundPoints.back().total); //Change the minimum to the maximum + invert(); //Invert the list again so that it is back to it's original form + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem18::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + + std::stringstream results; + results << "The value of the longest path is " << actualTotal; + return results.str(); +} + +std::string Problem18::getPyramid(){ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + std::stringstream results; + + //Print the triangle list of numbers + for(unsigned int rowCnt = 0;rowCnt < NUM_ROWS;++rowCnt){ + for(unsigned int colCnt = 0;colCnt < list[rowCnt].size();++colCnt){ + results << std::setw(2) << list[rowCnt][colCnt] << ' '; + } + } + return results.str(); +} + +std::string Problem18::getTrail(){ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + + std::stringstream results; + //Print the trail the algorithm took + std::list trail; + trail.push_front(foundPoints.back()); + bool top = false; + while(!top){ + bool found = false; + int loc = foundPoints.size() - 1; + std::list::iterator toAdd = foundPoints.begin(); + while(!found){ + if(loc < 0){ + results << "Error: Location < 0\n"; + exit(1); + } + std::list::iterator it = foundPoints.begin(); + std::advance(it, loc); + if(trail.front().fromRight){ + if((it->xLocation == trail.begin()->xLocation) && (it->yLocation == (trail.begin()->yLocation - 1))){ + found = true; + toAdd = it; + } + else{ + --loc; + } + } + else{ + if((it->xLocation == (trail.begin()->xLocation - 1)) && (it->yLocation == (trail.begin()->yLocation - 1))){ + found = true; + toAdd = it; + } + else{ + --loc; + } + } + } + + + trail.push_front(*toAdd); + + if(trail.begin()->yLocation == 0){ + top = true; + } + } + + for(location loc : trail){ + results << list[loc.yLocation][loc.xLocation] << "->"; + } + return results.str(); +} + +int Problem18::getTotal() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return actualTotal; +} diff --git a/Source/Problem19.cpp b/Source/Problem19.cpp new file mode 100644 index 0000000..ab0cfa6 --- /dev/null +++ b/Source/Problem19.cpp @@ -0,0 +1,191 @@ +//ProjectEuler/C++/Source/Problem19.cpp +//Matthew Ellison +// Created: 09-28-18 +//Modified: 07-14-19 +//How many Sundays fell on the first of the month during the twentieth century (1 Jan 1901 to 31 Dec 2000)? +/* +You are given the following information, but you may prefer to do some research for yourself. +1 Jan 1900 was a Monday. +Thirty days has September, +April, June and November. +All the rest have thirty-one, +Saving February alone, +Which has twenty-eight, rain or shine. +And on leap years, twenty-nine. +A leap year occurs on any year evenly divisible by 4, but not on a century unless it is divisible by 400. +*/ +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + + +#include +#include +#include +#include "Stopwatch.hpp" +#include "../Headers/Problem19.hpp" + + +unsigned int Problem19::START_YEAR = 1901; //The start year +unsigned int Problem19::END_YEAR = 2000; //The stop year + +Problem19::Problem19() : Problem("How many Sundays fell on the first of the month during the twentieth century (1 Jan 1901 to 31 Dec 2000)?"), totalSundays(0){ + +} + +Problem19::DAYS Problem19::getDay(unsigned int month, unsigned int day, unsigned int year){ + //Make sure the numbers are within propper bounds + if((month < 1) || (month > 12) || (day < 1) || (day > 31) || (year < 1)){ + return ERROR; + } + uint64_t numDays = 0; //The number of days between 01-01-0001 and the date given (Saturday) + unsigned int currentYear, currentMonth, currentDay; + currentYear = 1; + currentMonth = 1; + currentDay = SATURDAY; + --day; + + //Add the correct number of days for every year + while(currentYear < year){ + if(isLeapYear(currentYear)){ + numDays += 366; + } + else{ + numDays += 365; + } + ++currentYear; + } + //Add the correct number of days for every month + while(currentMonth < month){ + //31 day months + if(currentMonth == 2){ + if(isLeapYear(currentYear)){ + numDays += 29; + } + else{ + numDays += 28; + } + } + else if((currentMonth == 1) || (currentMonth == 3) || (currentMonth == 5) || (currentMonth == 7) || (currentMonth == 8) || (currentMonth == 10) || (currentMonth == 12)){ + numDays += 31; + } + else{ + numDays += 30; + } + ++currentMonth; + } + //Account for the weird year of 1752 + if(year > 1752){ + numDays -= 11; + } + else if(year == 1752){ + if(month > 9){ + numDays -= 11; + } + else if(month == 9){ + if(day >= 14){ + numDays -= 11; + } + //Days 3-13 were skipped that year + else if((day > 2) && (day < 14)){ + return ERROR; + } + } + } + //Add the correct number of days for every day + numDays += day; + + currentDay += numDays; + currentDay = currentDay % NUMBER_OF_DAYS; + switch(currentDay){ + case SUNDAY: return SUNDAY; + case MONDAY: return MONDAY; + case TUESDAY: return TUESDAY; + case WEDNESDAY: return WEDNESDAY; + case THURSDAY: return THURSDAY; + case FRIDAY: return FRIDAY; + case SATURDAY: return SATURDAY; + default: return ERROR; + } +} + +bool Problem19::isLeapYear(unsigned int year){ + if(year < 1){ + return false; + } + else if((year % 100) == 0){ + //This rule only applies at and after 1800 + if(year <= 1700){ + return true; + } + else if((year % 400) == 0){ + return true; + } + } + else if((year % 4) == 0){ + return true; + } + return false; +} + +void Problem19::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + + //Start the timer + timer.start(); + + //Run for all years up to 2000 + for(unsigned int year = START_YEAR;year <= END_YEAR;++year){ + //Run for all months in the year + for(unsigned int month = 1;month <= 12;++month){ + DAYS day = getDay(month, 1, year); + if(day == ERROR){ + exit(1); + } + else if(day == SUNDAY){ + ++totalSundays; + } + } + } + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem19::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + std::stringstream results; + results << "There are " << totalSundays << " Sundays that landed on the first of the months from " << START_YEAR << " to " << END_YEAR; + return results.str(); +} + +uint64_t Problem19::getTotalSundays() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return totalSundays; +} diff --git a/Source/Problem2.cpp b/Source/Problem2.cpp new file mode 100644 index 0000000..2c9730f --- /dev/null +++ b/Source/Problem2.cpp @@ -0,0 +1,82 @@ +//ProjectEuler/C++/Source/Problem2.cpp +//Matthew Ellison +// Created: 09-28-18 +//Modified: 07-14-19 +//The sum of the even Fibonacci numbers less than 4,000,000 +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + + +#include +#include +#include +#include "Stopwatch.hpp" +#include "Algorithms.hpp" +#include "../Headers/Problem.hpp" +#include "../Headers/Problem2.hpp" + + +uint64_t Problem2::TOP_NUM = 4000000; + +Problem2::Problem2() : Problem("What is the sum of the even Fibonacci numbers less than 4,000,000?"), fullSum(0){ + +} + +void Problem2::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + //Start the timer + timer.start(); + + //Get all the Fibonacci numbers <= TOP_NUM + std::vector fibList = mee::getAllFib(TOP_NUM); + //Step through the sum of all the elements to find the even numbers and add them to the list + for(uint64_t num : fibList){ + //If the number is even add it to the list + if((num % 2) == 0){ + fullSum += num; + } + //Otherwise ignore it + } + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem2::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + std::stringstream results; + results << "The sum of the even Fibonacci numbers less than 4,000,000 is " << fullSum; + return results.str(); +} + +uint64_t Problem2::getSum() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return fullSum; +} diff --git a/Source/Problem20.cpp b/Source/Problem20.cpp new file mode 100644 index 0000000..17f4496 --- /dev/null +++ b/Source/Problem20.cpp @@ -0,0 +1,103 @@ +//ProjectEuler/C++/Source/Problem20.cpp +//Matthew Ellison +// Created: 11-07-18 +//Modified: 07-14-19 +//What is the sum of the digits of 100!? +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +//This file contains a header from the gmp library. The library is used for large integers. +//You can find more information about them at https://gmplib.org/ +//When compiling this file you need to have the gmp library installed as well as linking the libraries to your executable using the -lgmpxx and -lgmp flags +/* + 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 . +*/ + + +#include +#include +#include +#include "gmpxx.h" +#include "Stopwatch.hpp" +#include "../Headers/Problem20.hpp" + + +Problem20::Problem20() : Problem("What is the sum of the digits of 100!?"), num(1), sum(0){ + //num Starts at 1 because multiplication is performed on it + //sum starts at 0 because addition is performed on it +} + +void Problem20::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + + //Start the timer + timer.start(); + + //Run through every number from 1 to 100 and multiply it by the current num + for(int cnt = 1;cnt <= 100;++cnt){ + num *= cnt; + } + + //Get a string of the number because it is easier to pull appart the individual characters + std::string numString = num.get_str(); + //Run through every character in the string, convert it back to an integer and add it to the running sum + for(unsigned int cnt = 0;cnt < numString.size();++cnt){ + sum += std::stoi(numString.substr(cnt, 1)); + } + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem20::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + std::stringstream results; + //Print the results + results << "100! = " << num.get_str() + << "\nThe sum of the digits is: " << sum; + return results.str(); +} + +mpz_class Problem20::getNumber() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return num; +} + +std::string Problem20::getNumberString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return num.get_str(); +} + +uint64_t Problem20::getSum() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return sum; +} diff --git a/Source/Problem21.cpp b/Source/Problem21.cpp new file mode 100644 index 0000000..8d9572f --- /dev/null +++ b/Source/Problem21.cpp @@ -0,0 +1,115 @@ +//ProjectEuler/C++/Source/Problem21.cpp +//Matthew Ellison +// Created: 11-08-18 +//Modified: 07-14-19 +//Evaluate the sum of all the amicable numbers under 10000 +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + + +#include +#include +#include +#include +#include "Algorithms.hpp" +#include "Stopwatch.hpp" +#include "../Headers/Problem21.hpp" + + +int Problem21::LIMIT = 10000; //The top number that will be evaluated + +Problem21::Problem21() : Problem("Evaluate the sum of all the amicable numbers under 10000"){ + divisorSum.reserve(LIMIT); //Reserving it now makes it faster later + divisorSum.resize(LIMIT); //Make sure there are enough spaces +} + +void Problem21::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + + //Start the timer + timer.start(); + + //Generate the divisors of all the numbers < 10000, get their sum, and add it to the list + for(int cnt = 1;cnt < LIMIT;++cnt){ + std::vector divisors = mee::getDivisors(cnt); //Get all the divisors of a number + if(divisors.size() > 1){ + divisors.pop_back(); //Remove the last entry because it will be the number itself + } + divisorSum.at(cnt) = mee::getSum(divisors); //Add the sum of the divisors to the vector + } + //Check every sum of divisors in the list for a matching sum + for(uint64_t cnt = 1;cnt < divisorSum.size();++cnt){ + uint64_t sum = divisorSum.at(cnt); + //If the sum is greater than the number of divisors then it is impossible to be amicable. Skip the number and continue + if(sum >= divisorSum.size()){ + continue; + } + //We know that divisorSum.at(cnt) == sum, so if divisorSum.at(sum) == cnt we found an amicable number + if(divisorSum.at(sum) == cnt){ + //A number can't be amicable with itself + if(sum == cnt){ + continue; + } + //Add the number to the amicable vector + amicable.push_back(cnt); + } + } + + //Sort the vector for neatness + std::sort(amicable.begin(), amicable.end()); + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem21::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + + std::stringstream results; + results << "All amicable numbers less than 10000 are\n"; + for(unsigned int cnt = 0;cnt < amicable.size();++cnt){ + results << amicable.at(cnt) << '\n'; + } + results << "The sum of all of these amicable numbers is " << mee::getSum(amicable); + return results.str(); +} + +std::vector Problem21::getAmicable() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return amicable; +} + +uint64_t Problem21::getSum() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return mee::getSum(amicable); +} diff --git a/Source/Problem22.cpp b/Source/Problem22.cpp new file mode 100644 index 0000000..370bc15 --- /dev/null +++ b/Source/Problem22.cpp @@ -0,0 +1,470 @@ +//ProjectEuler/C++/Source/Problem22.cpp +//Matthew Ellison +// Created: 11-09-18 +//Modified: 07-14-19 +//What is the total of all the name scores in the file? +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + + +#include +#include +#include +#include +#include +#include "Stopwatch.hpp" +#include "Algorithms.hpp" +#include "../Headers/Problem22.hpp" + + +std::vector Problem22::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"}; + +Problem22::Problem22() : Problem("What is the total of all the name scores in the file?"){ + //Make sure the vector is the right size + sums.reserve(names.size()); + sums.resize(names.size()); + //Make sure the vector is the right size + prod.reserve(names.size()); + prod.resize(names.size()); +} + +void Problem22::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + + //Start the timer + timer.start(); + + //Sort all the names + std::sort(names.begin(), names.end()); + //Step through every name + for(unsigned int nameCnt = 0;nameCnt < names.size();++nameCnt){ + //Step through every character in the current name + for(unsigned int charCnt = 0;charCnt < names[nameCnt].size();++charCnt){ + //A = 65 so subtracting 64 means A = 1. This will only work correctly if all letters are capitalized + sums.at(nameCnt) += (names[nameCnt][charCnt] - 64); + } + } + //Get the product for all numbers + for(unsigned int cnt = 0;cnt < sums.size();++cnt){ + prod.at(cnt) = sums.at(cnt) * (cnt + 1); + } + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem22::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + std::stringstream results; + results << "The answer to the question is " << mee::getSum(prod); + return results.str(); +} + +//Returns the vector of the names being scored +std::vector Problem22::getNames() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return names; +} + +//Returns the sum of the names' scores +uint64_t Problem22::getNameScoreSum() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return mee::getSum(prod); +} diff --git a/Source/Problem23.cpp b/Source/Problem23.cpp new file mode 100644 index 0000000..fca638b --- /dev/null +++ b/Source/Problem23.cpp @@ -0,0 +1,118 @@ +//ProjectEuler/C++/Source/Problem23.cpp +//Matthew Ellison +// Created: 11-09-18 +//Modified: 07-14-19 +//Find the sum of all the positive integers which cannot be written as the sum of two abundant numbers +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + + +#include +#include +#include +#include +#include +#include "Stopwatch.hpp" +#include "Algorithms.hpp" +#include "../Headers/Problem23.hpp" + + +int Problem23::MAX_NUM = 28123; + +Problem23::Problem23() : Problem("Find the sum of all the positive integers which cannot be written as the sum of two abundant numbers"), sum(0){ + //This makes sure the vector is the correct size + divisorSums.reserve(MAX_NUM); + divisorSums.resize(MAX_NUM); +} + +bool Problem23::isSum(const std::vector& abund, int num){ + int64_t sum = 0; + //Pick a number for the first part of the sum + for(unsigned int firstNum = 0;firstNum < abund.size();++firstNum){ + //Pick a number for the second part of the sum + for(unsigned int secondNum = firstNum;secondNum < abund.size();++secondNum){ + sum = abund.at(firstNum) + abund.at(secondNum); + if(sum == num){ + return true; + } + else if(sum > num){ + break; + } + } + } + //If you have run through the entire list and did not find a sum then it is false + return false; +} + +void Problem23::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + + //Start the timer + timer.start(); + + //Get the sum of the divisors of all numbers < MAX_NUM + for(int cnt = 1;cnt < MAX_NUM;++cnt){ + std::vector div = mee::getDivisors(cnt); + if(div.size() > 1){ + div.pop_back(); //Remove the last element, which is the number itself. This gives us the propper divisors + } + divisorSums.at(cnt) = mee::getSum(div); + } + + //Get the abundant numbers + std::vector abund; + for(unsigned int cnt = 0;cnt < divisorSums.size();++cnt){ + if(divisorSums.at(cnt) > cnt){ + abund.push_back(cnt); + } + } + + //Check if each number can be the sum of 2 abundant numbers and add to the sum if no + for(int cnt = 1;cnt < MAX_NUM;++cnt){ + if(!isSum(abund, cnt)){ + sum += cnt; + } + } + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem23::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + std::stringstream results; + results << "The answer is " << sum; + return results.str(); +} + +uint64_t Problem23::getSum() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return sum; +} diff --git a/Source/Problem24.cpp b/Source/Problem24.cpp new file mode 100644 index 0000000..f20e760 --- /dev/null +++ b/Source/Problem24.cpp @@ -0,0 +1,86 @@ +//ProjectEuler/C++/Source/Problem24.cpp +//Matthew Ellison +// Created: 11-11-18 +//Modified: 07-14-19 +//What is the millionth lexicographic permutation of the digits 0, 1, 2, 3, 4, 5, 6, 7, 8 and 9? +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + + +#include +#include +#include +#include "Algorithms.hpp" +#include "Stopwatch.hpp" +#include "../Headers/Problem24.hpp" + + +int Problem24::NEEDED_PERM = 1000000; //The number of the permutation that you need +std::string Problem24::nums = "0123456789"; //All of the characters that we need to get the permutations of + +Problem24::Problem24() : Problem("What is the millionth lexicographic permutation of the digits 0, 1, 2, 3, 4, 5, 6, 7, 8 and 9?"){ + +} + +void Problem24::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + + //Start the timer + timer.start(); + + //Get all permutations of the string + permutations = mee::getPermutations(nums); + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem24::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + std::stringstream results; + //Print the results + results << "The 1 millionth permutation is " << permutations.at(NEEDED_PERM - 1); + return results.str(); +} + +//Returns a vector with all of the permutations +std::vector Problem24::getPermutationsList() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return permutations; +} + +//Returns the specific permutations you are looking for +std::string Problem24::getPermutation() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return permutations.at(NEEDED_PERM - 1); +} diff --git a/Source/Problem25.cpp b/Source/Problem25.cpp new file mode 100644 index 0000000..62d8f07 --- /dev/null +++ b/Source/Problem25.cpp @@ -0,0 +1,119 @@ +//ProjectEuler/C++/Source/Problem25.cpp +//Matthew Ellison +// Created: 11-13-18 +//Modified: 07-14-19 +//What is the index of the first term in the Fibonacci sequence to contain 1000 digits? +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +//This file contains a header from the gmp library. The library is used for large integers. +//You can find more information about them at https://gmplib.org/ +//When compiling this file you need to have the gmp library installed as well as linking the libraries to your executable using the -lgmpxx and -lgmp flags +/* + 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 . +*/ + + +#include +#include +#include "gmpxx.h" +#include "Algorithms.hpp" +#include "Stopwatch.hpp" +#include "../Headers/Problem25.hpp" + + +unsigned int Problem25::NUM_DIGITS = 1000; //The number of digits to calculate up to + +Problem25::Problem25() : Problem("What is the index of the first term in the Fibonacci sequence to contain 1000 digits?"), number(0), index(2){ + +} + +void Problem25::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + + //Start the timer + timer.start(); + + //Move through all Fibonacci numbers until you reach the one with at least NUM_DIGITS digits + while(number.get_str().size() < NUM_DIGITS){ + ++index; //Increase the index number. Doing this at the beginning keeps the index correct at the end of the loop + number = mee::getFib(index); //Calculate the number + } + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem25::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + + std::stringstream results; + results << "The first Fibonacci number with " << NUM_DIGITS << " digits is " << number + << "\nIts index is " << index; + return results.str(); +} + +//Returns the Fibonacci number asked for +mpz_class Problem25::getNumber() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return number; +} + +//Returns the Fibonacci number asked for as a string +std::string Problem25::getNumberString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return number.get_str(); +} + +//Returns the index of the requested Fibonacci number +mpz_class Problem25::getIndex() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return index; +} + +//Returns the index of the requested Fibonacci number as a string +std::string Problem25::getIndexString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return index.get_str(); +} + +//Returns the index of the requested Fibonacci number as a uint64_t +uint64_t Problem25::getIndexInt() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return index.get_ui(); +} diff --git a/Source/Problem26.cpp b/Source/Problem26.cpp new file mode 100644 index 0000000..16582f2 --- /dev/null +++ b/Source/Problem26.cpp @@ -0,0 +1,119 @@ +//ProjectEuler/C++/Headers/Problem26.cpp +//Matthew Ellison +// Created: 07-28-19 +//Modified: 07-28-19 +//Find the value of d < 1000 for which 1/d contains the longest recurring cycle in its decimal fraction part. +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + + +#include +#include +#include +#include "Algorithms.hpp" +#include "../Headers/Problem26.hpp" + + +unsigned int Problem26::TOP_NUMBER = 999; + +Problem26::Problem26() : Problem("Find the value of d < 1000 for which 1/d contains the longest recurring cycle in its decimal fraction part."), longestCycle(0), longestNumber(1){ + +} + +void Problem26::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + + //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(unsigned int denominator = 2;denominator <= TOP_NUMBER;++denominator){ + std::vector remainderList; //Holds the list of remainders + bool endFound = false; //Holds whether we have found an end to the number (either a cycle or a 0 for remainder) + bool cycleFound = false; //Holds whether a cycle was detected + unsigned int numerator = 1; //The numerator that will be divided + while(!endFound){ + //Get the remainder after the division + unsigned int remainder = numerator % denominator; + //Check if the remainder is 0 + //If it is set the flag + if(remainder == 0){ + endFound = true; + } + //Check if the remainder is in the list + //If it is in the list, set the appropriate flags + else if(mee::isFound(remainderList, remainder)){ + endFound = true; + cycleFound = true; + } + //Else add it to the list + else{ + remainderList.push_back(remainder); + } + //Multiply the remainder by 10 to continue finding the next remainder + numerator = remainder * 10; + } + //If a cycle was found check the size of the list against the largest cycle + if(cycleFound){ + //If it is larger than the largest, set it as the new largest + if(remainderList.size() > longestCycle){ + longestCycle = remainderList.size(); + longestNumber = denominator; + } + } + } + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem26::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + + std::stringstream results; + results << "The longest cycle is " << longestCycle << " digits long\n" + << "It is started with the number " << longestNumber; + + return results.str(); +} + +unsigned int Problem26::getLongestCycle() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return longestCycle; +} + +unsigned int Problem26::getLongestNumber() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return longestNumber; +} diff --git a/Source/Problem27.cpp b/Source/Problem27.cpp new file mode 100644 index 0000000..5783cf5 --- /dev/null +++ b/Source/Problem27.cpp @@ -0,0 +1,110 @@ +//ProjectEuler/C++/Source/Problem27.cpp +//Matthew Ellison +// Created: 09-14-19 +//Modified: 09-14-19 +//Find the product of the coefficients, |a| < 1000 and |b| <= 1000, for the quadratic expression that produces the maximum number of primes for consecutive values of n, starting with n=0. +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + +#include +#include +#include +#include "Algorithms.hpp" +#include "../Headers/Problem27.hpp" + + +Problem27::Problem27(){ + topA = topB = topN = 0; + primes = mee::getPrimes((int64_t)(12000)); +} + +void Problem27::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + + //Start the timer + timer.start(); + + //Start with the lowest possible A and check all possibilities after that + for(int64_t a = -999;a <= 999;++a){ + //Start with the lowest possible B and check all possibilities after that + for(int64_t b = -1000;b <= 1000;++b){ + //Start with n=0 and check the formula to see how many primes you can get with concecutive n's + int64_t n = 0; + int64_t quadratic = (n * n) + (a * n) + b; + while(mee::isFound(primes, quadratic)){ + ++n; + quadratic = (n * n) + (a * n) + b; + } + --n; //Negate an n because the last formula failed + + //Set all the largest numbers if this created more primes than any other + if(n > topN){ + topN = n; + topB = b; + topA = a; + } + } + } + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem27::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + + std::stringstream results; + results << "The greatest number of primes found is " << topN + << "\nIt was found with A = " << topA << ", B = " << topB + << "\nThe product of A and B is " << topA * topB; + + return results.str(); +} + +int64_t Problem27::getTopA() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return topA; +} + +int64_t Problem27::getTopB() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return topB; +} + +int64_t Problem27::getTopN() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return topN; +} diff --git a/Source/Problem28.cpp b/Source/Problem28.cpp new file mode 100644 index 0000000..50bb0ff --- /dev/null +++ b/Source/Problem28.cpp @@ -0,0 +1,160 @@ +//ProjectEuler/C++/Source/Problem28.cpp +//Matthew Ellison +// Created: 09-21-19 +//Modified: 09-21-19 +//What is the sum of the numbers on the diagonals in a 1001 by 1001 spiral formed by starting with the number 1 and moving to the right in a clockwise direction a 5 by 5 spiral +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + + +#include +#include +#include +#include +#include "../Headers/Problem28.hpp" + + +//Sets up the grid +void Problem28::setupGrid(){ + bool finalLocation = false; //A flag to indicate if the final location to be filled has been reached + //Set the number that is going to be put at each location + int currentNum = 1; + //Start with the middle location and set it correctly and advance the tracker to the next number + int xLocation = 500; + int yLocation = 500; + grid.at(yLocation).at(xLocation) = currentNum++; + //Move right the first time + ++xLocation; + + //Move in a circular pattern until you reach the final location + while(!finalLocation){ + //Move down until you reach a blank location on the left + while(grid.at(yLocation).at(xLocation - 1) != 0){ + grid.at(yLocation).at(xLocation) = currentNum++; + ++yLocation; + } + + //Move left until you reach a blank location above + while(grid.at(yLocation - 1).at(xLocation) != 0){ + grid.at(yLocation).at(xLocation) = currentNum++; + --xLocation; + } + + //Move up until you reach a blank location to the right + while(grid.at(yLocation).at(xLocation + 1) != 0){ + grid.at(yLocation).at(xLocation) = currentNum++; + --yLocation; + } + + //Move right until you reach a blank location below + while(grid.at(yLocation + 1).at(xLocation) != 0){ + grid.at(yLocation).at(xLocation) = currentNum++; + ++xLocation; + //Check if you are at the final location and break the loop if you are + if(xLocation == (int)grid.size()){ + finalLocation = true; + break; + } + } + } +} + +//Finds the sum of the diagonals in the grid +void Problem28::findSum(){ + //Start at the top corners and work your way down moving toward the opposite side + unsigned int leftSide = 0; + unsigned int rightSide = grid.size() - 1; + unsigned int row = 0; + while(row < grid.size()){ + //This ensures the middle location is only counted once + if(leftSide == rightSide){ + sumOfDiagonals += grid.at(row).at(leftSide); + } + else{ + sumOfDiagonals += grid.at(row).at(leftSide); + sumOfDiagonals += grid.at(row).at(rightSide); + } + ++row; + ++leftSide; + --rightSide; + } +} + +Problem28::Problem28(){ + //Set the size of the grid to 1001 x 1001 + for(int cnt = 0;cnt < 1001;++cnt){ + grid.emplace_back(); + for(int location = 0;location < 1001;++location){ + grid.at(cnt).push_back(0); + } + } + sumOfDiagonals = 0; +} + +void Problem28::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + + //Start the timer + timer.start(); + + + //Setup the grid + setupGrid(); + //Find the sum of the diagonals in the grid + findSum(); + + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem28::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + + std::stringstream results; + results << "The sum of the diagonals in the given grid is " << sumOfDiagonals; + + return results.str(); +} + +//Returns the grid +std::vector> Problem28::getGrid() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return grid; +} + +//Returns the sum of the diagonals +uint64_t Problem28::getSum() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return sumOfDiagonals; +} diff --git a/Source/Problem29.cpp b/Source/Problem29.cpp new file mode 100644 index 0000000..d903c32 --- /dev/null +++ b/Source/Problem29.cpp @@ -0,0 +1,120 @@ +//ProjectEuler/C++/Source/Problem29.cpp +//Matthew Ellison +// Created: 10-06-19 +//Modified: 10-06-19 +//How many distinct terms are in the sequence generated by a^b for 2 <= a <= 100 and 2 <= b <= 100? +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +//This file contains a header from the gmp library. The library is used for large integers. +//You can find more information about them at https://gmplib.org/ +//When compiling this file you need to have the gmp library installed as well as linking the libraries to your executable using the -lgmpxx and -lgmp flags +/* + 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 . +*/ + +#include +#include +#include +#include +#include +#include +#include "../Headers/Problem29.hpp" +#include "Algorithms.hpp" + + +Problem29::Problem29(){ + +} + +void Problem29::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + + //Start the timer + timer.start(); + + //Start with the first A and move towards the top + for(unsigned long currentA = BOTTOM_A;currentA <= TOP_A;++currentA){ + //Start with the first B and move towards the top + for(unsigned long currentB = BOTTOM_B;currentB <= TOP_B;++currentB){ + mpz_class num; + mpz_ui_pow_ui(num.get_mpz_t(), currentA, currentB); + //If the number is not found add it to the list + if(!mee::isFound(unique, num)){ + unique.push_back(num); + } + } + } + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem29::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + + std::stringstream results; + results << "The number of unique values generated by a^b for " << BOTTOM_A << " <= a <= " << TOP_A << " and " << BOTTOM_B << " <= b <= " << TOP_B << " is " << unique.size(); + + return results.str(); +} + +unsigned int Problem29::getBottomA() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return BOTTOM_A; +} + +unsigned int Problem29::getTopA() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return TOP_A; +} + +unsigned int Problem29::getBottomB() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return BOTTOM_B; +} + +unsigned int Problem29::getTopB() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return TOP_B; +} + +std::vector Problem29::getUnique() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return unique; +} diff --git a/Source/Problem3.cpp b/Source/Problem3.cpp new file mode 100644 index 0000000..046569b --- /dev/null +++ b/Source/Problem3.cpp @@ -0,0 +1,92 @@ +//ProjectEuler/C++/Source/Problem3.cpp +//Matthew Ellison +// Created: 09-28-18 +//Modified: 07-14-19 +//The largest prime factor of 600851475143 +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + + +#include +#include +#include +#include +#include "Stopwatch.hpp" +#include "Algorithms.hpp" +#include "../Headers/Problem.hpp" +#include "../Headers/Problem3.hpp" + + +uint64_t Problem3::GOAL_NUMBER = 600851475143; + +Problem3::Problem3() : Problem("What is the largest prime factor of 600851475143?"){ + +} + +void Problem3::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + //Start the timer + timer.start(); + + //Find the factors of GOAL_NUMBER + factors = mee::getFactors(GOAL_NUMBER); + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem3::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + std::stringstream results; + results << "The largest factor of the number " << GOAL_NUMBER << " is " << factors[factors.size() - 1]; + return results.str(); +} + +std::vector Problem3::getFactors() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return factors; +} + +uint64_t Problem3::getLargestFactor() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + + return *factors.end(); +} + +uint64_t Problem3::getGoalNumber() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return GOAL_NUMBER; +} diff --git a/Source/Problem30.cpp b/Source/Problem30.cpp new file mode 100644 index 0000000..3b97808 --- /dev/null +++ b/Source/Problem30.cpp @@ -0,0 +1,127 @@ +//ProjectEuler/C++/Source/Problem30.cpp +//Matthew Ellison +// Created: 10-27-19 +//Modified: 10-27-19 +//Find the sum of all the numbers that can be written as the sum of the fifth powers of their digits. +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + + +#include +#include +#include +#include +#include +#include "../Headers/Problem30.hpp" + + +//Returns a vector with the indivitual digits of the number passed into it +std::vector Problem30::getDigits(uint64_t num){ + std::vector listOfDigits; //This vector holds the individual digits of num + //The easiest way to get the individual digits of a number is by converting it to a string + std::string digits = std::to_string(num); //Holds a string representation of num + //Start with the first digit, convert it to an integer, store it in the vector, and move to the next digit + for(int cnt = 0;cnt < digits.size();++cnt){ + listOfDigits.push_back(std::stoi(digits.substr(cnt, 1))); + } + //Return the list of digits + return listOfDigits; +} + +Problem30::Problem30(){ + +} + +void Problem30::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + + //Start the timer + timer.start(); + + //Start with the lowest number and increment until you reach the largest number + for(uint64_t currentNum = BOTTOM_NUM;currentNum <= TOP_NUM;++currentNum){ + //Get the digits of the number + std::vector digits = getDigits(currentNum); + //Get the sum of the powers + uint64_t sumOfPowers = 0; + for(uint64_t num : digits){ + sumOfPowers += std::pow(num, POWER_RAISED); + } + //Check if the sum of the powers is the same as the number + //If it is add it to the list, otherwise continue to the next number + if(sumOfPowers == currentNum){ + sumOfFifthNumbers.push_back(currentNum); + } + } + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem30::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + + std::stringstream results; + results << "The sum of all the numbers that can be written as the sum of the fifth powers of their digits is " << getSumOfList(); + + return results.str(); +} + +//This returns the top number to be checked +uint64_t Problem30::getTopNum() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + + return TOP_NUM; +} + +//This returns a copy of the vector holding all the numbers that are the sum of the fifth power of their digits +std::vector Problem30::getListOfSumOfFifths() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + + return sumOfFifthNumbers; +} + +//This returns the sum of all entries in sumOfFifthNumbers +uint64_t Problem30::getSumOfList() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + + uint64_t sum = 0; + for(uint64_t num : sumOfFifthNumbers){ + sum += num; + } + + return sum; +} diff --git a/Source/Problem4.cpp b/Source/Problem4.cpp new file mode 100644 index 0000000..53fc4cc --- /dev/null +++ b/Source/Problem4.cpp @@ -0,0 +1,104 @@ +//ProjectEuler/C++/Source/Problem4.cpp +//Matthew Ellison +// Created: 09-28-18 +//Modified: 07-14-19 +//Find the largest palindrome made from the product of two 3-digit numbers +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + + +#include +#include +#include +#include +#include "Stopwatch.hpp" +#include "../Headers/Problem.hpp" +#include "../Headers/Problem4.hpp" + + +int Problem4::START_NUM = 100; +int Problem4::END_NUM = 999; + +Problem4::Problem4() : Problem("Find the largest palindrome made from the product of two 3-digit numbers."){ + +} + +void Problem4::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + //Start the timer + timer.start(); + + //Start at the first 3-digit number and check every one up to the last 3-digit number + for(int firstNum = START_NUM;firstNum <= END_NUM;++firstNum){ + //You can start at the location of the first number because everything before that has already been tested. (100*101 == 101*100) + for(int secondNum = firstNum;secondNum < END_NUM;++secondNum){ + //Get the product + uint64_t product = firstNum * secondNum; + //Change the number to a string + std::string productString= std::to_string(product); + //Reverse the string + std::string revProductString = productString; + std::reverse(revProductString.begin(), revProductString.end()); + + //If the number and it's reverse are the same it is a palindrome so add it to the vector + if(productString == revProductString){ + palindromes.push_back(product); + } + //If it's not a palindrome ignore it and move to the next number + } + } + + //Sort the palindromes so that the last one is the largest + std::sort(palindromes.begin(), palindromes.end()); + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem4::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + //Print the results + std::stringstream results; + results << "The largest palindrome is " << *(palindromes.end() - 1); + return results.str(); +} + +std::vector Problem4::getPalindromes() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return palindromes; +} + +uint64_t Problem4::getLargestPalindrome() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return *(palindromes.end() - 1); +} diff --git a/Source/Problem5.cpp b/Source/Problem5.cpp new file mode 100644 index 0000000..d416102 --- /dev/null +++ b/Source/Problem5.cpp @@ -0,0 +1,94 @@ +//ProjectEuler/C++/Source/Problem5.cpp +//Matthew Ellison +// Created: 09-28-18 +//Modified: 07-14-19 +//What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20? +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + + +#include +#include +#include +#include +#include "Stopwatch.hpp" +#include "../Headers/Problem.hpp" +#include "../Headers/Problem5.hpp" + + +Problem5::Problem5() : Problem("What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20?"), smallestNum(0){ + +} + +void Problem5::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + //Setup your variables + bool numFound = false; //Used to determine if the number has been found + + //Start the timer + timer.start(); + + //Start at 20 because it must at least be divisible by 20. Increment by 2 because it must be an even number to be divisible by 2 + //Loop through every even number starting at 20 + int currentNum = 20; + while((currentNum > 0) && (!numFound)){ + //Start by assuming you found the number (because we throw a flag if we didn't find it) + numFound = true; + //Step through every number from 1-20 seeing if the current number is divisible by it + for(int divisor = 1;divisor <= 20;++divisor){ + //If it is not divisible then throw a flag and start looking at the next number + if((currentNum % divisor) != 0){ + numFound = false; + break; + } + } + //If you didn't find the correct number then increment by 2 + if(!numFound){ + currentNum += 2; + } + } + + smallestNum = currentNum; + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem5::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + std::stringstream results; + results << "The smallest positive number evenly divisible by all numbers 1-20 is " << smallestNum; + return results.str(); +} + +int Problem5::getNumber() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return smallestNum; +} diff --git a/Source/Problem6.cpp b/Source/Problem6.cpp new file mode 100644 index 0000000..b7b1c6e --- /dev/null +++ b/Source/Problem6.cpp @@ -0,0 +1,96 @@ +//ProjectEuler/C++/Source/Problem6.cpp +//Matthew Ellison +// Created: 09-28-18 +//Modified: 07-14-19 +//Find the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum. +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + + +#include +#include +#include +#include +#include "Stopwatch.hpp" +#include "../Headers/Problem.hpp" +#include "../Headers/Problem6.hpp" + + +int Problem6::START_NUM = 1; +int Problem6::END_NUM = 100; + +Problem6::Problem6() : Problem("Find the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum."), sumOfSquares(0), squareOfSum(0){ + +} + +void Problem6::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + //Start the timer + timer.start(); + + //Run through all numbers and add them to the appropriate sums + for(int currentNum = START_NUM;currentNum <= END_NUM;++currentNum){ + sumOfSquares += (currentNum * currentNum); //Add the square to the correct variable + squareOfSum += currentNum; //Add the number to the correct variable for squaring later + } + //Square the sum that needs it + squareOfSum *= squareOfSum; + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem6::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + std::stringstream results; + results << "The difference between the sum of the squares and the square of the sum of all numbers from 1-100 is " << abs(sumOfSquares - squareOfSum); + return results.str(); +} + +uint64_t Problem6::getSumOfSquares() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return sumOfSquares; +} + +uint64_t Problem6::getSquareOfSum() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return squareOfSum; +} + +uint64_t Problem6::getDifference() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return abs(sumOfSquares - squareOfSum); +} diff --git a/Source/Problem67.cpp b/Source/Problem67.cpp new file mode 100644 index 0000000..c5f9d93 --- /dev/null +++ b/Source/Problem67.cpp @@ -0,0 +1,405 @@ +//ProjectEuler/C++/Source/Problem67.cpp +//Matthew Ellison +// Created: 11-02-18 +//Modified: 07-14-19 +//The way to do this is using a breadth first search +/* +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 +*/ +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + + +#include +#include +#include +#include +#include "Stopwatch.hpp" +#include "../Headers/Problem67.hpp" + + +std::vector Problem67::list[NUM_ROWS] = { + {59}, + {73, 41}, + {52, 40, 9}, + {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, 9}, + {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, 9, 07, 75, 97, 95, 78, 87, 8, 53}, + {67, 66, 59, 60, 88, 99, 94, 65, 55, 77, 55, 34, 27, 53, 78, 28}, + {76, 40, 41, 04, 87, 16, 9, 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, 9, 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, 9, 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, 9, 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, 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}, + {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}, + {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}, + {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}, + {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}, + {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, 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}, + {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}, + {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, 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}, + {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, 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}, + {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}, + {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}, + {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, 8, 56, 80, 67, 18, 46, 66, 63, 01, 20, 8, 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, 9, 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, 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}, + {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}, + {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}, + {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}, + {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, 9, 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, 9, 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, 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}, + {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}, + {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, 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}, + {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}, + { 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}, + {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}, + {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}, + {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}, + { 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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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}, + {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, 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}, + {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, 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}, + {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}, + {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}, + {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, 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}, + {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}, + {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}, + {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}, + }; + +Problem67::Problem67() : Problem("Find the maximum total from the top to the bottom of the pyramid."){ + //The method that I am using looks for the smallest numbers, so I need to invert the numbers in this list + invert(); + //Now l[i][j] == 100 - l[i][j]; + + //Add the top point because that is already the only path + foundPoints.emplace_back(0, 0, list[0][0], false); + //Add the second row as possible points + possiblePoints.emplace_back(0, 1, (list[0][0] + list[1][0]), true); + possiblePoints.emplace_back(1, 1, list[0][0] + list[1][1], false); +} + +void Problem67::invert(){ + for(unsigned int rowCnt = 0;rowCnt < NUM_ROWS;++rowCnt){ + for(unsigned int colCnt = 0;colCnt < list[rowCnt].size();++colCnt){ + list[rowCnt][colCnt] = 100 - list[rowCnt][colCnt]; + } + } +} + +void Problem67::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + + //Start the timer + timer.start(); + + bool foundBottom = false; //Used when you find a point at the bottom + + //Loop until you find the bottom + while(!foundBottom){ + //Check which possible point gives us the lowest number. If more than one has the same number simply keep the first one + location minLoc = possiblePoints.front(); + for(location loc : possiblePoints){ + if(loc.total < minLoc.total){ + minLoc = loc; + } + } + + //Remove it from the list of possible points + possiblePoints.remove_if([minLoc](location loc){return (loc.xLocation == minLoc.xLocation) &&(loc.yLocation == minLoc.yLocation);}); + + //Add that point to the list of found points + foundPoints.push_back(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 + unsigned int xLoc = minLoc.xLocation; + unsigned int yLoc = minLoc.yLocation + 1; //Add one because you will always be moving to the next row + if(yLoc >= NUM_ROWS){ + foundBottom = true; + } + else{ + possiblePoints.emplace_back(xLoc, yLoc, minLoc.total + list[yLoc][xLoc], true); + ++xLoc; //Advance the x location to simulate going right + //Check if x is out of bounds + if(xLoc < list[yLoc].size()){ + possiblePoints.emplace_back(xLoc, yLoc, minLoc.total + list[yLoc][xLoc], false); + } + } + } + + actualTotal = ((100 * NUM_ROWS) - foundPoints.back().total); //Change the minimum to the maximum + invert(); //Invert the list again so that it is back to it's original form + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem67::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + + std::stringstream results; + results << "The value of the longest path is " << actualTotal; + return results.str(); +} + +//Returns the pyramid that was traversed as a string +std::string Problem67::getPyramid() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + std::stringstream results; + + //Print the triangle list of numbers + for(unsigned int rowCnt = 0;rowCnt < NUM_ROWS;++rowCnt){ + for(unsigned int colCnt = 0;colCnt < list[rowCnt].size();++colCnt){ + results << std::setw(2) << list[rowCnt][colCnt] << ' '; + } + } + return results.str(); +} + +//Returns the trail the algorithm took as a string +std::string Problem67::getTrail(){ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + + std::stringstream results; + //Print the trail the algorithm took + std::list trail; + trail.push_front(foundPoints.back()); + bool top = false; + while(!top){ + bool found = false; + int loc = foundPoints.size() - 1; + std::list::iterator toAdd = foundPoints.begin(); + while(!found){ + if(loc < 0){ + results << "Error: Location < 0\n"; + exit(1); + } + std::list::iterator it = foundPoints.begin(); + std::advance(it, loc); + if(trail.front().fromRight){ + if((it->xLocation == trail.begin()->xLocation) && (it->yLocation == (trail.begin()->yLocation - 1))){ + found = true; + toAdd = it; + } + else{ + --loc; + } + } + else{ + if((it->xLocation == (trail.begin()->xLocation - 1)) && (it->yLocation == (trail.begin()->yLocation - 1))){ + found = true; + toAdd = it; + } + else{ + --loc; + } + } + } + + + trail.push_front(*toAdd); + + if(trail.begin()->yLocation == 0){ + top = true; + } + } + + for(location loc : trail){ + results << list[loc.yLocation][loc.xLocation] << "->"; + } + return results.str(); +} + +//Returns the total that was asked for +int Problem67::getTotal() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return actualTotal; +} \ No newline at end of file diff --git a/Source/Problem7.cpp b/Source/Problem7.cpp new file mode 100644 index 0000000..0a4c71e --- /dev/null +++ b/Source/Problem7.cpp @@ -0,0 +1,75 @@ +//ProjectEuler/C++/Source/Problem7.cpp +//Matthew Ellison +// Created: 09-28-18 +//Modified: 07-14-19 +//What is the 10001th prime number? +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + + +#include +#include +#include +#include +#include "Stopwatch.hpp" +#include "Algorithms.hpp" +#include "../Headers/Problem.hpp" +#include "../Headers/Problem7.hpp" + + +uint64_t Problem7::NUMBER_OF_PRIMES = 10001; + +Problem7::Problem7() : Problem("What is the 10001th prime number?"){ + +} + +void Problem7::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + //Start the timer + timer.start(); + + //Get the correct number of prime numbers + primes = mee::getNumPrimes(NUMBER_OF_PRIMES); + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem7::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + std::stringstream results; + results << "The " << NUMBER_OF_PRIMES << "th prime number is " << primes.at(primes.size() - 1); + return results.str(); +} + +uint64_t Problem7::getPrime() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return *primes.end(); +} diff --git a/Source/Problem8.cpp b/Source/Problem8.cpp new file mode 100644 index 0000000..f0d8f3c --- /dev/null +++ b/Source/Problem8.cpp @@ -0,0 +1,114 @@ +//ProjectEuler/C++/Source/Problem8.cpp +//Matthew Ellison +// Created: 09-28-18 +//Modified: 07-14-19 +//Find the thirteen adjacent digits in the 1000-digit number that have the greatest product. What is the value of this product? +/* +73167176531330624919225119674426574742355349194934 +96983520312774506326239578318016984801869478851843 +85861560789112949495459501737958331952853208805511 +12540698747158523863050715693290963295227443043557 +66896648950445244523161731856403098711121722383113 +62229893423380308135336276614282806444486645238749 +30358907296290491560440772390713810515859307960866 +70172427121883998797908792274921901699720888093776 +65727333001053367881220235421809751254540594752243 +52584907711670556013604839586446706324415722155397 +53697817977846174064955149290862569321978468622482 +83972241375657056057490261407972968652414535100474 +82166370484403199890008895243450658541227588666881 +16427171479924442928230863465674813919123162824586 +17866458359124566529476545682848912883142607690042 +24219022671055626321111109370544217506941658960408 +07198403850962455444362981230987879927244284909188 +84580156166097919133875499200524063689912560717606 +05886116467109405077541002256983155200055935729725 +71636269561882670428252483600823257530420752963450 +*/ +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + + +#include +#include +#include +#include +#include "Stopwatch.hpp" +#include "../Headers/Problem.hpp" +#include "../Headers/Problem8.hpp" + + +std::string Problem8::number = "7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450"; + +Problem8::Problem8() : Problem("Find the thirteen adjacent digits in the 1000-digit number that have the greatest product. What is the value of this product?"), maxProduct(0){ + +} + +void Problem8::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + //Start the timer + timer.start(); + + //Cycle through the string of numbers looking for the maximum product + for(unsigned int cnt = 12;cnt < number.size();++cnt){ + uint64_t currentProduct = std::stoull(number.substr(cnt, 1)) * std::stoull(number.substr(cnt - 1, 1)) * std::stoull(number.substr(cnt - 2, 1)) * std::stoull(number.substr(cnt - 3, 1)) * std::stoull(number.substr(cnt - 4, 1)) * std::stoull(number.substr(cnt - 5, 1)) * std::stoull(number.substr(cnt - 6, 1)) * std::stoull(number.substr(cnt - 7, 1)) * std::stoull(number.substr(cnt - 8, 1)) * std::stoull(number.substr(cnt - 9, 1)) * std::stoull(number.substr(cnt - 10, 1)) * std::stoull(number.substr(cnt - 11, 1)) * std::stoull(number.substr(cnt - 12, 1)); + + //Check if the product is greater than the current maximum + //If it is currentNums is the new maximum + if(currentProduct > maxProduct){ + maxNums = number.substr(cnt - 12, 13); + maxProduct = currentProduct; + } + } + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem8::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + std::stringstream results; + results << "The greatest product is " << maxProduct + << "\nThe numbers are " << maxNums; + return results.str(); +} + +std::string Problem8::getLargestNums() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return maxNums; +} + +uint64_t Problem8::getLargestProduct() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return maxProduct; +} diff --git a/Source/Problem9.cpp b/Source/Problem9.cpp new file mode 100644 index 0000000..da3f7b0 --- /dev/null +++ b/Source/Problem9.cpp @@ -0,0 +1,119 @@ +//ProjectEuler/C++/Source/Problem9.cpp +//Matthew Ellison +// Created: 09-28-18 +//Modified: 07-14-19 +//There exists exactly one Pythagorean triplet for which a + b + c = 1000. Find the product of abc. +//Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/myClasses +/* + 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 . +*/ + + +#include +#include +#include +#include "Stopwatch.hpp" +#include "../Headers/Problem.hpp" +#include "../Headers/Problem9.hpp" + + +Problem9::Problem9() : Problem("There exists exactly one Pythagorean triplet for which a + b + c = 1000. Find the product of abc."), a(1), b(0), c(0), found(false){ + +} + +void Problem9::solve(){ + //If the problem has already been solved do nothing and end the function + if(solved){ + return; + } + //Start the timer + timer.start(); + + //Loop through all possible a's + while((a < 1000) && !found){ + b = a + 1; //b bust be greater than a + c = sqrt(pow(a, 2) + pow(b, 2)); + + //Loop through all possible b's + while((a + b + c) < 1000){ + ++b; + c = sqrt(pow(a, 2) + pow(b, 2)); + } + + //If the sum == 1000 you found the number, otherwise go to the next possible a + if((a + b + c) == 1000){ + found = true; + } + else{ + ++a; + } + } + + //Stop the timer + timer.stop(); + + //Throw a flag to show the problem is solved + solved = true; +} + +std::string Problem9::getString() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + std::stringstream results; + if(found){ + results << "The Pythagorean triplet is " << a << ' ' << b << ' ' << (int)c + << "\nThe numbers' product is " << a * b * (int)c; + } + else{ + results << "The number was not found!"; + } + + return results.str(); +} + +int Problem9::getSideA() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return a; +} + +int Problem9::getSideB() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return b; +} + +int Problem9::getSideC() const{ +//If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return (int)c; +} + +int Problem9::getProduct() const{ + //If the problem hasn't been solved throw an exception + if(!solved){ + throw unsolved(); + } + return a * b * (int)c; +} diff --git a/main.cpp b/main.cpp new file mode 100644 index 0000000..bf94185 --- /dev/null +++ b/main.cpp @@ -0,0 +1,256 @@ +//ProjectEuler/C++/main.cpp +//Matthew Ellison +// Created: 07-04-19 +//Modified: 07-08-19 +//This is a driver function for all Project Euler problems +//It prompts the user for an action (state the problem or solve the problem), then executes the appropriate command on the appropriate problem + + +#include +#include +#include "Algorithms.hpp" +#include "Headers/Problem.hpp" +#include "Headers/Problem1.hpp" +#include "Headers/Problem2.hpp" +#include "Headers/Problem3.hpp" +#include "Headers/Problem4.hpp" +#include "Headers/Problem5.hpp" +#include "Headers/Problem6.hpp" +#include "Headers/Problem7.hpp" +#include "Headers/Problem8.hpp" +#include "Headers/Problem9.hpp" +#include "Headers/Problem10.hpp" +#include "Headers/Problem11.hpp" +#include "Headers/Problem12.hpp" +#include "Headers/Problem13.hpp" +#include "Headers/Problem14.hpp" +#include "Headers/Problem15.hpp" +#include "Headers/Problem16.hpp" +#include "Headers/Problem17.hpp" +#include "Headers/Problem18.hpp" +#include "Headers/Problem19.hpp" +#include "Headers/Problem20.hpp" +#include "Headers/Problem21.hpp" +#include "Headers/Problem22.hpp" +#include "Headers/Problem23.hpp" +#include "Headers/Problem24.hpp" +#include "Headers/Problem25.hpp" +#include "Headers/Problem26.hpp" +#include "Headers/Problem27.hpp" +#include "Headers/Problem28.hpp" +#include "Headers/Problem29.hpp" +#include "Headers/Problem30.hpp" +#include "Headers/Problem67.hpp" + + +//Some helper functions to help with the menus +void printMenu(); //Prints the menu in the terminal +int getMenuSelection(); //Returns a valid menu selection from the user +bool isValidMenu(int selection); //Returns true if the int passed into it is a valid menu selection +void solveMenu(); //Prints the menu for solving a problem and handles how the problem is handed off +Problem* getProblem(unsigned int problemNumber); //Takes a problem's number and returns a pointer to the appropriate class +void solveProblem(Problem* problem); //Handles how the program solves the problem +void descriptionMenu(); //Handles how the program reacts to printing the problem's description +void printDescription(Problem* problem); //Prints out the description of the problem passed to it +unsigned int getProblemNumber(); //A helper function to error check the problem number input for solving and describing problems +void listProblems(); //Lists the problem numbers that you can choose + +//Setup the menu options +enum MenuOptions {SOLVE = 1, DESCRIPTION, LIST, EXIT, SIZE}; +//Setup the problem numbers +std::vector PROBLEM_NUMBERS = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, + 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, + 67}; + + +int main(){ + int selection = 0; //Holds the menu selection of the user + do{ + //Print the menu and prompt the user to select an action + printMenu(); + selection = getMenuSelection(); + + switch(selection){ + case SOLVE : solveMenu(); break; + case DESCRIPTION : descriptionMenu(); break; + case LIST : listProblems(); break; + case EXIT : break; + } + }while(selection != EXIT); + + return 0; +} + +void printMenu(){ + std::cout << "1. Solve a problem\n" + << "2. Print a problem description\n" + << "3. List valid problem numbers\n" + << "4. Exit" << std::endl; +} + +int getMenuSelection(){ + int selection = 0; + std::cin >> selection; + while(std::cin.fail() || !isValidMenu(selection)){ + std::cout << "That is an invalid option!\nPress Enter to continue" << std::endl; + std::cin.clear(); + std::cin.get(); + printMenu(); + std::cin >> selection; + } + return selection; +} + +bool isValidMenu(int selection){ + if((selection > 0) && (selection < MenuOptions::SIZE)){ + return true; + } + else{ + return false; + } +} + +void solveMenu(){ + unsigned int problemNumber = getProblemNumber(); + Problem* problem = nullptr; + //This selection solves all problems in order + if(problemNumber == 0){ + //Solve to every valid problem number, skipping over 0 + for(unsigned int problemLocation = PROBLEM_NUMBERS[1];problemLocation < PROBLEM_NUMBERS.size();++problemLocation){ + //Generate the current problem + problem = getProblem(PROBLEM_NUMBERS.at(problemLocation)); + //Solve the problem + std::cout << PROBLEM_NUMBERS.at(problemLocation) << ". "; + solveProblem(problem); + //Release the memory + delete problem; + //Safeguard + problem = nullptr; + } + } + //This is if a single problem number was chosen + else{ + //Generate the problem + problem = getProblem(problemNumber); + //Solve the problem + solveProblem(problem); + //Release the memory + delete problem; + //Just an overprotective safeguard + problem = nullptr; + } +} + +//This function returns a pointer to a problem of type number +Problem* getProblem(unsigned int problemNumber){ + Problem* problem = nullptr; //Holds the problem we are about to create + + //Decide which problem was asked for and create it + switch(problemNumber){ + case 1 : problem = new Problem1; break; + case 2 : problem = new Problem2; break; + case 3 : problem = new Problem3; break; + case 4 : problem = new Problem4; break; + case 5 : problem = new Problem5; break; + case 6 : problem = new Problem6; break; + case 7 : problem = new Problem7; break; + case 8 : problem = new Problem8; break; + case 9 : problem = new Problem9; break; + case 10 : problem = new Problem10; break; + case 11 : problem = new Problem11; break; + case 12 : problem = new Problem12; break; + case 13 : problem = new Problem13; break; + case 14 : problem = new Problem14; break; + case 15 : problem = new Problem15; break; + case 16 : problem = new Problem16; break; + case 17 : problem = new Problem17; break; + case 18 : problem = new Problem18; break; + case 19 : problem = new Problem19; break; + case 20 : problem = new Problem20; break; + case 21 : problem = new Problem21; break; + case 22 : problem = new Problem22; break; + case 23 : problem = new Problem23; break; + case 24 : problem = new Problem24; break; + case 25 : problem = new Problem25; break; + case 26 : problem = new Problem26; break; + case 27 : problem = new Problem27; break; + case 28 : problem = new Problem28; break; + case 29 : problem = new Problem29; break; + case 30 : problem = new Problem30; break; + case 67 : problem = new Problem67; break; + } + + //Return the newly created problem + return problem; +} + +void solveProblem(Problem* problem){ + //Print the problem description + printDescription(problem); + //Solve the problem + problem->solve(); + //Print the results + std::cout << problem->getString() + << "\nIt took " << problem->getTime() << " to solve this problem.\n\n" << std::endl; +} + +void descriptionMenu(){ + Problem* problem = nullptr; //Holds the problem that will be generated + std::cout << "\n\n"; //Give some extra space to print the description + + //Get the problem number + unsigned int problemNumber = getProblemNumber(); + + //If the problem number is 0 print out all descriptions + if(problemNumber == 0){ + //Print description for every valid problem number, skipping over 0 + for(unsigned int problemLocation = PROBLEM_NUMBERS[1];problemLocation < PROBLEM_NUMBERS.size();++problemLocation){ + //Generate the problem + problem = getProblem(PROBLEM_NUMBERS.at(problemLocation)); + //Print the problem's description + std::cout << PROBLEM_NUMBERS.at(problemLocation) << ". "; + printDescription(problem); + std::cout << '\n'; + //Release the memory + delete problem; + //Safeguard + problem = nullptr; + } + } + //Otherwise print out a single problem's description + else{ + //Generate the problem + problem = getProblem(problemNumber); + //Print the problem's description + printDescription(problem); + //Release the memory + delete problem; + //Safeguard + problem = nullptr; + } +} + +void printDescription(Problem* problem){ + std::cout << problem->getDescription() << '\n'; +} + +unsigned int getProblemNumber(){ + unsigned int problemNumber = 0; + std::cout << "Enter a problem number: "; + std::cin >> problemNumber; + while(!mee::isFound(PROBLEM_NUMBERS, problemNumber) || std::cin.fail()){ + std::cout << "That is an invalid problem number!\nEnter a problem number: "; + std::cin.clear(); + std::cin >> problemNumber; + } + return problemNumber; +} + +void listProblems(){ + std::cout << PROBLEM_NUMBERS[1]; + for(unsigned int problemNumber = 2;problemNumber < PROBLEM_NUMBERS.size();++problemNumber){ + std::cout << ", " << PROBLEM_NUMBERS[problemNumber]; + } + std::cout << std::endl; +} diff --git a/makefile b/makefile new file mode 100644 index 0000000..764c955 --- /dev/null +++ b/makefile @@ -0,0 +1,29 @@ +LIBFLAGS = -shared -std=c++11 -O3 -fPIC -Wall +EXEFLAGS = -Wall -std=c++11 -O3 -Wl,-rpath,'$$ORIGIN/lib' +LINKEDLIBS = -lgmp -lgmpxx +PROBLEM_NUMBERS = 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 67 +PROBLEM_FILES = $(patsubst %,Source/libProblem%.cpp,$(PROBLEM_NUMBERS)) +LIBDIR = ./lib +LIBS = $(patsubst %, -lProblem%,$(PROBLEM_NUMBERS)) + +all: libs ProjectEuler +libs: directory $(patsubst %, $(LIBDIR)/libProblem%.so,$(PROBLEM_NUMBERS)) + +directory: + mkdir -p $(LIBDIR) + +#Building the Libraries +$(LIBDIR)/libProblem%.so: Source/Problem%.cpp + $(CXX) $(LIBFLAGS) -o $@ $< $(LINKEDLIBS) + +#Building the executable +ProjectEuler: main.cpp + $(CXX) $(EXEFLAGS) -o $@.exe $< -L $(LIBDIR) $(LIBS) $(LINKEDLIBS) + + +#Clean up/Remove all files and folders created +.PHONY: clean + +clean: + rm -f lib/*.so ProjectEuler.exe + rmdir lib