Update test coverage

files/Problem11Grid.txt

@@ -0,0 +1,20 @@
+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

files/Problem13Numbers.txt

@@ -0,0 +1,100 @@
+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

files/Problem18Pyramid.txt

@@ -0,0 +1,15 @@
+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

files/Problem67Pyramid.txt

@@ -0,0 +1,100 @@
+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

files/Problem8Number.txt

@@ -0,0 +1 @@
+7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450

src/main/java/com/mattrixwv/project_euler/problems/Problem1.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem1.java
 //Matthew Ellison
 // Created: 03-01-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 //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/JavaClasses
 /*
-	Copyright (C) 2021  Matthew Ellison
+	Copyright (C) 2023  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
@@ -28,7 +28,7 @@ public class Problem1 extends Problem{
 	//Static variables
 	private static final int TOP_NUM = 999;	//The largest number to be checked
 	//Instance variables
-	private int fullSum;	//The sum of all the numbers
+	protected int fullSum;	//The sum of all the numbers
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem10.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem10.java
 //Matthew Ellison
 // Created: 03-03-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 //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/JavaClasses
 /*
-	Copyright (C) 2021  Matthew Ellison
+	Copyright (C) 2023  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
@@ -32,7 +32,7 @@ public class Problem10 extends Problem{
 	//Static variables
 	private static final long GOAL_NUMBER = 2000000L - 1L;	//The largest number to check for primes
 	//Instance variables
-	private long sum;	//The sum of all of the prime numbers
+	protected long sum;	//The sum of all of the prime numbers
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem11.java

@@ -1,33 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem11.java
 //Matthew Ellison
 // Created: 03-03-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 //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/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -45,6 +23,10 @@
 package com.mattrixwv.project_euler.problems;
 
 
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.security.InvalidParameterException;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -55,28 +37,10 @@ public class Problem11 extends Problem{
 	//Variables
 	//Static variables
 	//This is the grid of numbers that we will be working with
-	private static final Integer[][] grid = {{ 8,  2, 22, 97, 38, 15,  0, 40,  0, 75,  4,  5,  7, 78, 52, 12, 50, 77, 91,  8},
+	protected static String FILE_NAME = "files/Problem11Grid.txt";
-											 {49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48,  4, 56, 62,  0},
+	protected static ArrayList<List<Integer>> grid;
-											 {81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30,  3, 49, 13, 36, 65},
-											 {52, 70, 95, 23,  4, 60, 11, 42, 69, 24, 68, 56,  1, 32, 56, 71, 37,  2, 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,  3, 45,  2, 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,  2, 62, 12, 20, 95, 63, 94, 39, 63,  8, 40, 91, 66, 49, 94, 21},
-											 {24, 55, 58,  5, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72},
-											 {21, 36, 23,  9, 75,  0, 76, 44, 20, 45, 35, 14,  0, 61, 33, 97, 34, 31, 33, 95},
-											 {78, 17, 53, 28, 22, 75, 31, 67, 15, 94,  3, 80,  4, 62, 16, 14,  9, 53, 56, 92},
-											 {16, 39,  5, 42, 96, 35, 31, 47, 55, 58, 88, 24,  0, 17, 54, 24, 36, 29, 85, 57},
-											 {86, 56,  0, 48, 35, 71, 89,  7,  5, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58},
-											 {19, 80, 81, 68,  5, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77,  4, 89, 55, 40},
-											 { 4, 52,  8, 83, 97, 35, 99, 16,  7, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66},
-											 {88, 36, 68, 87, 57, 62, 20, 72,  3, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69},
-											 { 4, 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,  4, 36, 16},
-											 {20, 73, 35, 29, 78, 31, 90,  1, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57,  5, 54},
-											 { 1, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52,  1, 89, 19, 67, 48}};
 	//Instance variables
-	private ArrayList<Integer> greatestProduct;	//Holds the largest product we have found so far
+	protected List<Integer> greatestProduct;	//Holds the largest product we have found so far
 
 	//Functions
 	//Constructor
@@ -85,6 +49,32 @@ public class Problem11 extends Problem{
 		greatestProduct = new ArrayList<>();
 	}
 	//Operational functions
+	//Read numbers from file into grid
+	private void readFile(){
+		if(grid != null){
+			return;
+		}
+		File file = new File(FILE_NAME);
+		if(file.exists()){
+			try{
+				List<String> lines = Files.readAllLines(file.toPath());
+				grid = new ArrayList<>();
+				for(String line : lines){
+					ArrayList<Integer> row = new ArrayList<>();
+					for(String num : line.split(" ")){
+						row.add(Integer.parseInt(num));
+					}
+					grid.add(row);
+				}
+			}
+			catch(IOException error){
+				throw new InvalidParameterException("Error reading file", error);
+			}
+		}
+		else{
+			throw new InvalidParameterException("Error opening file");
+		}
+	}
 	//Solve the problem
 	@Override
 	public void solve(){
@@ -102,13 +92,16 @@ public class Problem11 extends Problem{
 			currentProduct.add(0);
 		}
 
+		//Read the file into the number
+		readFile();
+
 		//Start the timer
 		timer.start();
 
 
 		//Loop through every row and column
-		for(int row = 0;row < grid.length;++row){
+		for(int row = 0;row < grid.size();++row){
-			for(int col = 0;col < grid[row].length;++col){
+			for(int col = 0;col < grid.get(row).size();++col){
 				//Directional booleans to show whether you can move a certain direction
 				boolean left = false;
 				boolean right = false;
@@ -118,7 +111,7 @@ public class Problem11 extends Problem{
 				if((col - 3) >= 1){
 					left = true;
 				}
-				if((col + 3) < grid[row].length){
+				if((col + 3) < grid.get(row).size()){
 					right = true;
 				}
 				if((row + 3) < 20){
@@ -155,10 +148,10 @@ public class Problem11 extends Problem{
 	//Check to the right of the current location
 	private void checkRight(ArrayList<Integer> currentProduct, int row, int col){
 		//Fill the product
-		currentProduct.set(0, grid[row][col]);
+		currentProduct.set(0, grid.get(row).get(col));
-		currentProduct.set(1, grid[row][col + 1]);
+		currentProduct.set(1, grid.get(row).get(col + 1));
-		currentProduct.set(2, grid[row][col + 2]);
+		currentProduct.set(2, grid.get(row).get(col + 2));
-		currentProduct.set(3, grid[row][col + 3]);
+		currentProduct.set(3, grid.get(row).get(col + 3));
 
 		//If the current number's product is greater than the greatest product replace it
 		if(ArrayAlgorithms.getProd(currentProduct) > ArrayAlgorithms.getProd(greatestProduct)){
@@ -171,10 +164,10 @@ public class Problem11 extends Problem{
 	//Check below the current location
 	private void checkDown(ArrayList<Integer> currentProduct, int row, int col){
 		//Fill the product
-		currentProduct.set(0, grid[row][col]);
+		currentProduct.set(0, grid.get(row).get(col));
-		currentProduct.set(1, grid[row + 1][col]);
+		currentProduct.set(1, grid.get(row + 1).get(col));
-		currentProduct.set(2, grid[row + 2][col]);
+		currentProduct.set(2, grid.get(row + 2).get(col));
-		currentProduct.set(3, grid[row + 3][col]);
+		currentProduct.set(3, grid.get(row + 3).get(col));
 
 		//If the current number's product is greater than the greatest product replace it
 		if(ArrayAlgorithms.getProd(currentProduct) > ArrayAlgorithms.getProd(greatestProduct)){
@@ -187,10 +180,10 @@ public class Problem11 extends Problem{
 	//Check the left-down diagonal from the current location
 	private void checkLeftDown(ArrayList<Integer> currentProduct, int row, int col){
 		//Fill the product
-		currentProduct.set(0, grid[row][col]);
+		currentProduct.set(0, grid.get(row).get(col));
-		currentProduct.set(1, grid[row + 1][col - 1]);
+		currentProduct.set(1, grid.get(row + 1).get(col - 1));
-		currentProduct.set(2, grid[row + 2][col - 2]);
+		currentProduct.set(2, grid.get(row + 2).get(col - 2));
-		currentProduct.set(3, grid[row + 3][col - 3]);
+		currentProduct.set(3, grid.get(row + 3).get(col - 3));
 
 		//If the current number's product is greater than the greatest product replace it
 		if(ArrayAlgorithms.getProd(currentProduct) > ArrayAlgorithms.getProd(greatestProduct)){
@@ -203,10 +196,10 @@ public class Problem11 extends Problem{
 	//Check the right-down diagonal from the current location
 	private void checkRightDown(ArrayList<Integer> currentProduct, int row, int col){
 		//Fill the product
-		currentProduct.set(0, grid[row][col]);
+		currentProduct.set(0, grid.get(row).get(col));
-		currentProduct.set(1, grid[row + 1][col + 1]);
+		currentProduct.set(1, grid.get(row + 1).get(col + 1));
-		currentProduct.set(2, grid[row + 2][col + 2]);
+		currentProduct.set(1, grid.get(row + 2).get(col + 2));
-		currentProduct.set(3, grid[row + 3][col + 3]);
+		currentProduct.set(1, grid.get(row + 3).get(col + 3));
 
 		//If the current number's product is greater than the greatest product replace it
 		if(ArrayAlgorithms.getProd(currentProduct) > ArrayAlgorithms.getProd(greatestProduct)){

src/main/java/com/mattrixwv/project_euler/problems/Problem12.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem12.java
 //Matthew Ellison
 // Created: 03-04-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 //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/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -34,9 +34,9 @@ public class Problem12 extends Problem{
 	//Static variables
 	private static final Long GOAL_DIVISORS = 500L;	//The minimum number of divisors that you want
 	//Instance variables
-	private long sum;		//The sum of the numbers up to counter
+	protected long sum;		//The sum of the numbers up to counter
-	private long counter;	//The next number to be added to sum
+	protected long counter;	//The next number to be added to sum
-	private List<Long> divisors;	//Holds the divisors of the triangular number sum
+	protected List<Long> divisors;	//Holds the divisors of the triangular number sum
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem13.java

@@ -1,113 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem13.java
 //Matthew Ellison
 // Created: 03-04-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 //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/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -125,7 +23,11 @@
 package com.mattrixwv.project_euler.problems;
 
 
+import java.io.File;
+import java.io.IOException;
 import java.math.BigInteger;
+import java.nio.file.Files;
+import java.security.InvalidParameterException;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -134,127 +36,40 @@ import com.mattrixwv.ArrayAlgorithms;
 
 public class Problem13 extends Problem{
 	//Variables
+	//Static variables
+	protected static String FILE_NAME = "files/Problem13Numbers.txt";
+	protected static ArrayList<BigInteger> nums;	//Holds the numbers that are being summed
 	//Instance variables
-	private ArrayList<BigInteger> nums;	//Holds the numbers that are being summed
+	protected BigInteger sum;	//The sum of all the numbers
-	private BigInteger sum;	//The sum of all the numbers
 
 	//Functions
 	//Constructor
 	public Problem13(){
 		super("Work out the first ten digits of the sum of the one-hundred 50-digit numbers");
-		nums = new ArrayList<>();
-		reserveVectors();
-		setNums();
 		sum = BigInteger.ZERO;
 	}
 	//Operational functions
-	//A function to set the nums vector
+	//Read number from file into nums
-	private void reserveVectors(){
+	private void readFile(){
-		nums.ensureCapacity(100);
+		if(nums != null){
-	}
+			return;
-	//Reserve the size of the vector to speed up insertion
+		}
-	private void setNums(){
+		File file = new File(FILE_NAME);
-		//Setup the array
+		if(file.exists()){
-		nums.add(new BigInteger("37107287533902102798797998220837590246510135740250"));
+			try{
-		nums.add(new BigInteger("46376937677490009712648124896970078050417018260538"));
+				List<String> lines = Files.readAllLines(file.toPath());
-		nums.add(new BigInteger("74324986199524741059474233309513058123726617309629"));
+				nums = new ArrayList<>();
-		nums.add(new BigInteger("91942213363574161572522430563301811072406154908250"));
+				for(String line : lines){
-		nums.add(new BigInteger("23067588207539346171171980310421047513778063246676"));
+					nums.add(new BigInteger(line));
-		nums.add(new BigInteger("89261670696623633820136378418383684178734361726757"));
+				}
-		nums.add(new BigInteger("28112879812849979408065481931592621691275889832738"));
+			}
-		nums.add(new BigInteger("44274228917432520321923589422876796487670272189318"));
+			catch(IOException error){
-		nums.add(new BigInteger("47451445736001306439091167216856844588711603153276"));
+				throw new InvalidParameterException("Error reading file", error);
-		nums.add(new BigInteger("70386486105843025439939619828917593665686757934951"));
+			}
-		nums.add(new BigInteger("62176457141856560629502157223196586755079324193331"));
+		}
-		nums.add(new BigInteger("64906352462741904929101432445813822663347944758178"));
+		else{
-		nums.add(new BigInteger("92575867718337217661963751590579239728245598838407"));
+			throw new InvalidParameterException("Error opening file");
-		nums.add(new BigInteger("58203565325359399008402633568948830189458628227828"));
+		}
-		nums.add(new BigInteger("80181199384826282014278194139940567587151170094390"));
-		nums.add(new BigInteger("35398664372827112653829987240784473053190104293586"));
-		nums.add(new BigInteger("86515506006295864861532075273371959191420517255829"));
-		nums.add(new BigInteger("71693888707715466499115593487603532921714970056938"));
-		nums.add(new BigInteger("54370070576826684624621495650076471787294438377604"));
-		nums.add(new BigInteger("53282654108756828443191190634694037855217779295145"));
-		nums.add(new BigInteger("36123272525000296071075082563815656710885258350721"));
-		nums.add(new BigInteger("45876576172410976447339110607218265236877223636045"));
-		nums.add(new BigInteger("17423706905851860660448207621209813287860733969412"));
-		nums.add(new BigInteger("81142660418086830619328460811191061556940512689692"));
-		nums.add(new BigInteger("51934325451728388641918047049293215058642563049483"));
-		nums.add(new BigInteger("62467221648435076201727918039944693004732956340691"));
-		nums.add(new BigInteger("15732444386908125794514089057706229429197107928209"));
-		nums.add(new BigInteger("55037687525678773091862540744969844508330393682126"));
-		nums.add(new BigInteger("18336384825330154686196124348767681297534375946515"));
-		nums.add(new BigInteger("80386287592878490201521685554828717201219257766954"));
-		nums.add(new BigInteger("78182833757993103614740356856449095527097864797581"));
-		nums.add(new BigInteger("16726320100436897842553539920931837441497806860984"));
-		nums.add(new BigInteger("48403098129077791799088218795327364475675590848030"));
-		nums.add(new BigInteger("87086987551392711854517078544161852424320693150332"));
-		nums.add(new BigInteger("59959406895756536782107074926966537676326235447210"));
-		nums.add(new BigInteger("69793950679652694742597709739166693763042633987085"));
-		nums.add(new BigInteger("41052684708299085211399427365734116182760315001271"));
-		nums.add(new BigInteger("65378607361501080857009149939512557028198746004375"));
-		nums.add(new BigInteger("35829035317434717326932123578154982629742552737307"));
-		nums.add(new BigInteger("94953759765105305946966067683156574377167401875275"));
-		nums.add(new BigInteger("88902802571733229619176668713819931811048770190271"));
-		nums.add(new BigInteger("25267680276078003013678680992525463401061632866526"));
-		nums.add(new BigInteger("36270218540497705585629946580636237993140746255962"));
-		nums.add(new BigInteger("24074486908231174977792365466257246923322810917141"));
-		nums.add(new BigInteger("91430288197103288597806669760892938638285025333403"));
-		nums.add(new BigInteger("34413065578016127815921815005561868836468420090470"));
-		nums.add(new BigInteger("23053081172816430487623791969842487255036638784583"));
-		nums.add(new BigInteger("11487696932154902810424020138335124462181441773470"));
-		nums.add(new BigInteger("63783299490636259666498587618221225225512486764533"));
-		nums.add(new BigInteger("67720186971698544312419572409913959008952310058822"));
-		nums.add(new BigInteger("95548255300263520781532296796249481641953868218774"));
-		nums.add(new BigInteger("76085327132285723110424803456124867697064507995236"));
-		nums.add(new BigInteger("37774242535411291684276865538926205024910326572967"));
-		nums.add(new BigInteger("23701913275725675285653248258265463092207058596522"));
-		nums.add(new BigInteger("29798860272258331913126375147341994889534765745501"));
-		nums.add(new BigInteger("18495701454879288984856827726077713721403798879715"));
-		nums.add(new BigInteger("38298203783031473527721580348144513491373226651381"));
-		nums.add(new BigInteger("34829543829199918180278916522431027392251122869539"));
-		nums.add(new BigInteger("40957953066405232632538044100059654939159879593635"));
-		nums.add(new BigInteger("29746152185502371307642255121183693803580388584903"));
-		nums.add(new BigInteger("41698116222072977186158236678424689157993532961922"));
-		nums.add(new BigInteger("62467957194401269043877107275048102390895523597457"));
-		nums.add(new BigInteger("23189706772547915061505504953922979530901129967519"));
-		nums.add(new BigInteger("86188088225875314529584099251203829009407770775672"));
-		nums.add(new BigInteger("11306739708304724483816533873502340845647058077308"));
-		nums.add(new BigInteger("82959174767140363198008187129011875491310547126581"));
-		nums.add(new BigInteger("97623331044818386269515456334926366572897563400500"));
-		nums.add(new BigInteger("42846280183517070527831839425882145521227251250327"));
-		nums.add(new BigInteger("55121603546981200581762165212827652751691296897789"));
-		nums.add(new BigInteger("32238195734329339946437501907836945765883352399886"));
-		nums.add(new BigInteger("75506164965184775180738168837861091527357929701337"));
-		nums.add(new BigInteger("62177842752192623401942399639168044983993173312731"));
-		nums.add(new BigInteger("32924185707147349566916674687634660915035914677504"));
-		nums.add(new BigInteger("99518671430235219628894890102423325116913619626622"));
-		nums.add(new BigInteger("73267460800591547471830798392868535206946944540724"));
-		nums.add(new BigInteger("76841822524674417161514036427982273348055556214818"));
-		nums.add(new BigInteger("97142617910342598647204516893989422179826088076852"));
-		nums.add(new BigInteger("87783646182799346313767754307809363333018982642090"));
-		nums.add(new BigInteger("10848802521674670883215120185883543223812876952786"));
-		nums.add(new BigInteger("71329612474782464538636993009049310363619763878039"));
-		nums.add(new BigInteger("62184073572399794223406235393808339651327408011116"));
-		nums.add(new BigInteger("66627891981488087797941876876144230030984490851411"));
-		nums.add(new BigInteger("60661826293682836764744779239180335110989069790714"));
-		nums.add(new BigInteger("85786944089552990653640447425576083659976645795096"));
-		nums.add(new BigInteger("66024396409905389607120198219976047599490197230297"));
-		nums.add(new BigInteger("64913982680032973156037120041377903785566085089252"));
-		nums.add(new BigInteger("16730939319872750275468906903707539413042652315011"));
-		nums.add(new BigInteger("94809377245048795150954100921645863754710598436791"));
-		nums.add(new BigInteger("78639167021187492431995700641917969777599028300699"));
-		nums.add(new BigInteger("15368713711936614952811305876380278410754449733078"));
-		nums.add(new BigInteger("40789923115535562561142322423255033685442488917353"));
-		nums.add(new BigInteger("44889911501440648020369068063960672322193204149535"));
-		nums.add(new BigInteger("41503128880339536053299340368006977710650566631954"));
-		nums.add(new BigInteger("81234880673210146739058568557934581403627822703280"));
-		nums.add(new BigInteger("82616570773948327592232845941706525094512325230608"));
-		nums.add(new BigInteger("22918802058777319719839450180888072429661980811197"));
-		nums.add(new BigInteger("77158542502016545090413245809786882778948721859617"));
-		nums.add(new BigInteger("72107838435069186155435662884062257473692284509516"));
-		nums.add(new BigInteger("20849603980134001723930671666823555245252804609722"));
-		nums.add(new BigInteger("53503534226472524250874054075591789781264330331690"));
 	}
 	//Solve the problem
 	@Override
@@ -264,6 +79,9 @@ public class Problem13 extends Problem{
 			return;
 		}
 
+		//Read the file into the number
+		readFile();
+
 		//Start the timer
 		timer.start();
 
@@ -283,9 +101,6 @@ public class Problem13 extends Problem{
 	public void reset(){
 		super.reset();
 		sum = BigInteger.ZERO;
-		nums.clear();
-		reserveVectors();
-		setNums();
 	}
 	//Gets
 	//Returns the result of solving the problem

src/main/java/com/mattrixwv/project_euler/problems/Problem14.java

@@ -1,7 +1,7 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem14.java
 //Matthew Ellison
 // Created: 03-04-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 /*
 The following iterative sequence is defined for the set of positive integers:
 n → n/2 (n is even)
@@ -10,7 +10,7 @@ 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/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -33,8 +33,8 @@ public class Problem14 extends Problem{
 	//Static variables
 	private static final long MAX_NUM = 1000000L - 1L;	//This is the top number that you will be checking against the series
 	//Instance variables
-	private long maxLength;	//This is the length of the longest chain
+	protected long maxLength;	//This is the length of the longest chain
-	private long maxNum;	//This is the starting number of the longest chain
+	protected long maxNum;		//This is the starting number of the longest chain
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem15.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem15.java
 //Matthew Ellison
 // Created: 03-04-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 //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/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -29,7 +29,7 @@ public class Problem15 extends Problem{
 	protected static int gridWidth = 20;	//The width of the box to traverse
 	protected static int gridLength = 20;	//The height of the box to traverse
 	//Instance variables
-	private long numOfRoutes;	//The number of routes from 0, 0 to 20, 20
+	protected long numOfRoutes;	//The number of routes from 0, 0 to 20, 20
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem16.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem16.java
 //Matthew Ellison
 // Created: 03-04-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 //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/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -32,8 +32,8 @@ public class Problem16 extends Problem{
 	private static final int NUM_TO_POWER = 2;	//The number that is going to be raised to a power
 	private static final int POWER = 1000;	//The power that the number is going to be raised to
 	//Instance variables
-	private BigInteger num;	//The number to be calculated
+	protected BigInteger num;		//The number to be calculated
-	private int sumOfElements;	//The sum of all digits in the number
+	protected int sumOfElements;	//The sum of all digits in the number
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem17.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem17.java
 //Matthew Ellison
 // Created: 03-04-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 //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/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -23,17 +23,13 @@
 package com.mattrixwv.project_euler.problems;
 
 
-import com.mattrixwv.exceptions.InvalidResult;
-import com.mattrixwv.project_euler.exceptions.Unsolved;
-
-
 public class Problem17 extends Problem{
 	//Variables
 	//Static variables
 	private static final int START_NUM = 1;		//This is the smallest number to get the words of
 	private static final int STOP_NUM = 1000;	//This is the largest number to get the words of
 	//Instance variables
-	private long letterCount;	//This is the cumulative number of letters in the words of the numbers
+	protected long letterCount;	//This is the cumulative number of letters in the words of the numbers
 
 	//Functions
 	//Constructor
@@ -76,13 +72,14 @@ public class Problem17 extends Problem{
 		letterCount = 0;
 	}
 	//This function makes a word out of the number passed into it
-	private String makeWordFromNum(int number){
+	protected String makeWordFromNum(int number){
 		int num = number;
 		StringBuilder numberString = new StringBuilder();
 		//Starting with the largest digit create a string based on the number passed in
 		//Check for negative
 		if(num < 0){
 			numberString.append("negative ");
+			num = -num;
 		}
 
 		//Check if the number is zero
@@ -105,7 +102,7 @@ public class Problem17 extends Problem{
 		}
 
 		//Insert an and if there is need
-		if(!numberString.toString().isBlank() && (num > 0)){
+		if(!numberString.toString().isBlank() && (numberString.indexOf("negative") != 0) && (num > 0)){
 			numberString.append(" and ");
 		}
 
@@ -122,7 +119,6 @@ public class Problem17 extends Problem{
 				case 4: numberString.append("forty"); break;
 				case 3: numberString.append("thirty"); break;
 				case 2: numberString.append("twenty"); break;
-				default: throw new InvalidResult("tensPlace < 2");
 			}
 			num -= (tensPlace * 10);
 			//If there is something left in the number you will need a dash to separate the tens and ones place
@@ -144,7 +140,6 @@ public class Problem17 extends Problem{
 				case 2: numberString.append("twelve"); break;
 				case 1: numberString.append("eleven"); break;
 				case 0: numberString.append("ten"); break;
-				default: throw new InvalidResult("onesPlace > 9");
 			}
 			//If this was hit the number was completed
 			num = 0;
@@ -162,17 +157,11 @@ public class Problem17 extends Problem{
 				case 3: numberString.append("three"); break;
 				case 2: numberString.append("two"); break;
 				case 1: numberString.append("one"); break;
-				default: throw new InvalidResult("onesPlace > 9");
 			}
 			//If this was hit the number was completed
 			num = 0;
 		}
 
-		//If the number is not 0 there was a problem
-		if(num != 0){
-			throw new Unsolved("The number " + number + " was not completely reduced!\nRemainder is " + num);
-		}
-
 		//Return the string
 		return numberString.toString();
 	}

src/main/java/com/mattrixwv/project_euler/problems/Problem18.java

@@ -1,29 +1,12 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem18.java
 //Matthew Ellison
 // Created: 03-11-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 //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/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -41,9 +24,13 @@
 package com.mattrixwv.project_euler.problems;
 
 
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.security.InvalidParameterException;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Iterator;
+import java.util.List;
 import java.util.StringJoiner;
 
 
@@ -75,27 +62,8 @@ public class Problem18 extends Problem{
 
 	//Variables
 	//Static variables
+	protected String FILE_NAME = "files/Problem18Pyramid.txt";
 	protected static ArrayList<ArrayList<Integer>> list;	//The list to hold the numbers in
-	static{
-		list = new ArrayList<>(
-			Arrays.asList(
-				new ArrayList<Integer>(Arrays.asList(75)),
-				new ArrayList<Integer>(Arrays.asList(95, 64)),
-				new ArrayList<Integer>(Arrays.asList(17, 47, 82)),
-				new ArrayList<Integer>(Arrays.asList(18, 35, 87, 10)),
-				new ArrayList<Integer>(Arrays.asList(20, 04, 82, 47, 65)),
-				new ArrayList<Integer>(Arrays.asList(19, 01, 23, 75, 03, 34)),
-				new ArrayList<Integer>(Arrays.asList(88, 02, 77, 73, 07, 63, 67)),
-				new ArrayList<Integer>(Arrays.asList(99, 65, 04, 28, 06, 16, 70, 92)),
-				new ArrayList<Integer>(Arrays.asList(41, 41, 26, 56, 83, 40, 80, 70, 33)),
-				new ArrayList<Integer>(Arrays.asList(41, 48, 72, 33, 47, 32, 37, 16, 94, 29)),
-				new ArrayList<Integer>(Arrays.asList(53, 71, 44, 65, 25, 43, 91, 52, 97, 51, 14)),
-				new ArrayList<Integer>(Arrays.asList(70, 11, 33, 28, 77, 73, 17, 78, 39, 68, 17, 57)),
-				new ArrayList<Integer>(Arrays.asList(91, 71, 52, 38, 17, 14, 91, 43, 58, 50, 27, 29, 48)),
-				new ArrayList<Integer>(Arrays.asList(63, 66, 04, 68, 89, 53, 67, 30, 73, 16, 69, 87, 40, 31)),
-				new ArrayList<Integer>(Arrays.asList(04, 62, 98, 27, 23, 9, 70, 98, 73, 93, 38, 53, 60, 04, 23))
-			));
-	}
 	//Instance variables
 	protected ArrayList<Location> foundPoints;	//For the points that you have already found the shortest distance to
 	protected ArrayList<Location> possiblePoints;	//For the locations you are checking this round
@@ -110,6 +78,32 @@ public class Problem18 extends Problem{
 		actualTotal = 0;
 	}
 	//Operational functions
+	//Read number from file into number
+	private void readFile(){
+		if(list != null){
+			return;
+		}
+		File file = new File(FILE_NAME);
+		if(file.exists()){
+			try{
+				List<String> lines = Files.readAllLines(file.toPath());
+				list = new ArrayList<>();
+				for(String line : lines){
+					ArrayList<Integer> working = new ArrayList<>();
+					for(String num : line.split(" ")){
+						working.add(Integer.parseInt(num));
+					}
+					list.add(working);
+				}
+			}
+			catch(IOException error){
+				throw new InvalidParameterException("Error reading file", error);
+			}
+		}
+		else{
+			throw new InvalidParameterException("Error opening file");
+		}
+	}
 	//This function turns every number in the array into (100 - num) to allow you to find the largest numbers rather than the smallest
 	protected void invert(ArrayList<ArrayList<Integer>> list){
 		//Loop through every row in the list
@@ -132,6 +126,9 @@ public class Problem18 extends Problem{
 			return;
 		}
 
+		//Read the file into the list
+		readFile();
+
 		//Start the timer
 		timer.start();
 
@@ -237,10 +234,6 @@ public class Problem18 extends Problem{
 			int loc = foundPoints.size() - 1;
 			Location toAdd = null;
 			while(!found){
-				if(loc < 0){
-					results.add("Error: Location < 0\n");
-					System.exit(1);
-				}
 				Iterator<Location> it = foundPoints.iterator();
 				Location tempLoc = new Location(0, 0, 0, false);
 				for(int cnt = 0;cnt < loc;++cnt){

src/main/java/com/mattrixwv/project_euler/problems/Problem19.java

@@ -1,7 +1,7 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem19.java
 //Matthew Ellison
 // Created: 03-13-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 //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.
@@ -16,7 +16,7 @@ A leap year occurs on any year evenly divisible by 4, but not on a century unles
 */
 //Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -33,8 +33,10 @@ A leap year occurs on any year evenly divisible by 4, but not on a century unles
 */
 package com.mattrixwv.project_euler.problems;
 
