diff --git a/src/main/java/com/mattrixwv/project_euler/problems/Problem35.java b/src/main/java/com/mattrixwv/project_euler/problems/Problem35.java index 46a5cb8..caad57e 100644 --- a/src/main/java/com/mattrixwv/project_euler/problems/Problem35.java +++ b/src/main/java/com/mattrixwv/project_euler/problems/Problem35.java @@ -32,7 +32,7 @@ import com.mattrixwv.NumberAlgorithms; public class Problem35 extends Problem{ //Variables //Static variables - private static final int MAX_NUM = 999999; //The largest number that we are checking for primes + protected static int maxNum = 999999; //The largest number that we are checking for primes //Instance variables private List primes; //The primes below MAX_NUM private ArrayList circularPrimes; //The circular primes below MAX_NUM @@ -49,7 +49,7 @@ public class Problem35 extends Problem{ } //Constructor public Problem35(){ - super("How many circular primes are there below one million?"); + super(String.format("How many circular primes are there below %d?", maxNum + 1)); primes = new ArrayList<>(); circularPrimes = new ArrayList<>(); } @@ -66,7 +66,7 @@ public class Problem35 extends Problem{ //Get all primes under 1,000,000 - primes = NumberAlgorithms.getPrimes(MAX_NUM); + primes = NumberAlgorithms.getPrimes(maxNum); //Go through all primes, get all their rotations, and check if those numbers are also primes for(int prime : primes){ boolean allRotationsPrime = true; @@ -103,7 +103,7 @@ public class Problem35 extends Problem{ //Returns a string with the solution to the problem public String getResult(){ solvedCheck("result"); - return String.format("The number of all circular prime numbers under %d is %d", MAX_NUM, circularPrimes.size()); + return String.format("The number of all circular prime numbers under %d is %d", maxNum, circularPrimes.size()); } //Returns the ArrayList of primes < MAX_NUM public List getPrimes(){ diff --git a/src/main/java/com/mattrixwv/project_euler/problems/Problem39.java b/src/main/java/com/mattrixwv/project_euler/problems/Problem39.java index b4ee5f8..6226448 100644 --- a/src/main/java/com/mattrixwv/project_euler/problems/Problem39.java +++ b/src/main/java/com/mattrixwv/project_euler/problems/Problem39.java @@ -32,14 +32,14 @@ import com.mattrixwv.Triple; public class Problem39 extends Problem{ //Variables //Static variables - private static final long MAX_PERIMETER = 1000; + protected static long maxPerimeter = 1000; //Instace variables private ArrayList> longestSolutions; //Functions //Constructor public Problem39(){ - super("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"); + super(String.format("If p is the perimeter of a right triangle for which value of p <= %d is the number of solutions for the sides {a, b, c} maximized", maxPerimeter)); longestSolutions = new ArrayList<>(); } //Operational functions @@ -58,7 +58,7 @@ public class Problem39 extends Problem{ //Loop for perimeter <= 1000 - for(long perimeter = 1;perimeter <= MAX_PERIMETER;++perimeter){ + for(long perimeter = 1;perimeter <= maxPerimeter;++perimeter){ ArrayList> solutions = new ArrayList<>(); for(long a = 1;(a * 3) <= perimeter;++a){ for(long b = a;(a + b + b) <= perimeter;++b){ diff --git a/src/main/java/com/mattrixwv/project_euler/problems/Problem40.java b/src/main/java/com/mattrixwv/project_euler/problems/Problem40.java index 569750f..1ee41c3 100644 --- a/src/main/java/com/mattrixwv/project_euler/problems/Problem40.java +++ b/src/main/java/com/mattrixwv/project_euler/problems/Problem40.java @@ -92,7 +92,7 @@ public class Problem40 extends Problem{ return String.format("The product is %d", product); } //Returns the string of the decimal - public String irrationalDecimal(){ + public String getIrrationalDecimal(){ solvedCheck("decimal string"); return "0." + irrationalDecimal.toString(); } diff --git a/src/test/java/com/mattrixwv/project_euler/problems/BaseTest.java b/src/test/java/com/mattrixwv/project_euler/problems/BaseTest.java index 4b826dc..247f68c 100644 --- a/src/test/java/com/mattrixwv/project_euler/problems/BaseTest.java +++ b/src/test/java/com/mattrixwv/project_euler/problems/BaseTest.java @@ -37,7 +37,6 @@ public abstract class BaseTest{ } public abstract void testSolve(); - public void testSolve(Problem problem){ //Verify the results cannot be seen until the problem has been run assertThrows(Unsolved.class, () -> { problem.getResult(); }); diff --git a/src/test/java/com/mattrixwv/project_euler/problems/TestProblem31.java b/src/test/java/com/mattrixwv/project_euler/problems/TestProblem31.java new file mode 100644 index 0000000..8e5925b --- /dev/null +++ b/src/test/java/com/mattrixwv/project_euler/problems/TestProblem31.java @@ -0,0 +1,48 @@ +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 BaseTest{ + @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"; + } + + + @Test + @Order(1) + @Override + public void testDescription(){ + super.testDescription(problem); + } + + @Test + @Order(2) + @Override + public void testSolve(){ + assertThrows(Unsolved.class, () -> { problem.getPermutations(); }); + + super.testSolve(problem); + + //Verify result + assertEquals(73682, problem.getPermutations()); + } + + @Test + @Order(3) + @Override + public void testReset(){ + super.testReset(problem); + } +} diff --git a/src/test/java/com/mattrixwv/project_euler/problems/TestProblem32.java b/src/test/java/com/mattrixwv/project_euler/problems/TestProblem32.java new file mode 100644 index 0000000..ffea88a --- /dev/null +++ b/src/test/java/com/mattrixwv/project_euler/problems/TestProblem32.java @@ -0,0 +1,48 @@ +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 TestProblem32 extends BaseTest{ + @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"); + } + + + @Test + @Order(1) + @Override + public void testDescription(){ + super.testDescription(problem); + } + + @Test + @Order(2) + @Override + public void testSolve(){ + assertThrows(Unsolved.class, () -> { problem.getSumOfPandigitals(); }); + + super.testSolve(problem); + + //Verify result + assertEquals(45228, problem.getSumOfPandigitals()); + } + + @Test + @Order(3) + @Override + public void testReset(){ + super.testReset(problem); + } +} diff --git a/src/test/java/com/mattrixwv/project_euler/problems/TestProblem33.java b/src/test/java/com/mattrixwv/project_euler/problems/TestProblem33.java new file mode 100644 index 0000000..76cd77a --- /dev/null +++ b/src/test/java/com/mattrixwv/project_euler/problems/TestProblem33.java @@ -0,0 +1,54 @@ +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.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 BaseTest{ + @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"; + } + + + @Test + @Order(1) + @Override + public void testDescription(){ + super.testDescription(problem); + } + + @Test + @Order(2) + @Override + public void testSolve(){ + assertThrows(Unsolved.class, () -> { problem.getNumerators(); }); + assertThrows(Unsolved.class, () -> { problem.getDenominators(); }); + assertThrows(Unsolved.class, () -> { problem.getProdDenominator(); }); + + super.testSolve(problem); + + //Verify result + assertEquals(List.of(16, 26, 19, 49), problem.getNumerators()); + assertEquals(List.of(64, 65, 95, 98), problem.getDenominators()); + assertEquals(100, problem.getProdDenominator()); + } + + @Test + @Order(3) + @Override + public void testReset(){ + super.testReset(problem); + } +} diff --git a/src/test/java/com/mattrixwv/project_euler/problems/TestProblem34.java b/src/test/java/com/mattrixwv/project_euler/problems/TestProblem34.java new file mode 100644 index 0000000..07ab8b4 --- /dev/null +++ b/src/test/java/com/mattrixwv/project_euler/problems/TestProblem34.java @@ -0,0 +1,52 @@ +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.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 BaseTest{ + @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"; + } + + + @Test + @Order(1) + @Override + public void testDescription(){ + super.testDescription(problem); + } + + @Test + @Order(2) + @Override + public void testSolve(){ + assertThrows(Unsolved.class, () -> { problem.getFactorials(); }); + assertThrows(Unsolved.class, () -> { problem.getSum(); }); + + super.testSolve(problem); + + //Verify result + assertEquals(List.of(1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880), problem.getFactorials()); + assertEquals(40730, problem.getSum()); + } + + @Test + @Order(3) + @Override + public void testReset(){ + super.testReset(problem); + } +} diff --git a/src/test/java/com/mattrixwv/project_euler/problems/TestProblem35.java b/src/test/java/com/mattrixwv/project_euler/problems/TestProblem35.java new file mode 100644 index 0000000..d4ed75d --- /dev/null +++ b/src/test/java/com/mattrixwv/project_euler/problems/TestProblem35.java @@ -0,0 +1,59 @@ +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 TestProblem35 extends BaseTest{ + @InjectMocks + private Problem35Override problem; + static{ + description = "How many circular primes are there below 10000?"; + result = "The number of all circular prime numbers under 9999 is 33"; + } + + + @Test + @Order(1) + @Override + public void testDescription(){ + super.testDescription(problem); + } + + @Test + @Order(2) + @Override + public void testSolve(){ + assertThrows(Unsolved.class, () -> { problem.getPrimes(); }); + assertThrows(Unsolved.class, () -> { problem.getCircularPrimes(); }); + assertThrows(Unsolved.class, () -> { problem.getNumCircularPrimes(); }); + + super.testSolve(problem); + + //Verify result + assertEquals(1229, problem.getPrimes().size()); + assertEquals(33, problem.getCircularPrimes().size()); + assertEquals(33, problem.getNumCircularPrimes()); + } + + @Test + @Order(3) + @Override + public void testReset(){ + super.testReset(problem); + } + + + public static class Problem35Override extends Problem35{ + static{ + maxNum = 9999; + } + } +} diff --git a/src/test/java/com/mattrixwv/project_euler/problems/TestProblem36.java b/src/test/java/com/mattrixwv/project_euler/problems/TestProblem36.java new file mode 100644 index 0000000..4d95c61 --- /dev/null +++ b/src/test/java/com/mattrixwv/project_euler/problems/TestProblem36.java @@ -0,0 +1,50 @@ +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 TestProblem36 extends BaseTest{ + @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"; + } + + + @Test + @Order(1) + @Override + public void testDescription(){ + super.testDescription(problem); + } + + @Test + @Order(2) + @Override + public void testSolve(){ + assertThrows(Unsolved.class, () -> { problem.getPalindromes(); }); + assertThrows(Unsolved.class, () -> { problem.getSumOfPalindromes(); }); + + super.testSolve(problem); + + //Verify result + assertEquals(19, problem.getPalindromes().size()); + assertEquals(872187, problem.getSumOfPalindromes()); + } + + @Test + @Order(3) + @Override + public void testReset(){ + super.testReset(problem); + } +} diff --git a/src/test/java/com/mattrixwv/project_euler/problems/TestProblem37.java b/src/test/java/com/mattrixwv/project_euler/problems/TestProblem37.java new file mode 100644 index 0000000..034b792 --- /dev/null +++ b/src/test/java/com/mattrixwv/project_euler/problems/TestProblem37.java @@ -0,0 +1,50 @@ +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 TestProblem37 extends BaseTest{ + @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"; + } + + + @Test + @Order(1) + @Override + public void testDescription(){ + super.testDescription(problem); + } + + @Test + @Order(2) + @Override + public void testSolve(){ + assertThrows(Unsolved.class, () -> { problem.getTruncatablePrimes(); }); + assertThrows(Unsolved.class, () -> { problem.getSumOfPrimes(); }); + + super.testSolve(problem); + + //Verify result + assertEquals(11, problem.getTruncatablePrimes().size()); + assertEquals(748317L, problem.getSumOfPrimes()); + } + + @Test + @Order(3) + @Override + public void testReset(){ + super.testReset(problem); + } +} diff --git a/src/test/java/com/mattrixwv/project_euler/problems/TestProblem38.java b/src/test/java/com/mattrixwv/project_euler/problems/TestProblem38.java new file mode 100644 index 0000000..d48a14a --- /dev/null +++ b/src/test/java/com/mattrixwv/project_euler/problems/TestProblem38.java @@ -0,0 +1,50 @@ +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 BaseTest{ + @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"; + } + + + @Test + @Order(1) + @Override + public void testDescription(){ + super.testDescription(problem); + } + + @Test + @Order(2) + @Override + public void testSolve(){ + assertThrows(Unsolved.class, () -> { problem.getLargestNum(); }); + assertThrows(Unsolved.class, () -> { problem.getPandigital(); }); + + super.testSolve(problem); + + //Verify result + assertEquals(9327L, problem.getLargestNum()); + assertEquals(932718654L, problem.getPandigital()); + } + + @Test + @Order(3) + @Override + public void testReset(){ + super.testReset(problem); + } +} diff --git a/src/test/java/com/mattrixwv/project_euler/problems/TestProblem39.java b/src/test/java/com/mattrixwv/project_euler/problems/TestProblem39.java new file mode 100644 index 0000000..5de0ba8 --- /dev/null +++ b/src/test/java/com/mattrixwv/project_euler/problems/TestProblem39.java @@ -0,0 +1,60 @@ +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.List; + +import org.junit.jupiter.api.Order; +import org.junit.jupiter.api.Test; +import org.mockito.InjectMocks; + +import com.mattrixwv.Triple; +import com.mattrixwv.project_euler.exceptions.Unsolved; + + +public class TestProblem39 extends BaseTest{ + @InjectMocks + private Problem39Override 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"; + } + + + @Test + @Order(1) + @Override + public void testDescription(){ + super.testDescription(problem); + } + + @Test + @Order(2) + @Override + public void testSolve(){ + assertThrows(Unsolved.class, () -> { problem.getLongestSolutions(); }); + assertThrows(Unsolved.class, () -> { problem.getLongestPerimeter(); }); + + super.testSolve(problem); + + //Verify result + assertEquals(List.of(new Triple<>(9L, 40L, 41L), new Triple<>(15L, 36L, 39L)), problem.getLongestSolutions()); + assertEquals(90, problem.getLongestPerimeter()); + } + + @Test + @Order(3) + @Override + public void testReset(){ + super.testReset(problem); + } + + + public static class Problem39Override extends Problem39{ + static{ + maxPerimeter = 100; + } + } +} diff --git a/src/test/java/com/mattrixwv/project_euler/problems/TestProblem40.java b/src/test/java/com/mattrixwv/project_euler/problems/TestProblem40.java new file mode 100644 index 0000000..86bd04c --- /dev/null +++ b/src/test/java/com/mattrixwv/project_euler/problems/TestProblem40.java @@ -0,0 +1,50 @@ +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 BaseTest{ + @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"; + } + + + @Test + @Order(1) + @Override + public void testDescription(){ + super.testDescription(problem); + } + + @Test + @Order(2) + @Override + public void testSolve(){ + assertThrows(Unsolved.class, () -> { problem.getIrrationalDecimal(); }); + assertThrows(Unsolved.class, () -> { problem.getProduct(); }); + + super.testSolve(problem); + + //Verify result + assertEquals(1000007, problem.getIrrationalDecimal().length()); + assertEquals(210, problem.getProduct()); + } + + @Test + @Order(3) + @Override + public void testReset(){ + super.testReset(problem); + } +}