+
 import com.mattrixwv.exceptions.InvalidResult;
 
+
 public class Problem19 extends Problem{
 	//Variables
 	//Static variables
@@ -43,7 +45,7 @@ public class Problem19 extends Problem{
 	private static final int START_YEAR = 1901;	//The first year we are going to test
 	private static final int END_YEAR = 2000;	//The last year we are going to test
 	//Instance variables
-	private long totalSundays;	//Keep track of the number of sundays
+	protected long totalSundays;	//Keep track of the number of sundays
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem2.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem2.java
 //Matthew Ellison
 // Created: 03-01-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 //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/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -33,7 +33,7 @@ public class Problem2 extends Problem{
 	//Static variables
 	private static final int TOP_NUM = 4000000 - 1;	//The largest number that will be checked as a fibonacci number
 	//Instance variables
-	private int fullSum;	//Holds the sum of all the numbers
+	protected int fullSum;	//Holds the sum of all the numbers
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem20.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem20.java
 //Matthew Ellison
 // Created: 03-14-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 //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/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -31,8 +31,8 @@ public class Problem20 extends Problem{
 	//Static variables
 	private static final int TOP_NUM = 100;	//The largest number that will be multiplied
 	//Instance variables
-	private BigInteger num;	//Holds the number 100!
+	protected BigInteger num;	//Holds the number 100!
-	private long sum;	//The sum of the digits of num
+	protected long sum;	//The sum of the digits of num
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem21.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem21.java
 //Matthew Ellison
 // Created: 03-18-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 //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/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -36,8 +36,8 @@ public class Problem21 extends Problem{
 	//Static variables
 	private static final int LIMIT = 10000;	//The number that is > the largest number to be checked
 	//Instance variables
-	private ArrayList<Integer> divisorSum;	//Holds the sum of the divisors of the subscript number
+	protected ArrayList<Integer> divisorSum;	//Holds the sum of the divisors of the subscript number
-	private ArrayList<Integer> amicable;	//Holds all amicable numbers
+	protected ArrayList<Integer> amicable;	//Holds all amicable numbers
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem22.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem22.java
 //Matthew Ellison
 // Created: 03-20-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 //What is the total of all the name scores in this file?
 //Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -37,13 +37,13 @@ import java.util.List;
 public class Problem22 extends Problem{
 	//Variables
 	//Static variables
-	private static final String FILE_NAME = "files/Problem22Names.txt";
+	protected static String FILE_NAME = "files/Problem22Names.txt";
 	//Holds the names that will be scored
-	private static final ArrayList<String> names = new ArrayList<>();
+	protected static ArrayList<String> names = new ArrayList<>();
 	//Instance variables
-	private ArrayList<Long> sums;	//Holds the score based on the sum of the characters in the name
+	protected ArrayList<Long> sums;	//Holds the score based on the sum of the characters in the name
-	private ArrayList<Long> prod;	//Holds the score based on the sum of the characters and the location in alphabetical order
+	protected ArrayList<Long> prod;	//Holds the score based on the sum of the characters and the location in alphabetical order
-	private long sum;	//Holds the sum of the scores
+	protected long sum;	//Holds the sum of the scores
 
 	//Functions
 	//Constructor
@@ -71,7 +71,7 @@ public class Problem22 extends Problem{
 				}
 			}
 			catch(IOException error){
-				throw new InvalidParameterException(error.getMessage());
+				throw new InvalidParameterException("Error reading file", error);
 			}
 		}
 		else{

src/main/java/com/mattrixwv/project_euler/problems/Problem23.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem23.java
 //Matthew Ellison
 // Created: 03-22-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 //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/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -35,8 +35,9 @@ public class Problem23 extends Problem{
 	//Static variables
 	protected static int maxNum = 28123;	//The largest number to be checked
 	//Instance variables
-	private ArrayList<Integer> divisorSums;	//This gives the sum of the divisors at subscripts
+	protected ArrayList<Integer> divisorSums;	//This gives the sum of the divisors at subscripts
-	private long sum;	//The sum of all the numbers we are looking for
+	protected long sum;	//The sum of all the numbers we are looking for
+
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem24.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem24.java
 //Matthew Ellison
 // Created: 03-24-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 //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/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -35,7 +35,7 @@ public class Problem24 extends Problem{
 	protected static int neededPerm = 1000000;	//The number of the permutation that you need
 	protected static String nums = "0123456789";	//All of the characters that we need to get the permutations of
 	//Instance variables
-	private List<String> permutations;	//Holds all of the permutations of the string nums
+	protected List<String> permutations;	//Holds all of the permutations of the string nums
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem25.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem25.java
 //Matthew Ellison
 // Created: 03-25-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 //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/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -33,8 +33,8 @@ public class Problem25 extends Problem{
 	//Static variables
 	private static final int NUM_DIGITS = 1000;	//The number of digits to calculate up to
 	//Instance variables
-	private BigInteger number;	//The current Fibonacci number
+	protected BigInteger number;	//The current Fibonacci number
-	private BigInteger index;	//The index of the current Fibonacci number just calculated
+	protected BigInteger index;		//The index of the current Fibonacci number just calculated
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem26.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem26.java
 //Matthew Ellison
 // Created: 07-28-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 //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/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -31,8 +31,9 @@ public class Problem26 extends Problem{
 	//Static variables
 	private static final int TOP_NUM = 999;	//The largest denominator to test
 	//Instance variables
-	private int longestCycle;	//The length of the longest cycle
+	protected int longestCycle;		//The length of the longest cycle
-	private int longestNumber;	//The starting denominator of the longest cycle
+	protected int longestNumber;	//The starting denominator of the longest cycle
+
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem27.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem27.java
 //Matthew Ellison
 // Created: 09-15-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 //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/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -32,9 +32,9 @@ public class Problem27 extends Problem{
 	private static final int LARGEST_POSSIBLE_A = 999;
 	private static final int LARGEST_POSSIBLE_B = 1000;
 	//Instance variables
-	private int topA;	//The A for the most n's generated
+	protected int topA;	//The A for the most n's generated
-	private int topB;	//The B for the most n's generated
+	protected int topB;	//The B for the most n's generated
-	private int topN;	//The most n's generated
+	protected int topN;	//The most n's generated
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem28.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem28.java
 //Matthew Ellison
 // Created: 09-22-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 //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/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -30,8 +30,8 @@ import java.util.List;
 public class Problem28 extends Problem{
 	//Variables
 	//Instance variables
-	private ArrayList<ArrayList<Integer>> grid;	//Holds the grid that we will be filling and searching
+	protected ArrayList<ArrayList<Integer>> grid;	//Holds the grid that we will be filling and searching
-	private int sumOfDiagonals;	//Holds the sum of the diagonals of the grid
+	protected int sumOfDiagonals;	//Holds the sum of the diagonals of the grid
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem29.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem29.java
 //Matthew Ellison
 // Created: 10-09-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 //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/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -36,7 +36,7 @@ public class Problem29 extends Problem{
 	private static final int BOTTOM_B = 2;	//The lowest possible value for b
 	private static final int TOP_B = 100;	//The highest possible value for b
 	//Instance variables
-	private ArrayList<BigInteger> unique;	//Holds all unique values generated
+	protected List<BigInteger> unique;	//Holds all unique values generated
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem3.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem3.java
 //Matthew Ellison
 // Created: 03-01-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 //The largest prime factor of 600851475143
 //Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -35,7 +35,7 @@ public class Problem3 extends Problem{
 	//Static variables
 	private static final long GOAL_NUMBER = 600851475143L;	//The number that needs factored
 	//Instance variables
-	private List<Long> factors;	//Holds the factors of goalNumber
+	protected List<Long> factors;	//Holds the factors of goalNumber
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem30.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem30.java
 //Matthew Ellison
 // Created: 10-27-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 //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/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -36,8 +36,8 @@ public class Problem30 extends Problem{
 	private static final long BOTTOM_NUM = 2;		//Starts with 2 because 0 and 1 don't count
 	private static final long POWER_RAISED = 5;		//This is the power that the digits are raised to
 	//Instance variables
-	private ArrayList<Long> sumOfFifthNumbers;	//This is an ArrayList of the numbers that are the sum of the fifth power of their digits
+	protected List<Long> sumOfFifthNumbers;	//This is an ArrayList of the numbers that are the sum of the fifth power of their digits
-	private long sum;	//This is the sum of the sumOfFifthNumbers array
+	protected long sum;	//This is the sum of the sumOfFifthNumbers array
 
 	//Functions
 	//Operational functions

src/main/java/com/mattrixwv/project_euler/problems/Problem31.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem31.java
 //Matthew Ellison
 // Created: 06-19-20
-//Modified: 08-20-22
+//Modified: 06-27-23
 //How many different ways can £2 be made using any number of coins?
 //Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -28,7 +28,7 @@ public class Problem31 extends Problem{
 	//Static variables
 	private static final int DESIRED_VALUE = 200;	//The value of coins we want
 	//Instance variables
-	private int permutations;	//The number of permutations that are found
+	protected int permutations;	//The number of permutations that are found
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem32.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem32.java
 //Matthew Ellison
 // Created: 07-27-20
-//Modified: 08-20-22
+//Modified: 06-27-23
 //Find the sum of all products whose multiplicand/multiplier/product identity can be written as a 1 through 9 pandigital.
 //Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -31,18 +31,16 @@ import com.mattrixwv.StringAlgorithms;
 public class Problem32 extends Problem{
 	//Structures
 	//Holds the set of numbers that make a product
-	private class ProductSet{
+	protected class ProductSet{
 		private int multiplicand;
 		private int multiplier;
 		public ProductSet(int multiplicand, int multiplier){
 			this.multiplicand = multiplicand;
 			this.multiplier = multiplier;
 		}
-		@SuppressWarnings("unused")
 		public int getMultiplicand(){
 			return multiplicand;
 		}
-		@SuppressWarnings("unused")
 		public int getMultiplier(){
 			return multiplier;
 		}
@@ -78,8 +76,8 @@ public class Problem32 extends Problem{
 	private static final int TOP_MULTIPLICAND = 99;	//The largest multiplicand to check
 	private static final int TOP_MULTIPLIER = 4999;	//The largest multiplier to check
 	//Instance variables
-	ArrayList<ProductSet> listOfProducts;	//The list of unique products that are 1-9 pandigital
+	protected ArrayList<ProductSet> listOfProducts;	//The list of unique products that are 1-9 pandigital
-	long sumOfPandigitals;	//The sum of the products of the pandigital numbers
+	protected long sumOfPandigitals;	//The sum of the products of the pandigital numbers
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem33.java

@@ -1,7 +1,7 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem33.java
 //Matthew Ellison
 // Created: 02-05-21
-//Modified: 08-20-22
+//Modified: 06-27-23
 /*
 The fraction 49/98 is a curious fraction, as an inexperienced mathematician in attempting to simplify it may incorrectly believe that 49/98 = 4/8, which is correct, is obtained by cancelling the 9s
 We shall consider fractions like, 30/50 = 3/5, to be trivial examples
@@ -10,7 +10,7 @@ If the product of these four fractions is given in its lowest common terms, find
 */
 //Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -43,9 +43,9 @@ public class Problem33 extends Problem{
 	private static final int MIN_DENOMINATOR = 11;	//The lowest the denominator can be
 	private static final int MAX_DENOMINATOR = 99;	//The highest the denominator can be
 	//Instance variables
-	private ArrayList<Integer> numerators;		//Holds the numerators that were found
+	protected ArrayList<Integer> numerators;	//Holds the numerators that were found
-	private ArrayList<Integer> denominators;	//Holds the denominators that were found
+	protected ArrayList<Integer> denominators;	//Holds the denominators that were found
-	private int prodDenominator;				//Holds the answer to the question
+	protected int prodDenominator;	//Holds the answer to the question
 
 	//Functions
 	//Constructor
@@ -127,6 +127,7 @@ public class Problem33 extends Problem{
 		super.reset();
 		numerators.clear();
 		denominators.clear();
+		prodDenominator = 1;
 	}
 	//Gets
 	//Returns the result of solving the problem

src/main/java/com/mattrixwv/project_euler/problems/Problem34.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem34.java
 //Matthew Ellison
 // Created: 02-05-21
-//Modified: 08-20-22
+//Modified: 06-27-23
 //Find the sum of all numbers which are equal to the sum of the factorial of their digits
 //Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -34,8 +34,8 @@ public class Problem34 extends Problem{
 	//Static variables
 	private static final int MAX_NUM = 1499999;	//The largest num that can be the sum of its own digits
 	//Instance variables
-	private ArrayList<Integer> factorials;	//Holds the pre-computed factorials of the numbers 0-9
+	protected List<Integer> factorials;	//Holds the pre-computed factorials of the numbers 0-9
-	private int sum;	//Holds the sum of all numbers equal to the sum of their digit's factorials
+	protected int sum;	//Holds the sum of all numbers equal to the sum of their digit's factorials
 
 	//Functions
 	//Constructor
@@ -91,7 +91,7 @@ public class Problem34 extends Problem{
 	public void reset(){
 		super.reset();
 		sum = 0;
-		factorials = new ArrayList<>();
+		factorials.clear();
 		for(int cnt = 0;cnt <= 9;++cnt){
 			factorials.add(0);
 		}

src/main/java/com/mattrixwv/project_euler/problems/Problem35.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem35.java
 //Matthew Ellison
 // Created: 06-05-21
-//Modified: 08-20-22
+//Modified: 06-27-23
 //How many circular primes are there below one million?
 //Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -34,8 +34,8 @@ public class Problem35 extends Problem{
 	//Static variables
 	protected static int maxNum = 999999;	//The largest number that we are checking for primes
 	//Instance variables
-	private List<Integer> primes;	//The primes below MAX_NUM
+	protected List<Integer> primes;	//The primes below MAX_NUM
-	private ArrayList<Integer> circularPrimes;	//The circular primes below MAX_NUM
+	protected List<Integer> circularPrimes;	//The circular primes below MAX_NUM
 	//Functions
 	//Returns a list of all rotations of a string passed to it
 	private ArrayList<String> getRotations(String str){

src/main/java/com/mattrixwv/project_euler/problems/Problem36.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem36.java
 //Matthew Ellison
 // Created: 06-29-21
-//Modified: 08-20-22
+//Modified: 06-30-23
 //Find the sum of all numbers, less than one million, which are palindromic in base 10 and base 2.
 //Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -36,8 +36,8 @@ public class Problem36 extends Problem{
 	//Static variables
 	private static final int MAX_NUM = 999999;	//The largest number that will be checked
 	//Instance variables
-	private ArrayList<Integer> palindromes;	//All numbers that are palindromes in base 10 and 2
+	protected ArrayList<Integer> palindromes;	//All numbers that are palindromes in base 10 and 2
-	private int sum;	//The sum of all elements in the list of palindromes
+	protected int sum;	//The sum of all elements in the list of palindromes
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem37.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem37.java
 //Matthew Ellison
 // Created: 07-01-21
-//Modified: 08-20-22
+//Modified: 06-30-23
 //Find the sum of the only eleven primes that are both truncatable from left to right and right to left (2, 3, 5, and 7 are not counted).
 //Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -36,8 +36,8 @@ public class Problem37 extends Problem{
 	//Static variables
 	private static final long LAST_PRIME_BEFORE_CHECK = 7;	//The last prime before 11 since single digit primes aren't checked
 	//Instance variables
-	private ArrayList<Long> truncPrimes;	//All numbers that are truncatable primes
+	protected List<Long> truncPrimes;	//All numbers that are truncatable primes
-	private long sum;	//The sum of all elements in truncPrimes
+	protected long sum;	//The sum of all elements in truncPrimes
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem38.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem37.java
 //Matthew Ellison
 // Created: 10-11-21
-//Modified: 08-20-22
+//Modified: 06-30-23
 //What is the largest 1-9 pandigital number that can be formed as the concatenated product of an integer with 1, 2, ... n where n > 1
 //Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -31,8 +31,8 @@ public class Problem38 extends Problem{
 	//Static variables
 	private static final long HIGHEST_POSSIBLE_NUM = 9999;	//The highest number that needs to be checked for a 1-9 pandigital
 	//Instance variables
-	private long largestNum;	//The number passed to the executeFormula function that returns the largest pandigital
+	protected long largestNum;	//The number passed to the executeFormula function that returns the largest pandigital
-	private long pandigital;	//The largest pandigital number found
+	protected long pandigital;	//The largest pandigital number found
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem39.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem39.java
 //Mattrixwv
 // Created: 08-20-22
-//Modified: 08-20-22
+//Modified: 06-30-23
 //If p is the perimeter of a right triangle for which value of p <= 1000 is the number of solutions for the sides {a, b, c} maximized
 //Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -34,7 +34,7 @@ public class Problem39 extends Problem{
 	//Static variables
 	protected static long maxPerimeter = 1000;
 	//Instace variables
-	private ArrayList<Triple<Long, Long, Long>> longestSolutions;
+	protected List<Triple<Long, Long, Long>> longestSolutions;
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem4.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem4.java
 //Matthew Ellison
 // Created: 03-01-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 //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/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -34,7 +34,7 @@ public class Problem4 extends Problem{
 	private static final int START_NUM = 100;	//The first number to be multiplied
 	private static final int END_NUM = 999;		//The last number to be multiplied
 	//Instance variables
-	private ArrayList<Integer> palindromes;	//Holds all numbers that turn out to be palindromes
+	protected List<Integer> palindromes;	//Holds all numbers that turn out to be palindromes
 
 	//Constructor
 	public Problem4(){

src/main/java/com/mattrixwv/project_euler/problems/Problem40.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem40.java
 //Mattrixwv
 // Created: 08-20-22
-//Modified: 08-20-22
+//Modified: 06-30-23
 //An irrational decimal fraction is created by concatenating the positive integers. Find the value of the following expression: d1 * d10 * d100 * d1000 * d10000 * d100000 * d1000000
 //Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -33,8 +33,8 @@ public class Problem40 extends Problem{
 	//Static variables
 	private static final long LARGEST_SUBSCRIPT = 1000000;
 	//Instance variables
-	private StringBuilder irrationalDecimal;
+	protected StringBuilder irrationalDecimal;
-	private long product;
+	protected long product;
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem41.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem41.java
 //Mattrixwv
 // Created: 08-20-22
-//Modified: 08-20-22
+//Modified: 06-30-23
 //What is the largest n-digit pandigital prime?
 //Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -32,7 +32,7 @@ import com.mattrixwv.StringAlgorithms;
 public class Problem41 extends Problem{
 	//Variables
 	//Instance variables
-	private long largestPrimePandigital;
+	protected long largestPrimePandigital;
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem42.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem42.java
 //Mattrixwv
 // Created: 08-20-22
-//Modified: 08-20-22
+//Modified: 06-30-23
 //Triangular number t(n) = (n * (n + 1)) / 2. For A = 1, B = 2, ... find the number of triangular words in the file
 //Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -34,10 +34,10 @@ import java.util.List;
 public class Problem42 extends Problem{
 	//Variables
 	//Static variables
-	private static final String FILE_NAME = "files/Problem42Words.txt";
+	protected static String FILE_NAME = "files/Problem42Words.txt";
-	private static final ArrayList<String> fileWords = new ArrayList<>();
+	protected static ArrayList<String> fileWords = new ArrayList<>();
 	//Instance variables
-	private ArrayList<String> triangleWords;
+	protected ArrayList<String> triangleWords;
 
 	//Functions
 	//Constructor
@@ -63,7 +63,7 @@ public class Problem42 extends Problem{
 				}
 			}
 			catch(IOException error){
-				throw new InvalidParameterException(error.getMessage());
+				throw new InvalidParameterException("Error reading file", error);
 			}
 		}
 		else{

src/main/java/com/mattrixwv/project_euler/problems/Problem43.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem43.java
 //Mattrixwv
 // Created: 08-20-22
-//Modified: 08-20-22
+//Modified: 06-30-23
 //Find the sum of all 0-9 pandigital numbers with this property
 //Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -36,7 +36,7 @@ public class Problem43 extends Problem{
 	//Static variables
 	protected static String nums = "0123456789";
 	//Instance variables
-	private ArrayList<Long> subPrimePandigitals;
+	protected ArrayList<Long> subPrimePandigitals;
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem44.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem44.java
 //Mattrixwv
 // Created: 08-20-22
-//Modified: 08-20-22
+//Modified: 06-30-23
 //Pentagonal number P = ((n * (3 * n - 1)) / 2). Find 2 pentagonal numbers whos sum and difference are also pentagonal numbers
 //Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -32,10 +32,10 @@ import com.mattrixwv.generators.PentagonalNumberGenerator;
 public class Problem44 extends Problem{
 	//Variables
 	//Instance variables
-	private PentagonalNumberGenerator generator;
+	protected PentagonalNumberGenerator generator;
-	private List<Long> pentagonalList;
+	protected List<Long> pentagonalList;
-	private long pentagonalNumber1;
+	protected long pentagonalNumber1;
-	private long pentagonalNumber2;
+	protected long pentagonalNumber2;
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem45.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem45.java
 //Mattrixwv
 // Created: 08-20-22
-//Modified: 08-20-22
+//Modified: 06-30-23
 //If p is the perimeter of a right triangle for which value of p <= 1000 is the number of solutions for the sides {a, b, c} maximized
 //Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -31,10 +31,10 @@ public class Problem45 extends Problem{
 	//Static variables
 	private static final long MIN_NUMBER = 40756;
 	//Instance variables
-	private long num;
+	protected long num;
-	private TriangularNumberGenerator triGen;
+	protected TriangularNumberGenerator triGen;
-	private PentagonalNumberGenerator penGen;
+	protected PentagonalNumberGenerator penGen;
-	private HexagonalNumberGenerator hexGen;
+	protected HexagonalNumberGenerator hexGen;
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem46.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/project_euler/Problems/Problem46.java
 //Mattrixwv
 // Created: 08-22-22
-//Modified: 08-22-22
+//Modified: 06-30-23
 //What is the smallest odd coposite number that cannot be written as the sum of a prime and twice a square?
 //Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -31,7 +31,7 @@ import com.mattrixwv.generators.SieveOfEratosthenes;
 public class Problem46 extends Problem{
 	//Variables
 	//Instance variables
-	private long num;
+	protected long num;
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem47.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem47.java
 //Mattrixwv
 // Created: 08-22-22
-//Modified: 08-22-22
+//Modified: 06-30-23
 //What is the first of four consecutive integers to have four distinct prime factors each?
 //Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -25,7 +25,6 @@ package com.mattrixwv.project_euler.problems;
 
 import java.util.HashMap;
 import java.util.List;
-import java.util.Map.Entry;
 
 import com.mattrixwv.NumberAlgorithms;
 
@@ -33,7 +32,7 @@ import com.mattrixwv.NumberAlgorithms;
 public class Problem47 extends Problem{
 	//Variables
 	//Instance variables
-	private long num;	//The first of the consecutive numbers
+	protected long num;	//The first of the consecutive numbers
 
 	//Function
 	//Constructor
@@ -59,7 +58,6 @@ public class Problem47 extends Problem{
 		factors.put(2L, NumberAlgorithms.getFactors(2L));
 		factors.put(3L, NumberAlgorithms.getFactors(3L));
 		for(long cnt = 1;num == 0;++cnt){
-			boolean found = false;
 			//Get the next set of factors
 			factors.put(cnt + 3, NumberAlgorithms.getFactors(cnt + 3));
 
@@ -86,26 +84,7 @@ public class Problem47 extends Problem{
 				continue;
 			}
 
-			//Make sure none of the elements match
+			num = cnt;
-			for(Entry<Long, Long> entry : factors0.entrySet()){
-				if(entry.getValue().equals(factors1.get(entry.getKey())) || entry.getValue().equals(factors2.get(entry.getKey())) || entry.getValue().equals(factors3.get(entry.getKey()))){
-					found = true;
-				}
-			}
-			for(Entry<Long, Long> entry : factors1.entrySet()){
-				if(entry.getValue().equals(factors2.get(entry.getKey())) || entry.getValue().equals(factors3.get(entry.getKey()))){
-					found = true;
-				}
-			}
-			for(Entry<Long, Long> entry : factors2.entrySet()){
-				if(entry.getValue().equals(factors3.get(entry.getKey()))){
-					found = true;
-				}
-			}
-
-			if(!found){
-				num = cnt;
-			}
 		}
 
 

src/main/java/com/mattrixwv/project_euler/problems/Problem48.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem48.java
 //Mattrixwv
 // Created: 08-23-22
-//Modified: 08-23-22
+//Modified: 06-30-23
 //Find the last ten digits of the series 1^1 + 2^2 + 3^3 + ... + 1000^1000
 //Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -31,7 +31,7 @@ public class Problem48 extends Problem{
 	//Static variables
 	private static final BigInteger TOP_NUM = BigInteger.valueOf(1000);
 	//Instance variables
-	private BigInteger sum;
+	protected BigInteger sum;
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem49.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem49.java
 //Mattrixwv
 // Created: 08-23-22
-//Modified: 08-23-22
+//Modified: 06-30-23
 //What is the 12-digit number formed by concatenating the three terms in the sequence?
 //Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -39,7 +39,7 @@ public class Problem49 extends Problem{
 	private static final int MIN_NUMBER = 1000;
 	private static final int MAX_NUMBER = 9999;
 	//Instance variables
-	private String concatenationOfNumbers;
+	protected String concatenationOfNumbers;
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem5.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem5.java
 //Matthew Ellison
 // Created: 03-01-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 //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/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -26,7 +26,7 @@ package com.mattrixwv.project_euler.problems;
 public class Problem5 extends Problem{
 	//Variables
 	//Instance variables
-	private int smallestNum;	//The smallest number that is found
+	protected int smallestNum;	//The smallest number that is found
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem50.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/com/mattrixwv/project_euler/problems/Problem50.java
 //Mattrixwv
 // Created: 08-23-22
-//Modified: 08-23-22
+//Modified: 06-30-23
 //Which prime, below one-million, can be written as the sum of the most consecutive primes?
 //Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -35,7 +35,7 @@ public class Problem50 extends Problem{
 	//Static variables
 	private static final long MAX = 999999;
 	//Instance variables
-	private ArrayList<Long> consecutivePrimes;
+	protected ArrayList<Long> consecutivePrimes;
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem6.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem6.java
 //Matthew Ellison
 // Created: 03-01-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 //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/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -29,8 +29,8 @@ public class Problem6 extends Problem{
 	private static final int START_NUM = 1;		//The first number that needs to be counted
 	private static final int END_NUM = 100;		//The last number that needs to be counted
 	//Instance variables
-	private long sumOfSquares;	//Holds the sum of the squares of all the numbers
+	protected long sumOfSquares;	//Holds the sum of the squares of all the numbers
-	private long squareOfSum;	//Holds the square of the sum of all the numbers
+	protected long squareOfSum;		//Holds the square of the sum of all the numbers
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem67.java

@@ -1,114 +1,12 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem67.java
 //Matthew Ellison
 // Created: 03-26-19
-//Modified: 07-03-21
+//Modified: 06-30-23
 //Find the maximum total from top to bottom
-/*
-59
-73 41
-52 40 09
-26 53 06 34
-10 51 87 86 81
-61 95 66 57 25 68
-90 81 80 38 92 67 73
-30 28 51 76 81 18 75 44
-84 14 95 87 62 81 17 78 58
-21 46 71 58 02 79 62 39 31 09
-56 34 35 53 78 31 81 18 90 93 15
-78 53 04 21 84 93 32 13 97 11 37 51
-45 03 81 79 05 18 78 86 13 30 63 99 95
-39 87 96 28 03 38 42 17 82 87 58 07 22 57
-06 17 51 17 07 93 09 07 75 97 95 78 87 08 53
-67 66 59 60 88 99 94 65 55 77 55 34 27 53 78 28
-76 40 41 04 87 16 09 42 75 69 23 97 30 60 10 79 87
-12 10 44 26 21 36 32 84 98 60 13 12 36 16 63 31 91 35
-70 39 06 05 55 27 38 48 28 22 34 35 62 62 15 14 94 89 86
-66 56 68 84 96 21 34 34 34 81 62 40 65 54 62 05 98 03 02 60
-38 89 46 37 99 54 34 53 36 14 70 26 02 90 45 13 31 61 83 73 47
-36 10 63 96 60 49 41 05 37 42 14 58 84 93 96 17 09 43 05 43 06 59
-66 57 87 57 61 28 37 51 84 73 79 15 39 95 88 87 43 39 11 86 77 74 18
-54 42 05 79 30 49 99 73 46 37 50 02 45 09 54 52 27 95 27 65 19 45 26 45
-71 39 17 78 76 29 52 90 18 99 78 19 35 62 71 19 23 65 93 85 49 33 75 09 02
-33 24 47 61 60 55 32 88 57 55 91 54 46 57 07 77 98 52 80 99 24 25 46 78 79 05
-92 09 13 55 10 67 26 78 76 82 63 49 51 31 24 68 05 57 07 54 69 21 67 43 17 63 12
-24 59 06 08 98 74 66 26 61 60 13 03 09 09 24 30 71 08 88 70 72 70 29 90 11 82 41 34
-66 82 67 04 36 60 92 77 91 85 62 49 59 61 30 90 29 94 26 41 89 04 53 22 83 41 09 74 90
-48 28 26 37 28 52 77 26 51 32 18 98 79 36 62 13 17 08 19 54 89 29 73 68 42 14 08 16 70 37
-37 60 69 70 72 71 09 59 13 60 38 13 57 36 09 30 43 89 30 39 15 02 44 73 05 73 26 63 56 86 12
-55 55 85 50 62 99 84 77 28 85 03 21 27 22 19 26 82 69 54 04 13 07 85 14 01 15 70 59 89 95 10 19
-04 09 31 92 91 38 92 86 98 75 21 05 64 42 62 84 36 20 73 42 21 23 22 51 51 79 25 45 85 53 03 43 22
-75 63 02 49 14 12 89 14 60 78 92 16 44 82 38 30 72 11 46 52 90 27 08 65 78 03 85 41 57 79 39 52 33 48
-78 27 56 56 39 13 19 43 86 72 58 95 39 07 04 34 21 98 39 15 39 84 89 69 84 46 37 57 59 35 59 50 26 15 93
-42 89 36 27 78 91 24 11 17 41 05 94 07 69 51 96 03 96 47 90 90 45 91 20 50 56 10 32 36 49 04 53 85 92 25 65
-52 09 61 30 61 97 66 21 96 92 98 90 06 34 96 60 32 69 68 33 75 84 18 31 71 50 84 63 03 03 19 11 28 42 75 45 45
-61 31 61 68 96 34 49 39 05 71 76 59 62 67 06 47 96 99 34 21 32 47 52 07 71 60 42 72 94 56 82 83 84 40 94 87 82 46
-01 20 60 14 17 38 26 78 66 81 45 95 18 51 98 81 48 16 53 88 37 52 69 95 72 93 22 34 98 20 54 27 73 61 56 63 60 34 63
-93 42 94 83 47 61 27 51 79 79 45 01 44 73 31 70 83 42 88 25 53 51 30 15 65 94 80 44 61 84 12 77 02 62 02 65 94 42 14 94
-32 73 09 67 68 29 74 98 10 19 85 48 38 31 85 67 53 93 93 77 47 67 39 72 94 53 18 43 77 40 78 32 29 59 24 06 02 83 50 60 66
-32 01 44 30 16 51 15 81 98 15 10 62 86 79 50 62 45 60 70 38 31 85 65 61 64 06 69 84 14 22 56 43 09 48 66 69 83 91 60 40 36 61
-92 48 22 99 15 95 64 43 01 16 94 02 99 19 17 69 11 58 97 56 89 31 77 45 67 96 12 73 08 20 36 47 81 44 50 64 68 85 40 81 85 52 09
-91 35 92 45 32 84 62 15 19 64 21 66 06 01 52 80 62 59 12 25 88 28 91 50 40 16 22 99 92 79 87 51 21 77 74 77 07 42 38 42 74 83 02 05
-46 19 77 66 24 18 05 32 02 84 31 99 92 58 96 72 91 36 62 99 55 29 53 42 12 37 26 58 89 50 66 19 82 75 12 48 24 87 91 85 02 07 03 76 86
-99 98 84 93 07 17 33 61 92 20 66 60 24 66 40 30 67 05 37 29 24 96 03 27 70 62 13 04 45 47 59 88 43 20 66 15 46 92 30 04 71 66 78 70 53 99
-67 60 38 06 88 04 17 72 10 99 71 07 42 25 54 05 26 64 91 50 45 71 06 30 67 48 69 82 08 56 80 67 18 46 66 63 01 20 08 80 47 07 91 16 03 79 87
-18 54 78 49 80 48 77 40 68 23 60 88 58 80 33 57 11 69 55 53 64 02 94 49 60 92 16 35 81 21 82 96 25 24 96 18 02 05 49 03 50 77 06 32 84 27 18 38
-68 01 50 04 03 21 42 94 53 24 89 05 92 26 52 36 68 11 85 01 04 42 02 45 15 06 50 04 53 73 25 74 81 88 98 21 67 84 79 97 99 20 95 04 40 46 02 58 87
-94 10 02 78 88 52 21 03 88 60 06 53 49 71 20 91 12 65 07 49 21 22 11 41 58 99 36 16 09 48 17 24 52 36 23 15 72 16 84 56 02 99 43 76 81 71 29 39 49 17
-64 39 59 84 86 16 17 66 03 09 43 06 64 18 63 29 68 06 23 07 87 14 26 35 17 12 98 41 53 64 78 18 98 27 28 84 80 67 75 62 10 11 76 90 54 10 05 54 41 39 66
-43 83 18 37 32 31 52 29 95 47 08 76 35 11 04 53 35 43 34 10 52 57 12 36 20 39 40 55 78 44 07 31 38 26 08 15 56 88 86 01 52 62 10 24 32 05 60 65 53 28 57 99
-03 50 03 52 07 73 49 92 66 80 01 46 08 67 25 36 73 93 07 42 25 53 13 96 76 83 87 90 54 89 78 22 78 91 73 51 69 09 79 94 83 53 09 40 69 62 10 79 49 47 03 81 30
-71 54 73 33 51 76 59 54 79 37 56 45 84 17 62 21 98 69 41 95 65 24 39 37 62 03 24 48 54 64 46 82 71 78 33 67 09 16 96 68 52 74 79 68 32 21 13 78 96 60 09 69 20 36
-73 26 21 44 46 38 17 83 65 98 07 23 52 46 61 97 33 13 60 31 70 15 36 77 31 58 56 93 75 68 21 36 69 53 90 75 25 82 39 50 65 94 29 30 11 33 11 13 96 02 56 47 07 49 02
-76 46 73 30 10 20 60 70 14 56 34 26 37 39 48 24 55 76 84 91 39 86 95 61 50 14 53 93 64 67 37 31 10 84 42 70 48 20 10 72 60 61 84 79 69 65 99 73 89 25 85 48 92 56 97 16
-03 14 80 27 22 30 44 27 67 75 79 32 51 54 81 29 65 14 19 04 13 82 04 91 43 40 12 52 29 99 07 76 60 25 01 07 61 71 37 92 40 47 99 66 57 01 43 44 22 40 53 53 09 69 26 81 07
-49 80 56 90 93 87 47 13 75 28 87 23 72 79 32 18 27 20 28 10 37 59 21 18 70 04 79 96 03 31 45 71 81 06 14 18 17 05 31 50 92 79 23 47 09 39 47 91 43 54 69 47 42 95 62 46 32 85
-37 18 62 85 87 28 64 05 77 51 47 26 30 65 05 70 65 75 59 80 42 52 25 20 44 10 92 17 71 95 52 14 77 13 24 55 11 65 26 91 01 30 63 15 49 48 41 17 67 47 03 68 20 90 98 32 04 40 68
-90 51 58 60 06 55 23 68 05 19 76 94 82 36 96 43 38 90 87 28 33 83 05 17 70 83 96 93 06 04 78 47 80 06 23 84 75 23 87 72 99 14 50 98 92 38 90 64 61 58 76 94 36 66 87 80 51 35 61 38
-57 95 64 06 53 36 82 51 40 33 47 14 07 98 78 65 39 58 53 06 50 53 04 69 40 68 36 69 75 78 75 60 03 32 39 24 74 47 26 90 13 40 44 71 90 76 51 24 36 50 25 45 70 80 61 80 61 43 90 64 11
-18 29 86 56 68 42 79 10 42 44 30 12 96 18 23 18 52 59 02 99 67 46 60 86 43 38 55 17 44 93 42 21 55 14 47 34 55 16 49 24 23 29 96 51 55 10 46 53 27 92 27 46 63 57 30 65 43 27 21 20 24 83
-81 72 93 19 69 52 48 01 13 83 92 69 20 48 69 59 20 62 05 42 28 89 90 99 32 72 84 17 08 87 36 03 60 31 36 36 81 26 97 36 48 54 56 56 27 16 91 08 23 11 87 99 33 47 02 14 44 73 70 99 43 35 33
-90 56 61 86 56 12 70 59 63 32 01 15 81 47 71 76 95 32 65 80 54 70 34 51 40 45 33 04 64 55 78 68 88 47 31 47 68 87 03 84 23 44 89 72 35 08 31 76 63 26 90 85 96 67 65 91 19 14 17 86 04 71 32 95
-37 13 04 22 64 37 37 28 56 62 86 33 07 37 10 44 52 82 52 06 19 52 57 75 90 26 91 24 06 21 14 67 76 30 46 14 35 89 89 41 03 64 56 97 87 63 22 34 03 79 17 45 11 53 25 56 96 61 23 18 63 31 37 37 47
-77 23 26 70 72 76 77 04 28 64 71 69 14 85 96 54 95 48 06 62 99 83 86 77 97 75 71 66 30 19 57 90 33 01 60 61 14 12 90 99 32 77 56 41 18 14 87 49 10 14 90 64 18 50 21 74 14 16 88 05 45 73 82 47 74 44
-22 97 41 13 34 31 54 61 56 94 03 24 59 27 98 77 04 09 37 40 12 26 87 09 71 70 07 18 64 57 80 21 12 71 83 94 60 39 73 79 73 19 97 32 64 29 41 07 48 84 85 67 12 74 95 20 24 52 41 67 56 61 29 93 35 72 69
-72 23 63 66 01 11 07 30 52 56 95 16 65 26 83 90 50 74 60 18 16 48 43 77 37 11 99 98 30 94 91 26 62 73 45 12 87 73 47 27 01 88 66 99 21 41 95 80 02 53 23 32 61 48 32 43 43 83 14 66 95 91 19 81 80 67 25 88
-08 62 32 18 92 14 83 71 37 96 11 83 39 99 05 16 23 27 10 67 02 25 44 11 55 31 46 64 41 56 44 74 26 81 51 31 45 85 87 09 81 95 22 28 76 69 46 48 64 87 67 76 27 89 31 11 74 16 62 03 60 94 42 47 09 34 94 93 72
-56 18 90 18 42 17 42 32 14 86 06 53 33 95 99 35 29 15 44 20 49 59 25 54 34 59 84 21 23 54 35 90 78 16 93 13 37 88 54 19 86 67 68 55 66 84 65 42 98 37 87 56 33 28 58 38 28 38 66 27 52 21 81 15 08 22 97 32 85 27
-91 53 40 28 13 34 91 25 01 63 50 37 22 49 71 58 32 28 30 18 68 94 23 83 63 62 94 76 80 41 90 22 82 52 29 12 18 56 10 08 35 14 37 57 23 65 67 40 72 39 93 39 70 89 40 34 07 46 94 22 20 05 53 64 56 30 05 56 61 88 27
-23 95 11 12 37 69 68 24 66 10 87 70 43 50 75 07 62 41 83 58 95 93 89 79 45 39 02 22 05 22 95 43 62 11 68 29 17 40 26 44 25 71 87 16 70 85 19 25 59 94 90 41 41 80 61 70 55 60 84 33 95 76 42 63 15 09 03 40 38 12 03 32
-09 84 56 80 61 55 85 97 16 94 82 94 98 57 84 30 84 48 93 90 71 05 95 90 73 17 30 98 40 64 65 89 07 79 09 19 56 36 42 30 23 69 73 72 07 05 27 61 24 31 43 48 71 84 21 28 26 65 65 59 65 74 77 20 10 81 61 84 95 08 52 23 70
-47 81 28 09 98 51 67 64 35 51 59 36 92 82 77 65 80 24 72 53 22 07 27 10 21 28 30 22 48 82 80 48 56 20 14 43 18 25 50 95 90 31 77 08 09 48 44 80 90 22 93 45 82 17 13 96 25 26 08 73 34 99 06 49 24 06 83 51 40 14 15 10 25 01
-54 25 10 81 30 64 24 74 75 80 36 75 82 60 22 69 72 91 45 67 03 62 79 54 89 74 44 83 64 96 66 73 44 30 74 50 37 05 09 97 70 01 60 46 37 91 39 75 75 18 58 52 72 78 51 81 86 52 08 97 01 46 43 66 98 62 81 18 70 93 73 08 32 46 34
-96 80 82 07 59 71 92 53 19 20 88 66 03 26 26 10 24 27 50 82 94 73 63 08 51 33 22 45 19 13 58 33 90 15 22 50 36 13 55 06 35 47 82 52 33 61 36 27 28 46 98 14 73 20 73 32 16 26 80 53 47 66 76 38 94 45 02 01 22 52 47 96 64 58 52 39
-88 46 23 39 74 63 81 64 20 90 33 33 76 55 58 26 10 46 42 26 74 74 12 83 32 43 09 02 73 55 86 54 85 34 28 23 29 79 91 62 47 41 82 87 99 22 48 90 20 05 96 75 95 04 43 28 81 39 81 01 28 42 78 25 39 77 90 57 58 98 17 36 73 22 63 74 51
-29 39 74 94 95 78 64 24 38 86 63 87 93 06 70 92 22 16 80 64 29 52 20 27 23 50 14 13 87 15 72 96 81 22 08 49 72 30 70 24 79 31 16 64 59 21 89 34 96 91 48 76 43 53 88 01 57 80 23 81 90 79 58 01 80 87 17 99 86 90 72 63 32 69 14 28 88 69
-37 17 71 95 56 93 71 35 43 45 04 98 92 94 84 96 11 30 31 27 31 60 92 03 48 05 98 91 86 94 35 90 90 08 48 19 33 28 68 37 59 26 65 96 50 68 22 07 09 49 34 31 77 49 43 06 75 17 81 87 61 79 52 26 27 72 29 50 07 98 86 01 17 10 46 64 24 18 56
-51 30 25 94 88 85 79 91 40 33 63 84 49 67 98 92 15 26 75 19 82 05 18 78 65 93 61 48 91 43 59 41 70 51 22 15 92 81 67 91 46 98 11 11 65 31 66 10 98 65 83 21 05 56 05 98 73 67 46 74 69 34 08 30 05 52 07 98 32 95 30 94 65 50 24 63 28 81 99 57
-19 23 61 36 09 89 71 98 65 17 30 29 89 26 79 74 94 11 44 48 97 54 81 55 39 66 69 45 28 47 13 86 15 76 74 70 84 32 36 33 79 20 78 14 41 47 89 28 81 05 99 66 81 86 38 26 06 25 13 60 54 55 23 53 27 05 89 25 23 11 13 54 59 54 56 34 16 24 53 44 06
-13 40 57 72 21 15 60 08 04 19 11 98 34 45 09 97 86 71 03 15 56 19 15 44 97 31 90 04 87 87 76 08 12 30 24 62 84 28 12 85 82 53 99 52 13 94 06 65 97 86 09 50 94 68 69 74 30 67 87 94 63 07 78 27 80 36 69 41 06 92 32 78 37 82 30 05 18 87 99 72 19 99
-44 20 55 77 69 91 27 31 28 81 80 27 02 07 97 23 95 98 12 25 75 29 47 71 07 47 78 39 41 59 27 76 13 15 66 61 68 35 69 86 16 53 67 63 99 85 41 56 08 28 33 40 94 76 90 85 31 70 24 65 84 65 99 82 19 25 54 37 21 46 33 02 52 99 51 33 26 04 87 02 08 18 96
-54 42 61 45 91 06 64 79 80 82 32 16 83 63 42 49 19 78 65 97 40 42 14 61 49 34 04 18 25 98 59 30 82 72 26 88 54 36 21 75 03 88 99 53 46 51 55 78 22 94 34 40 68 87 84 25 30 76 25 08 92 84 42 61 40 38 09 99 40 23 29 39 46 55 10 90 35 84 56 70 63 23 91 39
-52 92 03 71 89 07 09 37 68 66 58 20 44 92 51 56 13 71 79 99 26 37 02 06 16 67 36 52 58 16 79 73 56 60 59 27 44 77 94 82 20 50 98 33 09 87 94 37 40 83 64 83 58 85 17 76 53 02 83 52 22 27 39 20 48 92 45 21 09 42 24 23 12 37 52 28 50 78 79 20 86 62 73 20 59
-54 96 80 15 91 90 99 70 10 09 58 90 93 50 81 99 54 38 36 10 30 11 35 84 16 45 82 18 11 97 36 43 96 79 97 65 40 48 23 19 17 31 64 52 65 65 37 32 65 76 99 79 34 65 79 27 55 33 03 01 33 27 61 28 66 08 04 70 49 46 48 83 01 45 19 96 13 81 14 21 31 79 93 85 50 05
-92 92 48 84 59 98 31 53 23 27 15 22 79 95 24 76 05 79 16 93 97 89 38 89 42 83 02 88 94 95 82 21 01 97 48 39 31 78 09 65 50 56 97 61 01 07 65 27 21 23 14 15 80 97 44 78 49 35 33 45 81 74 34 05 31 57 09 38 94 07 69 54 69 32 65 68 46 68 78 90 24 28 49 51 45 86 35
-41 63 89 76 87 31 86 09 46 14 87 82 22 29 47 16 13 10 70 72 82 95 48 64 58 43 13 75 42 69 21 12 67 13 64 85 58 23 98 09 37 76 05 22 31 12 66 50 29 99 86 72 45 25 10 28 19 06 90 43 29 31 67 79 46 25 74 14 97 35 76 37 65 46 23 82 06 22 30 76 93 66 94 17 96 13 20 72
-63 40 78 08 52 09 90 41 70 28 36 14 46 44 85 96 24 52 58 15 87 37 05 98 99 39 13 61 76 38 44 99 83 74 90 22 53 80 56 98 30 51 63 39 44 30 91 91 04 22 27 73 17 35 53 18 35 45 54 56 27 78 48 13 69 36 44 38 71 25 30 56 15 22 73 43 32 69 59 25 93 83 45 11 34 94 44 39 92
-12 36 56 88 13 96 16 12 55 54 11 47 19 78 17 17 68 81 77 51 42 55 99 85 66 27 81 79 93 42 65 61 69 74 14 01 18 56 12 01 58 37 91 22 42 66 83 25 19 04 96 41 25 45 18 69 96 88 36 93 10 12 98 32 44 83 83 04 72 91 04 27 73 07 34 37 71 60 59 31 01 54 54 44 96 93 83 36 04 45
-30 18 22 20 42 96 65 79 17 41 55 69 94 81 29 80 91 31 85 25 47 26 43 49 02 99 34 67 99 76 16 14 15 93 08 32 99 44 61 77 67 50 43 55 87 55 53 72 17 46 62 25 50 99 73 05 93 48 17 31 70 80 59 09 44 59 45 13 74 66 58 94 87 73 16 14 85 38 74 99 64 23 79 28 71 42 20 37 82 31 23
-51 96 39 65 46 71 56 13 29 68 53 86 45 33 51 49 12 91 21 21 76 85 02 17 98 15 46 12 60 21 88 30 92 83 44 59 42 50 27 88 46 86 94 73 45 54 23 24 14 10 94 21 20 34 23 51 04 83 99 75 90 63 60 16 22 33 83 70 11 32 10 50 29 30 83 46 11 05 31 17 86 42 49 01 44 63 28 60 07 78 95 40
-44 61 89 59 04 49 51 27 69 71 46 76 44 04 09 34 56 39 15 06 94 91 75 90 65 27 56 23 74 06 23 33 36 69 14 39 05 34 35 57 33 22 76 46 56 10 61 65 98 09 16 69 04 62 65 18 99 76 49 18 72 66 73 83 82 40 76 31 89 91 27 88 17 35 41 35 32 51 32 67 52 68 74 85 80 57 07 11 62 66 47 22 67
-65 37 19 97 26 17 16 24 24 17 50 37 64 82 24 36 32 11 68 34 69 31 32 89 79 93 96 68 49 90 14 23 04 04 67 99 81 74 70 74 36 96 68 09 64 39 88 35 54 89 96 58 66 27 88 97 32 14 06 35 78 20 71 06 85 66 57 02 58 91 72 05 29 56 73 48 86 52 09 93 22 57 79 42 12 01 31 68 17 59 63 76 07 77
-73 81 14 13 17 20 11 09 01 83 08 85 91 70 84 63 62 77 37 07 47 01 59 95 39 69 39 21 99 09 87 02 97 16 92 36 74 71 90 66 33 73 73 75 52 91 11 12 26 53 05 26 26 48 61 50 90 65 01 87 42 47 74 35 22 73 24 26 56 70 52 05 48 41 31 18 83 27 21 39 80 85 26 08 44 02 71 07 63 22 05 52 19 08 20
-17 25 21 11 72 93 33 49 64 23 53 82 03 13 91 65 85 02 40 05 42 31 77 42 05 36 06 54 04 58 07 76 87 83 25 57 66 12 74 33 85 37 74 32 20 69 03 97 91 68 82 44 19 14 89 28 85 85 80 53 34 87 58 98 88 78 48 65 98 40 11 57 10 67 70 81 60 79 74 72 97 59 79 47 30 20 54 80 89 91 14 05 33 36 79 39
-60 85 59 39 60 07 57 76 77 92 06 35 15 72 23 41 45 52 95 18 64 79 86 53 56 31 69 11 91 31 84 50 44 82 22 81 41 40 30 42 30 91 48 94 74 76 64 58 74 25 96 57 14 19 03 99 28 83 15 75 99 01 89 85 79 50 03 95 32 67 44 08 07 41 62 64 29 20 14 76 26 55 48 71 69 66 19 72 44 25 14 01 48 74 12 98 07
-64 66 84 24 18 16 27 48 20 14 47 69 30 86 48 40 23 16 61 21 51 50 26 47 35 33 91 28 78 64 43 68 04 79 51 08 19 60 52 95 06 68 46 86 35 97 27 58 04 65 30 58 99 12 12 75 91 39 50 31 42 64 70 04 46 07 98 73 98 93 37 89 77 91 64 71 64 65 66 21 78 62 81 74 42 20 83 70 73 95 78 45 92 27 34 53 71 15
-30 11 85 31 34 71 13 48 05 14 44 03 19 67 23 73 19 57 06 90 94 72 57 69 81 62 59 68 88 57 55 69 49 13 07 87 97 80 89 05 71 05 05 26 38 40 16 62 45 99 18 38 98 24 21 26 62 74 69 04 85 57 77 35 58 67 91 79 79 57 86 28 66 34 72 51 76 78 36 95 63 90 08 78 47 63 45 31 22 70 52 48 79 94 15 77 61 67 68
-23 33 44 81 80 92 93 75 94 88 23 61 39 76 22 03 28 94 32 06 49 65 41 34 18 23 08 47 62 60 03 63 33 13 80 52 31 54 73 43 70 26 16 69 57 87 83 31 03 93 70 81 47 95 77 44 29 68 39 51 56 59 63 07 25 70 07 77 43 53 64 03 94 42 95 39 18 01 66 21 16 97 20 50 90 16 70 10 95 69 29 06 25 61 41 26 15 59 63 35
-*/
 //This is done using a breadth first search
 //Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses
 /*
-	Copyright (C) 2021  Matthew Ellison
+	Copyright (C) 2023  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
@@ -126,116 +24,11 @@
 package com.mattrixwv.project_euler.problems;
 
 
-import java.util.ArrayList;
-import java.util.Arrays;
-
-
 public class Problem67 extends Problem18{
 	//Setup the list of numbers to check
-	static{
+	public Problem67(){
-		list = new ArrayList<ArrayList<Integer>>(
+		super();
-			Arrays.asList(
+		FILE_NAME = "files/Problem67Pyramid.txt";
-				new ArrayList<Integer>(Arrays.asList(59)),
-				new ArrayList<Integer>(Arrays.asList(73, 41)),
-				new ArrayList<Integer>(Arrays.asList(52, 40,  9)),
-				new ArrayList<Integer>(Arrays.asList(26, 53, 06, 34)),
-				new ArrayList<Integer>(Arrays.asList(10, 51, 87, 86, 81)),
-				new ArrayList<Integer>(Arrays.asList(61, 95, 66, 57, 25, 68)),
-				new ArrayList<Integer>(Arrays.asList(90, 81, 80, 38, 92, 67, 73)),
-				new ArrayList<Integer>(Arrays.asList(30, 28, 51, 76, 81, 18, 75, 44)),
-				new ArrayList<Integer>(Arrays.asList(84, 14, 95, 87, 62, 81, 17, 78, 58)),
-				new ArrayList<Integer>(Arrays.asList(21, 46, 71, 58, 02, 79, 62, 39, 31,  9)),
-				new ArrayList<Integer>(Arrays.asList(56, 34, 35, 53, 78, 31, 81, 18, 90, 93, 15)),
-				new ArrayList<Integer>(Arrays.asList(78, 53, 04, 21, 84, 93, 32, 13, 97, 11, 37, 51)),
-				new ArrayList<Integer>(Arrays.asList(45, 03, 81, 79, 05, 18, 78, 86, 13, 30, 63, 99, 95)),
-				new ArrayList<Integer>(Arrays.asList(39, 87, 96, 28, 03, 38, 42, 17, 82, 87, 58, 07, 22, 57)),
-				new ArrayList<Integer>(Arrays.asList(06, 17, 51, 17, 07, 93,  9, 07, 75, 97, 95, 78, 87,  8, 53)),
-				new ArrayList<Integer>(Arrays.asList(67, 66, 59, 60, 88, 99, 94, 65, 55, 77, 55, 34, 27, 53, 78, 28)),
-				new ArrayList<Integer>(Arrays.asList(76, 40, 41, 04, 87, 16,  9, 42, 75, 69, 23, 97, 30, 60, 10, 79, 87)),
-				new ArrayList<Integer>(Arrays.asList(12, 10, 44, 26, 21, 36, 32, 84, 98, 60, 13, 12, 36, 16, 63, 31, 91, 35)),
-				new ArrayList<Integer>(Arrays.asList(70, 39, 06, 05, 55, 27, 38, 48, 28, 22, 34, 35, 62, 62, 15, 14, 94, 89, 86)),
-				new ArrayList<Integer>(Arrays.asList(66, 56, 68, 84, 96, 21, 34, 34, 34, 81, 62, 40, 65, 54, 62, 05, 98, 03, 02, 60)),
-				new ArrayList<Integer>(Arrays.asList(38, 89, 46, 37, 99, 54, 34, 53, 36, 14, 70, 26, 02, 90, 45, 13, 31, 61, 83, 73, 47)),
-				new ArrayList<Integer>(Arrays.asList(36, 10, 63, 96, 60, 49, 41, 05, 37, 42, 14, 58, 84, 93, 96, 17,  9, 43, 05, 43, 06, 59)),
-				new ArrayList<Integer>(Arrays.asList(66, 57, 87, 57, 61, 28, 37, 51, 84, 73, 79, 15, 39, 95, 88, 87, 43, 39, 11, 86, 77, 74, 18)),
-				new ArrayList<Integer>(Arrays.asList(54, 42, 05, 79, 30, 49, 99, 73, 46, 37, 50, 02, 45,  9, 54, 52, 27, 95, 27, 65, 19, 45, 26, 45)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList( 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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList( 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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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)),
-				new ArrayList<Integer>(Arrays.asList(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))
-			));
 	}
 }
 

src/main/java/com/mattrixwv/project_euler/problems/Problem7.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem7.java
 //Matthew Ellison
 // Created: 03-01-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 //What is the 10001th prime number?
 //Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -34,7 +34,7 @@ public class Problem7 extends Problem{
 	//Static variables
 	private static final long NUMBER_OF_PRIMES = 10001;	//The number of primes we are trying to get
 	//Instance variables
-	private List<Long> primes;
+	protected List<Long> primes;
 
 	//Functions
 	//Constructor

src/main/java/com/mattrixwv/project_euler/problems/Problem8.java

@@ -1,33 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem8.java
 //Matthew Ellison
 // Created: 03-28-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 //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/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -44,15 +22,21 @@
 */
 package com.mattrixwv.project_euler.problems;
 
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.security.InvalidParameterException;
+import java.util.List;
 
 public class Problem8 extends Problem{
 	//Variables
 	//Static variables
 	//The 1000 digit number to check
-	private static final String NUMBER = "7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450";
+	protected static String FILE_NAME = "files/Problem8Number.txt";
+	protected static String number;
 	//Instance variables
-	private String maxNums;		//Holds the string of the largest product
+	protected String maxNums;	//Holds the string of the largest product
-	private long maxProduct;	//Holds the largest product of 13 numbers
+	protected long maxProduct;	//Holds the largest product of 13 numbers
 
 	//Functions
 	//Constructor
@@ -62,6 +46,25 @@ public class Problem8 extends Problem{
 		maxProduct = 0;
 	}
 	//Operational functions
+	//Read number from file into number
+	private void readFile(){
+		if(number != null){
+			return;
+		}
+		File file = new File(FILE_NAME);
+		if(file.exists()){
+			try{
+				List<String> lines = Files.readAllLines(file.toPath());
+				number = lines.get(0);
+			}
+			catch(IOException error){
+				throw new InvalidParameterException("Error reading file", error);
+			}
+		}
+		else{
+			throw new InvalidParameterException("Error opening file");
+		}
+	}
 	//Solve the problem
 	@Override
 	public void solve(){
@@ -70,17 +73,20 @@ public class Problem8 extends Problem{
 			return;
 		}
 
+		//Read the file into the number
+		readFile();
+
 		//Start the timer
 		timer.start();
 
 
 		//Cycle through the string of numbers looking for the maximum product
-		for(int cnt = 12;cnt < NUMBER.length();++cnt){
+		for(int cnt = 12;cnt < number.length();++cnt){
-			long currentProduct = Long.parseLong(NUMBER.substring(cnt - 12, cnt - 11)) * Long.parseLong(NUMBER.substring(cnt - 11, cnt - 10)) * Long.parseLong(NUMBER.substring(cnt - 10, cnt - 9)) * Long.parseLong(NUMBER.substring(cnt - 9, cnt - 8)) * Long.parseLong(NUMBER.substring(cnt - 8, cnt - 7)) * Long.parseLong(NUMBER.substring(cnt - 7, cnt - 6)) * Long.parseLong(NUMBER.substring(cnt - 6, cnt - 5)) * Long.parseLong(NUMBER.substring(cnt - 5, cnt - 4)) * Long.parseLong(NUMBER.substring(cnt - 4, cnt - 3)) * Long.parseLong(NUMBER.substring(cnt - 3, cnt - 2)) * Long.parseLong(NUMBER.substring(cnt - 2, cnt - 1)) * Long.parseLong(NUMBER.substring(cnt - 1, cnt)) * Long.parseLong(NUMBER.substring(cnt, cnt + 1));
+			long currentProduct = Long.parseLong(number.substring(cnt - 12, cnt - 11)) * Long.parseLong(number.substring(cnt - 11, cnt - 10)) * Long.parseLong(number.substring(cnt - 10, cnt - 9)) * Long.parseLong(number.substring(cnt - 9, cnt - 8)) * Long.parseLong(number.substring(cnt - 8, cnt - 7)) * Long.parseLong(number.substring(cnt - 7, cnt - 6)) * Long.parseLong(number.substring(cnt - 6, cnt - 5)) * Long.parseLong(number.substring(cnt - 5, cnt - 4)) * Long.parseLong(number.substring(cnt - 4, cnt - 3)) * Long.parseLong(number.substring(cnt - 3, cnt - 2)) * Long.parseLong(number.substring(cnt - 2, cnt - 1)) * Long.parseLong(number.substring(cnt - 1, cnt)) * Long.parseLong(number.substring(cnt, cnt + 1));
 
 			//Check if the product is greater than the current maximum
 			if(currentProduct > maxProduct){
-				maxNums = NUMBER.substring(cnt - 12, cnt + 1);
+				maxNums = number.substring(cnt - 12, cnt + 1);
 				maxProduct = currentProduct;
 			}
 		}

src/main/java/com/mattrixwv/project_euler/problems/Problem9.java

@@ -1,11 +1,11 @@
 //ProjectEulerJava/src/main/java/mattrixwv/ProjectEuler/Problems/Problem9.java
 //Matthew Ellison
 // Created: 03-02-19
-//Modified: 08-20-22
+//Modified: 06-27-23
 //There exists exactly one Pythagorean triplet for which a + b + c = 1000. Find the product abc.
 //Unless otherwise listed all non-standard includes are my own creation and available from https://bibucket.org/Mattrixwv/JavaClasses
 /*
-	Copyright (C) 2022  Matthew Ellison
+	Copyright (C) 2023  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
@@ -29,17 +29,17 @@ import com.mattrixwv.project_euler.exceptions.Unsolved;
 public class Problem9 extends Problem{
 	//Variables
 	//Static variables
-	private static final int GOAL_SUM = 1000;	//The number that we want the sum of a, b, and c to equal
+	protected int GOAL_SUM = 1000;	//The number that we want the sum of a, b, and c to equal
 	//Instance variables
-	private int a;		//The size of the first side
+	protected int a;	//The size of the first side
-	private int b;		//The size of the second side
+	protected int b;	//The size of the second side
-	private double c;	//The size of the hyp
+	protected double c;	//The size of the hyp
-	private boolean found;	//A flag to determine if we have found the solution yet
+	protected boolean found;	//A flag to determine if we have found the solution yet
 
 	//Functions
 	//Constructor
 	public Problem9(){
-		super(String.format("There exists exactly one Pythagorean triplet for which a + b + c = %d. Find the product abc.", GOAL_SUM));
+		super(String.format("There exists exactly one Pythagorean triplet for which a + b + c = %d. Find the product abc.", 1000));
 		a = 1;
 		b = 0;
 		c = 0;

src/test/java/com/mattrixwv/project_euler/TestProblemSelection.java

@@ -1,9 +1,11 @@
 package com.mattrixwv.project_euler;
 
+
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import org.junit.jupiter.api.Test;
 
+
 public class TestProblemSelection{
 	@Test
 	public void testProblemSelection(){

src/test/java/com/mattrixwv/project_euler/problems/TestProblem.java

@@ -0,0 +1,89 @@
+package com.mattrixwv.project_euler.problems;
+
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import com.mattrixwv.project_euler.exceptions.Unsolved;
+
+
+@ExtendWith(MockitoExtension.class)
+public class TestProblem{
+	private Problem problem;
+
+
+	@BeforeEach
+	public void setup(){
+		problem = new Problem1();
+	}
+
+	@Test
+	public void testConstructor(){
+		assertNotNull(problem);
+		assertNotNull(problem.getDescription());
+		assertFalse(problem.getSolved());
+	}
+
+	@Test
+	public void testGetDescription(){
+		assertNotNull(problem.getDescription());
+	}
+
+	@Test
+	public void testGetTime(){
+		assertThrows(Unsolved.class, () -> {
+			problem.getTime();
+		});
+
+		problem.solved = true;
+
+		assertNotNull(problem.getTime());
+	}
+
+	@Test
+	public void testGetTimer(){
+		assertThrows(Unsolved.class, () -> {
+			problem.getTimer();
+		});
+
+		problem.solved = true;
+		assertNotNull(problem.getTimer());
+	}
+
+	@Test
+	public void testSolvedCheck(){
+		assertThrows(Unsolved.class, () -> {
+			problem.solvedCheck("");
+		});
+
+		problem.solved = true;
+		problem.solvedCheck("");
+	}
+
+	@Test
+	public void testGetSolved(){
+		assertFalse(problem.getSolved());
+
+		problem.solved = true;
+		assertTrue(problem.getSolved());
+	}
+
+	@Test
+	public void testReset(){
+		problem.solved = true;
+
+		problem.reset();
+
+		assertFalse(problem.getSolved());
+		problem.solved = true;
+		assertEquals(0.0D, problem.getTimer().getNano());
+	}
+}

src/test/java/com/mattrixwv/project_euler/problems/TestProblem1.java

@@ -4,31 +4,29 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem1 extends ProblemBaseTest{
+public class TestProblem1 extends TestProblemBase{
 	@InjectMocks
 	private Problem1 problem = new Problem1();
 	static{
 		description = "What is the sum of all the multiples of 3 or 5 that are less than 1000?";
 		result = "The sum of all numbers < 1000 is 233168";
 	}
+	private int fullSum = 233168;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getResult(); });
@@ -37,13 +35,21 @@ public class TestProblem1 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(233168, problem.getSum());
+		assertEquals(fullSum, problem.getSum());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		//Setup
+		problem.fullSum = fullSum;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(0, problem.fullSum);
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem10.java

@@ -4,31 +4,29 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem10 extends ProblemBaseTest{
+public class TestProblem10 extends TestProblemBase{
 	@InjectMocks
 	private Problem10 problem;
 	static{
 		description = "Find the sum of all the primes below 2000000.";
 		result = "The sum of all the primes < 2000000 is 142913828922";
 	}
+	private long sum = 142913828922L;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getSum(); });
@@ -36,13 +34,21 @@ public class TestProblem10 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(142913828922L, problem.getSum());
+		assertEquals(sum, problem.getSum());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		//Setup
+		problem.sum = sum;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(0, problem.sum);
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem11.java

@@ -4,33 +4,36 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.security.InvalidParameterException;
+import java.util.ArrayList;
 import java.util.List;
 
-import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem11 extends ProblemBaseTest{
+public class TestProblem11 extends TestProblemBase{
 	@InjectMocks
 	private Problem11 problem;
 	static{
 		description = "What is the greatest product of four adjacent numbers in the same direction (up, down, left, right, or diagonally) in the 20×20 grid?";
 		result = String.format("The greatest product of 4 numbers in a line is 70600674%nThe numbers are [89, 94, 97, 87]");
 	}
+	private List<Integer> greatestProduct = List.of(89, 94, 97, 87);
+	private int product = 70600674;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getNumbers(); });
@@ -39,14 +42,49 @@ public class TestProblem11 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(List.of(89, 94, 97, 87), problem.getNumbers());
+		assertEquals(greatestProduct, problem.getNumbers());
-		assertEquals(70600674, problem.getProduct());
+		assertEquals(product, problem.getProduct());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		//Setup
+		problem.greatestProduct = new ArrayList<>(greatestProduct);
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(new ArrayList<>(), problem.greatestProduct);
+	}
+
+	@Test
+	public void testSolve_readError() throws IOException{
+		problem.reset();
+
+		Problem11.grid = null;
+		RandomAccessFile file = new RandomAccessFile(Problem11.FILE_NAME, "rw");
+		file.getChannel().lock();
+
+		assertThrows(InvalidParameterException.class, () -> {
+			problem.solve();
+		});
+
+		file.close();
+	}
+
+	@Test
+	public void testSolve_noFile(){
+		problem.reset();
+
+		Problem11.grid = null;
+		Problem11.FILE_NAME = "/a";
+
+		assertThrows(InvalidParameterException.class, () -> {
+			problem.solve();
+		});
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem12.java

@@ -4,31 +4,35 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
+import java.util.ArrayList;
+import java.util.List;
+
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
+import com.mattrixwv.NumberAlgorithms;
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem12 extends ProblemBaseTest{
+public class TestProblem12 extends TestProblemBase{
 	@InjectMocks
 	private Problem12 problem;
 	static{
 		description = "What is the value of the first triangle number to have over 500 divisors?";
 		result = "The triangular number 76576500 is the sum of all numbers >= 12375 and has 576 divisors";
 	}
+	private long sum = 76576500;
+	private long counter = 12375;
+	private List<Long> divisors = NumberAlgorithms.getDivisors(sum);
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getTriangularNumber(); });
@@ -39,16 +43,28 @@ public class TestProblem12 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(76576500, problem.getTriangularNumber());
+		assertEquals(sum, problem.getTriangularNumber());
-		assertEquals(12375, problem.getLastNumberAdded());
+		assertEquals(counter, problem.getLastNumberAdded());
-		assertEquals(576, problem.getDivisorsOfTriangularNumber().size());
+		assertEquals(divisors, problem.getDivisorsOfTriangularNumber());
-		assertEquals(576, problem.getNumberOfDivisors());
+		assertEquals(divisors.size(), problem.getNumberOfDivisors());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		//Setup
+		problem.sum = sum;
+		problem.counter = counter;
+		problem.divisors = new ArrayList<>(divisors);
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(1, problem.sum);
+		assertEquals(2, problem.counter);
+		assertEquals(new ArrayList<>(), problem.divisors);
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem13.java

@@ -4,33 +4,34 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
+import java.io.IOException;
+import java.io.RandomAccessFile;
 import java.math.BigInteger;
+import java.security.InvalidParameterException;
 
-import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem13 extends ProblemBaseTest{
+public class TestProblem13 extends TestProblemBase{
 	@InjectMocks
 	private Problem13 problem;
 	static{
 		description = "Work out the first ten digits of the sum of the one-hundred 50-digit numbers";
 		result = String.format("The sum of all 100 numbers is 5537376230390876637302048746832985971773659831892672%nThe first 10 digits of the sum of the numbers is 5537376230");
 	}
+	private BigInteger sum = new BigInteger("5537376230390876637302048746832985971773659831892672");
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getNumbers(); });
@@ -40,13 +41,48 @@ public class TestProblem13 extends ProblemBaseTest{
 
 		//Verify result
 		assertEquals(100, problem.getNumbers().size());
-		assertEquals(new BigInteger("5537376230390876637302048746832985971773659831892672"), problem.getSum());
+		assertEquals(sum, problem.getSum());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		//Setup
+		problem.sum = sum;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(BigInteger.ZERO, problem.sum);
+	}
+
+	@Test
+	public void testSolve_readError() throws IOException{
+		problem.reset();
+
+		Problem13.nums = null;
+		RandomAccessFile file = new RandomAccessFile(Problem13.FILE_NAME, "rw");
+		file.getChannel().lock();
+
+		assertThrows(InvalidParameterException.class, () -> {
+			problem.solve();
+		});
+
+		file.close();
+	}
+
+	@Test
+	public void testSolve_noFile(){
+		problem.reset();
+
+		Problem13.nums = null;
+		Problem13.FILE_NAME = "/a";
+
+		assertThrows(InvalidParameterException.class, () -> {
+			problem.solve();
+		});
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem14.java

@@ -4,31 +4,30 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem14 extends ProblemBaseTest{
+public class TestProblem14 extends TestProblemBase{
 	@InjectMocks
 	private Problem14 problem;
 	static{
 		description = "Which starting number, under 1000000, produces the longest chain using the iterative sequence?";
 		result = "The number 837799 produced a chain of 525 steps";
 	}
+	private long maxLength = 525L;
+	private long maxNum = 837799L;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getLength(); });
@@ -37,14 +36,24 @@ public class TestProblem14 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(525, problem.getLength());
+		assertEquals(maxLength, problem.getLength());
-		assertEquals(837799, problem.getStartingNumber());
+		assertEquals(maxNum, problem.getStartingNumber());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		//Setup
+		problem.maxLength = maxLength;
+		problem.maxNum = maxNum;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(0L, problem.maxLength);
+		assertEquals(0L, problem.maxNum);
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem15.java

@@ -4,31 +4,29 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem15 extends ProblemBaseTest{
+public class TestProblem15 extends TestProblemBase{
 	@InjectMocks
 	private Problem15Override problem;
 	static{
 		description = "How many routes from the top left corner to the bottom right corner are there through a 5x5 grid if you can only move right and down?";
 		result = "The number of routes is 252";
 	}
+	private long numOfRoutes = 252;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getNumberOfRoutes(); });
@@ -36,16 +34,24 @@ public class TestProblem15 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(252, problem.getNumberOfRoutes());
+		assertEquals(numOfRoutes, problem.getNumberOfRoutes());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		//Setup
+		problem.numOfRoutes = numOfRoutes;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
 
+	@Override
+	public void verifyReset(){
+		assertEquals(0L, problem.numOfRoutes);
+	}
+
 	public static class Problem15Override extends Problem15{
 		static{
 			gridWidth = 5;

src/test/java/com/mattrixwv/project_euler/problems/TestProblem16.java

@@ -4,45 +4,58 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
+import java.math.BigInteger;
+
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem16 extends ProblemBaseTest{
+public class TestProblem16 extends TestProblemBase{
 	@InjectMocks
 	private Problem16 problem;
 	static{
 		description = "What is the sum of the digits of the number 2^1000?";
 		result = String.format("2^1000 = 10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831652624386837205668069376%nThe sum of the elements is 1366");
 	}
+	private BigInteger num = new BigInteger("10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831652624386837205668069376");
+	private int sum = 1366;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
+		assertThrows(Unsolved.class, () -> {problem.getNumber(); });
 		assertThrows(Unsolved.class, () -> { problem.getSum(); });
 
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(1366, problem.getSum());
+		assertEquals(num, problem.getNumber());
+		assertEquals(sum, problem.getSum());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		//Setup
+		problem.num = num;
+		problem.sumOfElements = sum;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(BigInteger.ZERO, problem.num);
+		assertEquals(0, problem.sumOfElements);
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem17.java

@@ -4,31 +4,29 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem17 extends ProblemBaseTest{
+public class TestProblem17 extends TestProblemBase{
 	@InjectMocks
 	private Problem17 problem;
 	static{
 		description = "If all the numbers from 1 to 1000 inclusive were written out in words, how many letters would be used?";
 		result = "The sum of all the letters in all the numbers 1-1000 is 21124";
 	}
+	private long letterCount = 21124L;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getLetterCount(); });
@@ -36,13 +34,35 @@ public class TestProblem17 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(21124, problem.getLetterCount());
+		assertEquals(letterCount, problem.getLetterCount());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		//Setup
+		problem.letterCount = letterCount;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(0, problem.letterCount);
+	}
+
+	@Test
+	public void testMakeWordFromNum_negative(){
+		String numberString = problem.makeWordFromNum(-1);
+
+		assertEquals("negative one", numberString);
+	}
+
+	@Test
+	public void testMakeWordFromNum_zero(){
+		String numberString = problem.makeWordFromNum(0);
+
+		assertEquals("zero", numberString);
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem18.java

@@ -2,33 +2,39 @@ package com.mattrixwv.project_euler.problems;
 
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.security.InvalidParameterException;
+import java.util.ArrayList;
 
-import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
+import com.mattrixwv.project_euler.problems.Problem18.Location;
 
 
-public class TestProblem18 extends ProblemBaseTest{
+public class TestProblem18 extends TestProblemBase{
 	@InjectMocks
 	private Problem18 problem;
 	static{
 		description = "Find the maximum total from top to bottom";
 		result = "The value of the longest path is 1074";
 	}
+	private int total = 1074;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getTotal(); });
@@ -36,15 +42,85 @@ public class TestProblem18 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(1074, problem.getTotal());
+		assertEquals(total, problem.getTotal());
 		assertEquals(String.format("75\n95 64\n17 47 82\n18 35 87 10\n20  4 82 47 65\n19  1 23 75  3 34\n88  2 77 73  7 63 67\n99 65  4 28  6 16 70 92\n41 41 26 56 83 40 80 70 33\n41 48 72 33 47 32 37 16 94 29\n53 71 44 65 25 43 91 52 97 51 14\n70 11 33 28 77 73 17 78 39 68 17 57\n91 71 52 38 17 14 91 43 58 50 27 29 48\n63 66  4 68 89 53 67 30 73 16 69 87 40 31\n 4 62 98 27 23  9 70 98 73 93 38 53 60  4 23"), problem.getPyramid());
 		assertEquals("75->95->47->35->4->23->73->6->40->37->91->78->58->73->93", problem.getTrail());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		//Setup
+		problem.actualTotal = total;
+		problem.foundPoints = new ArrayList<>();
+		problem.foundPoints.add(new Location(0, 0, 0, true));
+		problem.possiblePoints = new ArrayList<>();
+		problem.possiblePoints.add(new Location(0, 0, 0, true));
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals("files/Problem18Pyramid.txt", problem.FILE_NAME);
+		assertEquals(new ArrayList<>(), problem.foundPoints);
+		assertEquals(new ArrayList<>(), problem.possiblePoints);
+		assertEquals(0, problem.actualTotal);
+	}
+
+	@Test
+	public void testSolve_readError() throws IOException{
+		problem.reset();
+
+		Problem18.list = null;
+		RandomAccessFile file = new RandomAccessFile(problem.FILE_NAME, "rw");
+		file.getChannel().lock();
+
+		assertThrows(InvalidParameterException.class, () -> {
+			problem.solve();
+		});
+
+		file.close();
+	}
+
+	@Test
+	public void testSolve_noFile(){
+		problem.reset();
+
+		Problem18.list = null;
+		problem.FILE_NAME = "/a";
+
+		assertThrows(InvalidParameterException.class, () -> {
+			problem.solve();
+		});
+	}
+
+	@Test
+	public void testLocation(){
+		int x = 1;
+		int y = 2;
+		int t = 3;
+		boolean r = true;
+		Location location = new Location(x, y, t, r);
+
+		assertEquals(x, location.getXLocation());
+		assertEquals(y, location.getYLocation());
+		assertEquals(t, location.getTotal());
+		assertTrue(location.getFromRight());
+
+		x = 4;
+		y = 5;
+		t = 6;
+		r = false;
+		location.setXLocation(x);
+		location.setYLocation(y);
+		location.setTotal(t);
+		location.setFromRight(r);
+
+		assertEquals(x, location.getXLocation());
+		assertEquals(y, location.getYLocation());
+		assertEquals(t, location.getTotal());
+		assertFalse(location.getFromRight());
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem19.java

@@ -4,31 +4,29 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem19 extends ProblemBaseTest{
+public class TestProblem19 extends TestProblemBase{
 	@InjectMocks
 	private Problem19 problem;
 	static{
 		description = "How many Sundays fell on the first of the month during the twentieth century (1 Jan 1901 to 31 Dec 2000)?";
 		result = "There are 171 Sundays that landed on the first of the months from 1901 to 2000";
 	}
+	private long totalSundays = 171L;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getTotalSundays(); });
@@ -36,13 +34,21 @@ public class TestProblem19 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(171, problem.getTotalSundays());
+		assertEquals(totalSundays, problem.getTotalSundays());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		//Setup
+		problem.totalSundays = totalSundays;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(0, problem.totalSundays);
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem2.java

@@ -4,31 +4,29 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem2 extends ProblemBaseTest{
+public class TestProblem2 extends TestProblemBase{
 	@InjectMocks
 	private Problem2 problem;
 	static{
 		description = "What is the sum of the even Fibonacci numbers less than 4000000?";
 		result = "The sum of all even fibonacci numbers <= 3999999 is 4613732";
 	}
+	private int fullSum = 4613732;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getResult(); });
@@ -37,13 +35,21 @@ public class TestProblem2 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(4613732, problem.getSum());
+		assertEquals(fullSum, problem.getSum());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		//Setup
+		problem.fullSum = fullSum;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(0, problem.fullSum);
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem20.java

@@ -6,31 +6,31 @@ import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import java.math.BigInteger;
 
-import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem20 extends ProblemBaseTest{
+public class TestProblem20 extends TestProblemBase{
 	@InjectMocks
 	private Problem20 problem;
 	static{
 		description = "What is the sum of the digits of 100!?";
 		result = String.format("100! = 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000%nThe sum of the digits is: 648");
 	}
+	private String numString = "93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000";
+	private BigInteger num = new BigInteger(numString);
+	private long sum = 648L;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getNumber(); });
@@ -40,15 +40,25 @@ public class TestProblem20 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(new BigInteger("93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000"), problem.getNumber());
+		assertEquals(numString, problem.getNumberString());
-		assertEquals("93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000", problem.getNumberString());
+		assertEquals(num, problem.getNumber());
-		assertEquals(648, problem.getSum());
+		assertEquals(sum, problem.getSum());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		//Setup
+		problem.num = num;
+		problem.sum = sum;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(BigInteger.ONE, problem.num);
+		assertEquals(0L, problem.sum);
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem21.java

@@ -4,33 +4,33 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
+import java.util.ArrayList;
 import java.util.List;
 
-import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem21 extends ProblemBaseTest{
+public class TestProblem21 extends TestProblemBase{
 	@InjectMocks
 	private Problem21 problem;
 	static{
 		description = "Evaluate the sum of all the amicable numbers under 10000";
 		result = String.format("All amicable numbers less than 10000 are%n220%n284%n1184%n1210%n2620%n2924%n5020%n5564%n6232%n6368%nThe sum of all of these amicable numbers is 31626");
 	}
+	private List<Integer> amicable = List.of(220, 284, 1184, 1210, 2620, 2924, 5020, 5564, 6232, 6368);
+	private int sum = 31626;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getAmicable(); });
@@ -39,14 +39,27 @@ public class TestProblem21 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(List.of(220, 284, 1184, 1210, 2620, 2924, 5020, 5564, 6232, 6368), problem.getAmicable());
+		assertEquals(amicable, problem.getAmicable());
-		assertEquals(31626, problem.getSum());
+		assertEquals(sum, problem.getSum());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		//Setup
+		problem.amicable = new ArrayList<>(amicable);
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(new ArrayList<>(), problem.amicable);
+		ArrayList<Integer> divisorSum = new ArrayList<>(10000);
+		while(divisorSum.size() < 10000){
+			divisorSum.add(0);
+		}
+		assertEquals(divisorSum, problem.divisorSum);
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem22.java

@@ -4,31 +4,34 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.security.InvalidParameterException;
+import java.util.ArrayList;
+
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem22 extends ProblemBaseTest{
+public class TestProblem22 extends TestProblemBase{
 	@InjectMocks
 	private Problem22 problem;
 	static{
 		description = "What is the total of all the name scores in this file?";
 		result = "The answer to the question is 871198282";
 	}
+	private long sum = 871198282L;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getNameScoreSum(); });
@@ -37,13 +40,54 @@ public class TestProblem22 extends ProblemBaseTest{
 
 		//Verify result
 		assertEquals(5163, Problem22.getNames().size());
-		assertEquals(871198282L, problem.getNameScoreSum());
+		assertEquals(sum, problem.getNameScoreSum());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		//Setup
+		problem.sums = new ArrayList<>();
+		problem.sums.add(1L);
+		problem.prod = new ArrayList<>();
+		problem.prod.add(2L);
+		problem.sum = sum;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(new ArrayList<>(), problem.sums);
+		assertEquals(new ArrayList<>(), problem.prod);
+		assertEquals(0L, problem.sum);
+	}
+
+	@Test
+	public void testSolve_readError() throws IOException{
+		problem.reset();
+
+		Problem22.names = new ArrayList<>();
+		RandomAccessFile file = new RandomAccessFile(Problem22.FILE_NAME, "rw");
+		file.getChannel().lock();
+
+		assertThrows(InvalidParameterException.class, () -> {
+			problem.solve();
+		});
+
+		file.close();
+	}
+
+	@Test
+	public void testSolve_noFile(){
+		problem.reset();
+
+		Problem22.names = new ArrayList<>();
+		Problem22.FILE_NAME = "/a";
+
+		assertThrows(InvalidParameterException.class, () -> {
+			problem.solve();
+		});
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem23.java

@@ -4,31 +4,38 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
+import java.util.ArrayList;
+
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem23 extends ProblemBaseTest{
+public class TestProblem23 extends TestProblemBase{
 	@InjectMocks
-	private Problem23Override problem;
+	private Problem23 problem;
 	static{
 		description = "Find the sum of all the positive integers which cannot be written as the sum of two abundant numbers";
 		result = "The answer is 2035227";
 	}
+	private long sum = 2035227L;
+
+
+	@BeforeEach
+	public void setup(){
+		Problem23.maxNum = 5000;
+	}
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getSum(); });
@@ -36,20 +43,26 @@ public class TestProblem23 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(2035227, problem.getSum());
+		assertEquals(sum, problem.getSum());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		//Setup
+		problem.sum = sum;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
 
-
+	@Override
-	public static class Problem23Override extends Problem23{
+	public void verifyReset(){
-		static{
+		assertEquals(0L, problem.sum);
-			maxNum = 5000;
+		ArrayList<Integer> divisorSums = new ArrayList<>(5000);
+		while(divisorSums.size() <= 5000){
+			divisorSums.add(0);
 		}
+		assertEquals(divisorSums, problem.divisorSums);
 	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem24.java

@@ -4,14 +4,15 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
+import java.util.ArrayList;
+
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem24 extends ProblemBaseTest{
+public class TestProblem24 extends TestProblemBase{
 	@InjectMocks
 	private Problem24Override problem;
 	static{
@@ -21,14 +22,12 @@ public class TestProblem24 extends ProblemBaseTest{
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getPermutationsList(); });
@@ -42,12 +41,21 @@ public class TestProblem24 extends ProblemBaseTest{
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		//Setup
+		problem.permutations = new ArrayList<>();
+		problem.permutations.add("1");
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
 
+	@Override
+	public void verifyReset(){
+		assertEquals(new ArrayList<>(), problem.permutations);
+	}
+
 
 	public static class Problem24Override extends Problem24{
 		static{

src/test/java/com/mattrixwv/project_euler/problems/TestProblem25.java

@@ -6,31 +6,33 @@ import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import java.math.BigInteger;
 
-import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem25 extends ProblemBaseTest{
+public class TestProblem25 extends TestProblemBase{
 	@InjectMocks
 	private Problem25 problem;
 	static{
 		description = "What is the index of the first term in the Fibonacci sequence to contain 1000 digits?";
 		result = String.format("The first Fibonacci number with 1000 digits is 1070066266382758936764980584457396885083683896632151665013235203375314520604694040621889147582489792657804694888177591957484336466672569959512996030461262748092482186144069433051234774442750273781753087579391666192149259186759553966422837148943113074699503439547001985432609723067290192870526447243726117715821825548491120525013201478612965931381792235559657452039506137551467837543229119602129934048260706175397706847068202895486902666185435124521900369480641357447470911707619766945691070098024393439617474103736912503231365532164773697023167755051595173518460579954919410967778373229665796581646513903488154256310184224190259846088000110186255550245493937113651657039447629584714548523425950428582425306083544435428212611008992863795048006894330309773217834864543113205765659868456288616808718693835297350643986297640660000723562917905207051164077614812491885830945940566688339109350944456576357666151619317753792891661581327159616877487983821820492520348473874384736771934512787029218636250627816%nIts index is 4782");
 	}
+	private String numberString = "1070066266382758936764980584457396885083683896632151665013235203375314520604694040621889147582489792657804694888177591957484336466672569959512996030461262748092482186144069433051234774442750273781753087579391666192149259186759553966422837148943113074699503439547001985432609723067290192870526447243726117715821825548491120525013201478612965931381792235559657452039506137551467837543229119602129934048260706175397706847068202895486902666185435124521900369480641357447470911707619766945691070098024393439617474103736912503231365532164773697023167755051595173518460579954919410967778373229665796581646513903488154256310184224190259846088000110186255550245493937113651657039447629584714548523425950428582425306083544435428212611008992863795048006894330309773217834864543113205765659868456288616808718693835297350643986297640660000723562917905207051164077614812491885830945940566688339109350944456576357666151619317753792891661581327159616877487983821820492520348473874384736771934512787029218636250627816";
+	private BigInteger number = new BigInteger(numberString);
+	private int indexInt = 4782;
+	private String indexString = Integer.toString(indexInt);
+	private BigInteger index = new BigInteger(indexString);
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getNumber(); });
@@ -42,17 +44,27 @@ public class TestProblem25 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(new BigInteger("1070066266382758936764980584457396885083683896632151665013235203375314520604694040621889147582489792657804694888177591957484336466672569959512996030461262748092482186144069433051234774442750273781753087579391666192149259186759553966422837148943113074699503439547001985432609723067290192870526447243726117715821825548491120525013201478612965931381792235559657452039506137551467837543229119602129934048260706175397706847068202895486902666185435124521900369480641357447470911707619766945691070098024393439617474103736912503231365532164773697023167755051595173518460579954919410967778373229665796581646513903488154256310184224190259846088000110186255550245493937113651657039447629584714548523425950428582425306083544435428212611008992863795048006894330309773217834864543113205765659868456288616808718693835297350643986297640660000723562917905207051164077614812491885830945940566688339109350944456576357666151619317753792891661581327159616877487983821820492520348473874384736771934512787029218636250627816"), problem.getNumber());
+		assertEquals(number, problem.getNumber());
-		assertEquals("1070066266382758936764980584457396885083683896632151665013235203375314520604694040621889147582489792657804694888177591957484336466672569959512996030461262748092482186144069433051234774442750273781753087579391666192149259186759553966422837148943113074699503439547001985432609723067290192870526447243726117715821825548491120525013201478612965931381792235559657452039506137551467837543229119602129934048260706175397706847068202895486902666185435124521900369480641357447470911707619766945691070098024393439617474103736912503231365532164773697023167755051595173518460579954919410967778373229665796581646513903488154256310184224190259846088000110186255550245493937113651657039447629584714548523425950428582425306083544435428212611008992863795048006894330309773217834864543113205765659868456288616808718693835297350643986297640660000723562917905207051164077614812491885830945940566688339109350944456576357666151619317753792891661581327159616877487983821820492520348473874384736771934512787029218636250627816", problem.getNumberString());
+		assertEquals(numberString, problem.getNumberString());
-		assertEquals(BigInteger.valueOf(4782), problem.getIndex());
+		assertEquals(index, problem.getIndex());
-		assertEquals("4782", problem.getIndexString());
+		assertEquals(indexString, problem.getIndexString());
-		assertEquals(4782, problem.getIndexInt());
+		assertEquals(indexInt, problem.getIndexInt());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		//Setup
+		problem.number = number;
+		problem.index = index;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(BigInteger.ZERO, problem.number);
+		assertEquals(BigInteger.TWO, problem.index);
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem26.java

@@ -4,31 +4,30 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem26 extends ProblemBaseTest{
+public class TestProblem26 extends TestProblemBase{
 	@InjectMocks
 	private Problem26 problem;
 	static{
 		description = "Find the value of d <= 999 for which 1/d contains the longest recurring cycle in its decimal fraction part.";
 		result = String.format("The longest cycle is 982 digits long%nIt started with the number 983");
 	}
+	private int longestCycle = 982;
+	private int longestNumber = 983;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getLongestCycle(); });
@@ -37,14 +36,24 @@ public class TestProblem26 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(982, problem.getLongestCycle());
+		assertEquals(longestCycle, problem.getLongestCycle());
-		assertEquals(983, problem.getLongestNumber());
+		assertEquals(longestNumber, problem.getLongestNumber());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		//Setup
+		problem.longestCycle = longestCycle;
+		problem.longestNumber = longestNumber;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(0, problem.longestCycle);
+		assertEquals(1, problem.longestNumber);
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem27.java

@@ -4,31 +4,31 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem27 extends ProblemBaseTest{
+public class TestProblem27 extends TestProblemBase{
 	@InjectMocks
 	private Problem27 problem;
 	static{
 		description = "Find the product of the coefficients, |a| <= 999 and |b| <= 1000, for the quadratic expression that produces the maximum number of primes for consecutive values of n, starting with n=0";
 		result = String.format("The greatest number of primes found is 70%nIt was found with A = -61, B = 971%nThe product of A and B is -59231");
 	}
+	private int topA = -61;
+	private int topB = 971;
+	private int topN = 70;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getTopA(); });
@@ -39,16 +39,28 @@ public class TestProblem27 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(-61, problem.getTopA());
+		assertEquals(topA, problem.getTopA());
-		assertEquals(971, problem.getTopB());
+		assertEquals(topB, problem.getTopB());
-		assertEquals(70, problem.getTopN());
+		assertEquals(topN, problem.getTopN());
-		assertEquals(-59231, problem.getProduct());
+		assertEquals(topA * topB, problem.getProduct());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		//Setup
+		problem.topA = topA;
+		problem.topB = topB;
+		problem.topN = topN;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(0, problem.topA);
+		assertEquals(0, problem.topB);
+		assertEquals(0, problem.topN);
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem28.java

@@ -5,31 +5,31 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
+import java.util.ArrayList;
+
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem28 extends ProblemBaseTest{
+public class TestProblem28 extends TestProblemBase{
 	@InjectMocks
 	private Problem28 problem;
 	static{
 		description = "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?";
 		result = "The sum of the diagonals in the given grid is 669171001";
 	}
+	private int sum = 669171001;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getGrid(); });
@@ -39,13 +39,28 @@ public class TestProblem28 extends ProblemBaseTest{
 
 		//Verify result
 		assertNotNull(problem.getGrid());
-		assertEquals(669171001, problem.getSum());
+		assertEquals(sum, problem.getSum());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		//Setup
+		problem.grid = new ArrayList<>();
+		problem.grid.add(new ArrayList<>());
+		problem.grid.get(0).add(1);
+		problem.sumOfDiagonals = sum;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		ArrayList<ArrayList<Integer>> grid = new ArrayList<>();
+		grid.add(new ArrayList<>());
+		grid.get(0).add(1);
+		assertEquals(grid, problem.grid);
+		assertEquals(0, problem.sumOfDiagonals);
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem29.java

@@ -4,31 +4,33 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.List;
+
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem29 extends ProblemBaseTest{
+public class TestProblem29 extends TestProblemBase{
 	@InjectMocks
 	private Problem29 problem;
 	static{
 		description = "How many distinct terms are in the sequence generated by a^b for 2 <= a <= 100 and 2 <= b <= 100?";
 		result = "The number of unique values generated by a^b for 2 <= a <= 100 and 2 <= b <= 100 is 9183";
 	}
+	private List<BigInteger> unique = List.of(BigInteger.ONE);
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getUnique(); });
@@ -39,12 +41,24 @@ public class TestProblem29 extends ProblemBaseTest{
 		//Verify result
 		assertEquals(9183, problem.getUnique().size());
 		assertEquals(9183, problem.getNumUnique());
+		assertEquals(2, Problem29.getBottomA());
+		assertEquals(2, Problem29.getBottomB());
+		assertEquals(100, Problem29.getTopA());
+		assertEquals(100, Problem29.getTopB());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		//Setup
+		problem.unique = new ArrayList<>(unique);
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(new ArrayList<>(), problem.unique);
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem3.java

@@ -4,25 +4,28 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
+import java.util.ArrayList;
+import java.util.List;
+
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
-import com.mattrixwv.NumberAlgorithms;
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem3 extends ProblemBaseTest{
+public class TestProblem3 extends TestProblemBase{
 	@InjectMocks
 	private Problem3 problem;
 	static{
 		description = "What is the largest prime factor of 600851475143?";
 		result = "The largest factor of the number 600851475143 is 6857";
 	}
+	private static List<Long> factors = List.of(71L, 839L, 1471L, 6857L);
+	private long largestFactor = 6857;
+
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
@@ -30,7 +33,6 @@ public class TestProblem3 extends ProblemBaseTest{
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getResult(); });
@@ -40,14 +42,22 @@ public class TestProblem3 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(NumberAlgorithms.getFactors(600851475143L), problem.getFactors());
+		assertEquals(factors, problem.getFactors());
-		assertEquals(6857, problem.getLargestFactor());
+		assertEquals(largestFactor, problem.getLargestFactor());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		//Setup
+		problem.factors = new ArrayList<>(factors);
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(new ArrayList<>(), problem.factors);
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem30.java

@@ -4,33 +4,33 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
+import java.util.ArrayList;
 import java.util.List;
 
-import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem30 extends ProblemBaseTest{
+public class TestProblem30 extends TestProblemBase{
 	@InjectMocks
 	private Problem30 problem;
 	static{
 		description = "Find the sum of all the numbers that can be written as the sum of the fifth powers of their digits.";
 		result = String.format("The sum of all the numbers that can be written as the sum of the fifth powers of their digits is 443839");
 	}
+	private List<Long> sumOfFifthNumbers = List.of(4150L, 4151L, 54748L, 92727L, 93084L, 194979L);
+	private long sum = 443839L;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getListOfSumOfFifths(); });
@@ -39,14 +39,24 @@ public class TestProblem30 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(List.of(4150L, 4151L, 54748L, 92727L, 93084L, 194979L), problem.getListOfSumOfFifths());
+		assertEquals(sumOfFifthNumbers, problem.getListOfSumOfFifths());
-		assertEquals(443839L, problem.getSumOfList());
+		assertEquals(sum, problem.getSumOfList());
+		assertEquals(1000000L, Problem30.getTopNum());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		problem.sumOfFifthNumbers = new ArrayList<>(sumOfFifthNumbers);
+		problem.sum = sum;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(new ArrayList<>(), problem.sumOfFifthNumbers);
+		assertEquals(0L, problem.sum);
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem31.java

@@ -4,31 +4,29 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem31 extends ProblemBaseTest{
+public class TestProblem31 extends TestProblemBase{
 	@InjectMocks
 	private Problem31 problem;
 	static{
 		description = "How many different ways can 2 pounds be made using any number of coins?";
 		result = "There are 73682 ways to make 2 pounds with the given denominations of coins";
 	}
+	private int permutations = 73682;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getPermutations(); });
@@ -36,13 +34,21 @@ public class TestProblem31 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(73682, problem.getPermutations());
+		assertEquals(permutations, problem.getPermutations());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		//Setup
+		problem.permutations = permutations;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(0, problem.permutations);
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem32.java

@@ -2,33 +2,35 @@ package com.mattrixwv.project_euler.problems;
 
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
+import java.util.ArrayList;
+
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
+import com.mattrixwv.project_euler.problems.Problem32.ProductSet;
 
 
-public class TestProblem32 extends ProblemBaseTest{
+public class TestProblem32 extends TestProblemBase{
 	@InjectMocks
 	private Problem32 problem;
 	static{
 		description = "Find the sum of all products whose multiplicand/multiplier/product identity can be written as a 1 through 9 pandigital.";
 		result = String.format("There are 7 unique 1-9 pandigitals%nThe sum of the products of these pandigitals is 45228");
 	}
+	private long sum = 45228L;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getSumOfPandigitals(); });
@@ -36,13 +38,40 @@ public class TestProblem32 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(45228, problem.getSumOfPandigitals());
+		assertEquals(sum, problem.getSumOfPandigitals());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		//Setup
+		problem.listOfProducts = new ArrayList<>();
+		problem.listOfProducts.add(problem.new ProductSet(5, 6));
+		problem.sumOfPandigitals = sum;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(new ArrayList<>(), problem.listOfProducts);
+		assertEquals(0, problem.sumOfPandigitals);
+	}
+
+	@Test
+	public void testProductSet(){
+		int multiplicand = 2;
+		int multiplier = 3;
+		ProductSet ps = new Problem32().new ProductSet(multiplicand, multiplier);
+
+		assertEquals(multiplicand, ps.getMultiplicand());
+		assertEquals(multiplier, ps.getMultiplier());
+		assertEquals(multiplicand * multiplier, ps.getProduct());
+		assertEquals(ps, ps);
+		assertNotEquals(ps, 0);
+		assertEquals(ps, new Problem32().new ProductSet(multiplicand, multiplier));
+		assertEquals(((2 * multiplicand) + (3 * multiplier)), ps.hashCode());
+		assertEquals("236", ps.toString());
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem33.java

@@ -4,33 +4,34 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
+import java.util.ArrayList;
 import java.util.List;
 
-import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem33 extends ProblemBaseTest{
+public class TestProblem33 extends TestProblemBase{
 	@InjectMocks
 	private Problem33 problem;
 	static{
 		description = "If the product of these four fractions is given in its lowest common terms, find the value of the denominator";
 		result = "The denominator of the product is 100";
 	}
+	private List<Integer> numerators = List.of(16, 26, 19, 49);
+	private List<Integer> denominators = List.of(64, 65, 95, 98);
+	private int prod = 100;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getNumerators(); });
@@ -40,15 +41,27 @@ public class TestProblem33 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(List.of(16, 26, 19, 49), problem.getNumerators());
+		assertEquals(numerators, problem.getNumerators());
-		assertEquals(List.of(64, 65, 95, 98), problem.getDenominators());
+		assertEquals(denominators, problem.getDenominators());
-		assertEquals(100, problem.getProdDenominator());
+		assertEquals(prod, problem.getProdDenominator());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		//Setup
+		problem.numerators = new ArrayList<>(numerators);
+		problem.denominators = new ArrayList<>(denominators);
+		problem.prodDenominator = prod;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(new ArrayList<>(), problem.numerators);
+		assertEquals(new ArrayList<>(), problem.denominators);
+		assertEquals(1, problem.prodDenominator);
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem34.java

@@ -4,33 +4,33 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
+import java.util.ArrayList;
 import java.util.List;
 
-import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem34 extends ProblemBaseTest{
+public class TestProblem34 extends TestProblemBase{
 	@InjectMocks
 	private Problem34 problem;
 	static{
 		description = "Find the sum of all numbers which are equal to the sum of the factorial of their digits";
 		result = "The sum of all numbers that are the sum of their digit's factorials is 40730";
 	}
+	private List<Integer> factorials = List.of(1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880);
+	private int sum = 40730;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getFactorials(); });
@@ -39,14 +39,24 @@ public class TestProblem34 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(List.of(1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880), problem.getFactorials());
+		assertEquals(factorials, problem.getFactorials());
-		assertEquals(40730, problem.getSum());
+		assertEquals(sum, problem.getSum());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		//Setup
+		problem.factorials = new ArrayList<>(factorials);
+		problem.sum = sum;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(List.of(0, 0, 0, 0, 0, 0, 0, 0, 0, 0), problem.factorials);
+		assertEquals(0, problem.sum);
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem35.java

@@ -4,14 +4,15 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
+import java.util.ArrayList;
+
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem35 extends ProblemBaseTest{
+public class TestProblem35 extends TestProblemBase{
 	@InjectMocks
 	private Problem35Override problem;
 	static{
@@ -21,14 +22,12 @@ public class TestProblem35 extends ProblemBaseTest{
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getPrimes(); });
@@ -44,12 +43,24 @@ public class TestProblem35 extends ProblemBaseTest{
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		//Setup
+		problem.primes = new ArrayList<>();
+		problem.primes.add(1);
+		problem.circularPrimes = new ArrayList<>();
+		problem.circularPrimes.add(2);
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
 
+	@Override
+	public void verifyReset(){
+		assertEquals(new ArrayList<>(), problem.primes);
+		assertEquals(new ArrayList<>(), problem.circularPrimes);
+	}
+
 
 	public static class Problem35Override extends Problem35{
 		static{

src/test/java/com/mattrixwv/project_euler/problems/TestProblem36.java

@@ -4,31 +4,33 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
+import java.util.ArrayList;
+import java.util.List;
+
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem36 extends ProblemBaseTest{
+public class TestProblem36 extends TestProblemBase{
 	@InjectMocks
 	private Problem36 problem;
 	static{
 		description = "Find the sum of all numbers, less than one million, which are palindromic in base 10 and base 2.";
 		result = "The sum of all base 10 and base 2 palindromic numbers < 999999 is 872187";
 	}
+	private List<Integer> palindromes = List.of(1, 3, 5, 7, 9, 33, 99, 313, 585, 717, 7447, 9009, 15351, 32223, 39993, 53235, 53835, 73737, 585585);
+	private int sum = 872187;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getPalindromes(); });
@@ -37,14 +39,23 @@ public class TestProblem36 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(19, problem.getPalindromes().size());
+		assertEquals(palindromes, problem.getPalindromes());
-		assertEquals(872187, problem.getSumOfPalindromes());
+		assertEquals(sum, problem.getSumOfPalindromes());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		problem.palindromes = new ArrayList<>(palindromes);
+		problem.sum = sum;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(new ArrayList<>(), problem.palindromes);
+		assertEquals(0, problem.sum);
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem37.java

@@ -4,31 +4,33 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
+import java.util.ArrayList;
+import java.util.List;
+
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem37 extends ProblemBaseTest{
+public class TestProblem37 extends TestProblemBase{
 	@InjectMocks
 	private Problem37 problem;
 	static{
 		description = "Find the sum of the only eleven primes that are both truncatable from left to right and right to left (2, 3, 5, and 7 are not counted).";
 		result = "The sum of all left and right truncatable primes is 748317";
 	}
+	private List<Long> truncPrimes = List.of(23L, 37L, 53L, 73L, 313L, 317L, 373L, 797L, 3137L, 3797L, 739397L);
+	private long sum = 748317L;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getTruncatablePrimes(); });
@@ -37,14 +39,23 @@ public class TestProblem37 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(11, problem.getTruncatablePrimes().size());
+		assertEquals(truncPrimes, problem.getTruncatablePrimes());
-		assertEquals(748317L, problem.getSumOfPrimes());
+		assertEquals(sum, problem.getSumOfPrimes());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		problem.truncPrimes = new ArrayList<>(truncPrimes);
+		problem.sum = sum;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(new ArrayList<>(), problem.truncPrimes);
+		assertEquals(0L, problem.sum);
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem38.java

@@ -4,31 +4,30 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem38 extends ProblemBaseTest{
+public class TestProblem38 extends TestProblemBase{
 	@InjectMocks
 	private Problem38 problem;
 	static{
 		description = "What is the largest 1-9 pandigital number that can be formed as the concatenated product of an integer with 1, 2, ... n where n > 1";
 		result = "The largest appended product pandigital is 932718654";
 	}
+	private long largestNum = 9327L;
+	private long pandigital = 932718654L;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getLargestNum(); });
@@ -37,14 +36,23 @@ public class TestProblem38 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(9327L, problem.getLargestNum());
+		assertEquals(largestNum, problem.getLargestNum());
-		assertEquals(932718654L, problem.getPandigital());
+		assertEquals(pandigital, problem.getPandigital());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		problem.largestNum = largestNum;
+		problem.pandigital = pandigital;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(0, problem.largestNum);
+		assertEquals(0, problem.pandigital);
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem39.java

@@ -4,9 +4,10 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
+import java.util.ArrayList;
 import java.util.List;
 
-import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
@@ -14,24 +15,29 @@ import com.mattrixwv.Triple;
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem39 extends ProblemBaseTest{
+public class TestProblem39 extends TestProblemBase{
 	@InjectMocks
-	private Problem39Override problem;
+	private Problem39 problem;
 	static{
 		description = "If p is the perimeter of a right triangle for which value of p <= 100 is the number of solutions for the sides {a, b, c} maximized";
 		result = "The perimeter with the largest number of solutions is 90";
 	}
+	private List<Triple<Long, Long, Long>> longestSolutions = List.of(new Triple<>(9L, 40L, 41L), new Triple<>(15L, 36L, 39L));
+
+
+	@BeforeEach
+	public void setup(){
+		Problem39.maxPerimeter = 100;
+	}
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getLongestSolutions(); });
@@ -40,21 +46,21 @@ public class TestProblem39 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(List.of(new Triple<>(9L, 40L, 41L), new Triple<>(15L, 36L, 39L)), problem.getLongestSolutions());
+		assertEquals(longestSolutions, problem.getLongestSolutions());
-		assertEquals(90, problem.getLongestPerimeter());
+		assertEquals(90L, problem.getLongestPerimeter());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		problem.longestSolutions = new ArrayList<>(longestSolutions);
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
 
-
+	@Override
-	public static class Problem39Override extends Problem39{
+	public void verifyReset(){
-		static{
+		assertEquals(new ArrayList<>(), problem.longestSolutions);
-			maxPerimeter = 100;
-		}
 	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem4.java

@@ -4,14 +4,16 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
+import java.util.ArrayList;
+import java.util.List;
+
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem4 extends ProblemBaseTest{
+public class TestProblem4 extends TestProblemBase{
 	@InjectMocks
 	private Problem4 problem;
 	static{
@@ -21,14 +23,12 @@ public class TestProblem4 extends ProblemBaseTest{
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getPalindromes(); });
@@ -42,9 +42,20 @@ public class TestProblem4 extends ProblemBaseTest{
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		//Setup
+		Problem4 p2 = new Problem4();
+		p2.solve();
+		List<Integer> palindromes = p2.getPalindromes();
+		problem.palindromes = palindromes;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(new ArrayList<>(), problem.palindromes);
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem40.java

@@ -4,31 +4,29 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem40 extends ProblemBaseTest{
+public class TestProblem40 extends TestProblemBase{
 	@InjectMocks
 	private Problem40 problem;
 	static{
 		description = "An irrational decimal fraction is created by concatenating the positive integers. Find the value of the following expression: d1 * d10 * d100 * d1000 * d10000 * d100000 * d1000000";
 		result = "The product is 210";
 	}
+	private long product = 210L;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getIrrationalDecimal(); });
@@ -38,13 +36,22 @@ public class TestProblem40 extends ProblemBaseTest{
 
 		//Verify result
 		assertEquals(1000007, problem.getIrrationalDecimal().length());
-		assertEquals(210, problem.getProduct());
+		assertEquals(product, problem.getProduct());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		problem.irrationalDecimal = new StringBuilder("Some random string");
+		problem.product = product;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals("", problem.irrationalDecimal.toString());
+		assertEquals(0, problem.product);
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem41.java

@@ -4,31 +4,29 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem41 extends ProblemBaseTest{
+public class TestProblem41 extends TestProblemBase{
 	@InjectMocks
 	private Problem41 problem;
 	static{
 		description = "What is the largest n-digit pandigital prime?";
 		result = "The largest n-digit pandigital prime is 7652413";
 	}
+	private long largestPrimePandigital = 7652413L;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getLargestPrimePandigital(); });
@@ -36,13 +34,20 @@ public class TestProblem41 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(7652413L, problem.getLargestPrimePandigital());
+		assertEquals(largestPrimePandigital, problem.getLargestPrimePandigital());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		problem.largestPrimePandigital = largestPrimePandigital;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(0, problem.largestPrimePandigital);
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem42.java

@@ -4,14 +4,19 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.security.InvalidParameterException;
+import java.util.ArrayList;
+import java.util.List;
+
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem42 extends ProblemBaseTest{
+public class TestProblem42 extends TestProblemBase{
 	@InjectMocks
 	private Problem42 problem;
 	static{
@@ -21,14 +26,12 @@ public class TestProblem42 extends ProblemBaseTest{
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getTriangularWords(); });
@@ -42,9 +45,43 @@ public class TestProblem42 extends ProblemBaseTest{
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		problem.triangleWords = new ArrayList<>(List.of("1", "2"));
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(new ArrayList<>(), problem.triangleWords);
+	}
+
+	@Test
+	public void testSolve_readError() throws IOException{
+		problem.reset();
+
+		Problem42.fileWords = new ArrayList<>();
+		RandomAccessFile file = new RandomAccessFile(Problem42.FILE_NAME, "rw");
+		file.getChannel().lock();
+
+		assertThrows(InvalidParameterException.class, () -> {
+			problem.solve();
+		});
+
+		file.close();
+	}
+
+	@Test
+	public void testSolve_noFile(){
+		problem.reset();
+
+		Problem42.fileWords = new ArrayList<>();
+		Problem42.FILE_NAME = "/a";
+
+		assertThrows(InvalidParameterException.class, () -> {
+			problem.solve();
+		});
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem43.java

@@ -4,33 +4,40 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
+import java.util.ArrayList;
 import java.util.List;
 
-import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem43 extends ProblemBaseTest{
+public class TestProblem43 extends TestProblemBase{
 	@InjectMocks
-	private Problem43Override problem;
+	private Problem43 problem;
 	static{
 		description = "Find the sum of all 0-9 pandigital numbers with this property";
 		result = "The sum of all pandigitals with the property is 1113342912";
 	}
+	private List<Long> subPrimePandigitals = List.of(140635728L, 146035728L, 410635728L, 416035728L);
+	private long sumSubPrimePandigitals = 1113342912L;
+
+
+	@BeforeEach
+	public void setup(){
+		Problem43.nums = "012345678";
+	}
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getSubPrimePandigitals(); });
@@ -39,21 +46,21 @@ public class TestProblem43 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(List.of(140635728L, 146035728L, 410635728L, 416035728L), problem.getSubPrimePandigitals());
+		assertEquals(subPrimePandigitals, problem.getSubPrimePandigitals());
-		assertEquals(1113342912L, problem.getSumSubPrimePandigitals());
+		assertEquals(sumSubPrimePandigitals, problem.getSumSubPrimePandigitals());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		problem.subPrimePandigitals = new ArrayList<>(subPrimePandigitals);
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
 
-
+	@Override
-	public static class Problem43Override extends Problem43{
+	public void verifyReset(){
-		static{
+		assertEquals(new ArrayList<>(), problem.subPrimePandigitals);
-			nums = "012345678";
-		}
 	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem44.java

@@ -4,31 +4,34 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
+import java.util.ArrayList;
+import java.util.List;
+
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
+import com.mattrixwv.generators.PentagonalNumberGenerator;
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem44 extends ProblemBaseTest{
+public class TestProblem44 extends TestProblemBase{
 	@InjectMocks
 	private Problem44 problem;
 	static{
 		description = "Find 2 pentagonal numbers whos sum and difference are also pentagonal numbers";
 		result = "The difference of the pentagonal numbers is 5482660";
 	}
+	private long pentagonalNumber1 = 1560090L;
+	private long pentagonalNumber2 = 7042750L;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getPentagonalList(); });
@@ -40,15 +43,26 @@ public class TestProblem44 extends ProblemBaseTest{
 
 		//Verify result
 		assertEquals(2167, problem.getPentagonalList().size());
-		assertEquals(1560090L, problem.getPentagonalNumber1());
+		assertEquals(pentagonalNumber1, problem.getPentagonalNumber1());
-		assertEquals(7042750L, problem.getPentagonalNumber2());
+		assertEquals(pentagonalNumber2, problem.getPentagonalNumber2());
-		assertEquals(5482660L, problem.getDifference());
+		assertEquals(pentagonalNumber2 - pentagonalNumber1, problem.getDifference());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		problem.pentagonalList = new ArrayList<>(List.of(1L, 2L, 3L));
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(new PentagonalNumberGenerator().next(), problem.generator.next());
+		problem.generator = new PentagonalNumberGenerator();
+		assertEquals(new ArrayList<>(), problem.pentagonalList);
+		assertEquals(0, problem.pentagonalNumber1);
+		assertEquals(0, problem.pentagonalNumber2);
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem45.java

@@ -4,31 +4,32 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
+import com.mattrixwv.generators.HexagonalNumberGenerator;
+import com.mattrixwv.generators.PentagonalNumberGenerator;
+import com.mattrixwv.generators.TriangularNumberGenerator;
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem45 extends ProblemBaseTest{
+public class TestProblem45 extends TestProblemBase{
 	@InjectMocks
 	private Problem45 problem;
 	static{
 		description = "Find the next triangle number after 40755 that is also pentagonal and hexagonal";
 		result = "The next triangular/pentagonal/hexagonal number is 1533776805";
 	}
+	private long num = 1533776805L;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getNum(); });
@@ -36,13 +37,26 @@ public class TestProblem45 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(1533776805L, problem.getNum());
+		assertEquals(num, problem.getNum());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		problem.num = num;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(0, problem.num);
+		assertEquals(new TriangularNumberGenerator().next(), problem.triGen.next());
+		problem.triGen = new TriangularNumberGenerator();
+		assertEquals(new PentagonalNumberGenerator().next(), problem.penGen.next());
+		problem.penGen = new PentagonalNumberGenerator();
+		assertEquals(new HexagonalNumberGenerator().next(), problem.hexGen.next());
+		problem.hexGen = new HexagonalNumberGenerator();
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem46.java

@@ -4,31 +4,29 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem46 extends ProblemBaseTest{
+public class TestProblem46 extends TestProblemBase{
 	@InjectMocks
 	private Problem46 problem;
 	static{
 		description = "What is the smallest odd composite number that connot be written as the sum of a prime and twice a square?";
 		result = "The smallest odd composite that cannot be written as the sum of a prime and twice a square is 5777";
 	}
+	private long compositeNum = 5777L;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getCompositeNum(); });
@@ -36,13 +34,20 @@ public class TestProblem46 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(5777, problem.getCompositeNum());
+		assertEquals(compositeNum, problem.getCompositeNum());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		problem.num = compositeNum;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(0L, problem.num);
+	}
 }

src/test/java/com/mattrixwv/project_euler/problems/TestProblem47.java

@@ -4,31 +4,29 @@ package com.mattrixwv.project_euler.problems;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
-import org.junit.jupiter.api.Order;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 
 import com.mattrixwv.project_euler.exceptions.Unsolved;
 
 
-public class TestProblem47 extends ProblemBaseTest{
+public class TestProblem47 extends TestProblemBase{
 	@InjectMocks
 	private Problem47 problem;
 	static{
 		description = "What is the first of four consecutive integers to have four distinct prime factors each?";
 		result = "The first number is 134043";
 	}
+	private long firstNum = 134043L;
 
 
 	@Test
-	@Order(1)
 	@Override
 	public void testDescription(){
 		super.testDescription(problem);
 	}
 
 	@Test
-	@Order(2)
 	@Override
 	public void testSolve(){
 		assertThrows(Unsolved.class, () -> { problem.getFirstNum(); });
@@ -36,13 +34,20 @@ public class TestProblem47 extends ProblemBaseTest{
 		super.testSolve(problem);
 
 		//Verify result
-		assertEquals(134043, problem.getFirstNum());
+		assertEquals(firstNum, problem.getFirstNum());
 	}
 
 	@Test
-	@Order(3)
 	@Override
 	public void testReset(){
+		problem.num = firstNum;
+		problem.solved = true;
+
 		super.testReset(problem);
 	}
+
+	@Override
+	public void verifyReset(){
+		assertEquals(0, problem.num);
+	}
 }