Problems 4-10

Author: blacklp

src/main/java/Problem10.java

@@ -0,0 +1,32 @@
+/**
+ * Title: Summation of primes
+ *
+ * The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.
+ * Find the sum of all the primes below two million.
+ */
+public class Problem10 {
+    public long solve() {
+        long result = 0;
+
+        for (int i = 2; i < 2000000; i++) {
+            if (isPrime(i)) {
+                result += i;
+            }
+        }
+        return result;
+    }
+
+    private boolean isPrime(int num) {
+        for (int i = 2; i <= Math.sqrt(num); i++) {
+            if (num % i == 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static void main(String[] args) {
+        long result = new Problem10().solve();
+        System.out.println("Result: " + result);
+    }
+}

src/main/java/Problem4.java

@@ -0,0 +1,36 @@
+/**
+ * Title: Largest palindrome product
+ *
+ * A palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 × 99.
+ * Find the largest palindrome made from the product of two 3-digit numbers.
+ */
+public class Problem4 {
+    public int solve() {
+        int result = -1;
+
+        for (int num1 = 999; num1 > 99; num1--) {
+            for (int num2 = 999; num2 > 99; num2--) {
+                int product = num1 * num2;
+                if (isPalindromic(product) && product > result) {
+                    result = product;
+                }
+            }
+        }
+        return result;
+    }
+
+    private boolean isPalindromic(int num) {
+        String str = String.valueOf(num);
+        for (int i = 0; i < str.length() / 2; i++) {
+            if (str.charAt(i) != str.charAt(str.length() - 1 - i)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static void main(String[] args) {
+        int result = new Problem4().solve();
+        System.out.println("Result: " + result);
+    }
+}

src/main/java/Problem5.java

@@ -0,0 +1,50 @@
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Title: Smallest multiple
+ *
+ * 2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder.
+ * What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20?
+ */
+public class Problem5 {
+    public int solve() {
+        Map<Integer, Integer> factors = new HashMap<>();
+
+        for (int i = 2; i <= 20; i++) {
+            Map<Integer, Integer> factorsForNum = getFactors(i);
+            for (Map.Entry<Integer, Integer> entry : factorsForNum.entrySet()) {
+                Integer oldExponent = factors.get(entry.getKey());
+                if (oldExponent == null || entry.getValue() > oldExponent) {
+                    factors.put(entry.getKey(), entry.getValue());
+                }
+            }
+        }
+        int result = 1;
+        for (Map.Entry<Integer, Integer> entry : factors.entrySet()) {
+            result *= Math.pow(entry.getKey(), entry.getValue());
+        }
+        return result;
+    }
+
+    private Map<Integer, Integer> getFactors(int num) {
+        int copy = num;
+        Map<Integer, Integer> result = new HashMap<>();
+        int[] primeNumbers = new int[]{2, 3, 5, 7, 11, 13, 17, 19};
+
+        for (int i : primeNumbers) {
+            if (copy % i == 0) {
+                int exponent = (int)(Math.log(copy) / Math.log(i));
+                result.put(i, exponent);
+            }
+        }
+        return result;
+    }
+
+    public static void main(String[] args) {
+        // 1 2 3 4 5 6 7 8 9 10 -> 2,3,2^2,5,2*3,7,2^3,3^2,2*5
+        // 2^3,3^2,5,7 -> 8*9*5*7 = 2520
+        int result = new Problem5().solve();
+        System.out.println("Result: " + result);
+    }
+}

src/main/java/Problem6.java

@@ -0,0 +1,27 @@
+/**
+ * Title: Sum square difference
+ *
+ * The sum of the squares of the first ten natural numbers is,
+ * 1^2 + 2^2 + ... + 10^2 = 385
+ * The square of the sum of the first ten natural numbers is,
+ * (1 + 2 + ... + 10)^2 = 552 = 3025
+ * Hence the difference between the sum of the squares of the first ten natural numbers and the square of the sum is 3025 − 385 = 2640.
+ * Find the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum.
+ */
+public class Problem6 {
+    public int solve() {
+        int sum = 0;
+        int squareSum = 0;
+
+        for (int i = 1; i <= 100; i++) {
+            sum += i;
+            squareSum += i*i;
+        }
+        return sum * sum - squareSum;
+    }
+
+    public static void main(String[] args) {
+        int result = new Problem6().solve();
+        System.out.println("Result: " + result);
+    }
+}

src/main/java/Problem7.java

@@ -0,0 +1,33 @@
+/**
+ * Title: 10001st prime
+ *
+ * By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13.
+ * What is the 10001st prime number?
+ */
+public class Problem7 {
+    public int solve() {
+        int primeCount = 0;
+        int current = 1;
+        while (primeCount < 10001) {
+            current++;
+            if (isPrime(current)) {
+                primeCount++;
+            }
+        }
+        return current;
+    }
+
+    private boolean isPrime(int num) {
+        for (int i = 2; i <= Math.sqrt(num); i++) {
+            if (num % i == 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static void main(String[] args) {
+        int result = new Problem7().solve();
+        System.out.println("Result: " + result);
+    }
+}

src/main/java/Problem8.java

@@ -0,0 +1,74 @@
+/**
+ * Title: Largest product in a series
+ *
+ * The four adjacent digits in the 1000-digit number that have the greatest product are 9 × 9 × 8 × 9 = 5832.
+ * 73167176531330624919225119674426574742355349194934
+ * 96983520312774506326239578318016984801869478851843
+ * 85861560789112949495459501737958331952853208805511
+ * 12540698747158523863050715693290963295227443043557
+ * 66896648950445244523161731856403098711121722383113
+ * 62229893423380308135336276614282806444486645238749
+ * 30358907296290491560440772390713810515859307960866
+ * 70172427121883998797908792274921901699720888093776
+ * 65727333001053367881220235421809751254540594752243
+ * 52584907711670556013604839586446706324415722155397
+ * 53697817977846174064955149290862569321978468622482
+ * 83972241375657056057490261407972968652414535100474
+ * 82166370484403199890008895243450658541227588666881
+ * 16427171479924442928230863465674813919123162824586
+ * 17866458359124566529476545682848912883142607690042
+ * 24219022671055626321111109370544217506941658960408
+ * 07198403850962455444362981230987879927244284909188
+ * 84580156166097919133875499200524063689912560717606
+ * 05886116467109405077541002256983155200055935729725
+ * 71636269561882670428252483600823257530420752963450
+ * Find the thirteen adjacent digits in the 1000-digit number that have the greatest product. What is the value of this product?
+ */
+public class Problem8 {
+    final String input =
+        "73167176531330624919225119674426574742355349194934"+
+        "96983520312774506326239578318016984801869478851843"+
+        "85861560789112949495459501737958331952853208805511"+
+        "12540698747158523863050715693290963295227443043557"+
+        "66896648950445244523161731856403098711121722383113"+
+        "62229893423380308135336276614282806444486645238749"+
+        "30358907296290491560440772390713810515859307960866"+
+        "70172427121883998797908792274921901699720888093776"+
+        "65727333001053367881220235421809751254540594752243"+
+        "52584907711670556013604839586446706324415722155397"+
+        "53697817977846174064955149290862569321978468622482"+
+        "83972241375657056057490261407972968652414535100474"+
+        "82166370484403199890008895243450658541227588666881"+
+        "16427171479924442928230863465674813919123162824586"+
+        "17866458359124566529476545682848912883142607690042"+
+        "24219022671055626321111109370544217506941658960408"+
+        "07198403850962455444362981230987879927244284909188"+
+        "84580156166097919133875499200524063689912560717606"+
+        "05886116467109405077541002256983155200055935729725"+
+        "71636269561882670428252483600823257530420752963450";
+
+    public long solve() {
+        long result = 0;
+        char[] chars = input.toCharArray();
+        for (int i = 0; i < chars.length  - 13; i++) {
+            long product = calculate13Product(i, chars);
+            if (product > result) {
+                result = product;
+            }
+        }
+        return result;
+    }
+
+    private long calculate13Product(int startPosition, char[] arr) {
+        long result = 1;
+        for (int i = startPosition; i < startPosition + 13; i++) {
+            result *= arr[i] - '0'; // char to int
+        }
+        return result;
+    }
+
+    public static void main(String[] args) {
+        long result = new Problem8().solve();
+        System.out.println("Result: " + result);
+    }
+}

src/main/java/Problem9.java

@@ -0,0 +1,30 @@
+/**
+ * Title: Special Pythagorean triplet
+ *
+ * A Pythagorean triplet is a set of three natural numbers, a < b < c, for which,
+ * a^2 + b^2 = c^2
+ * For example, 3^2 + 4^2 = 9 + 16 = 25 = 5^2.
+ * There exists exactly one Pythagorean triplet for which a + b + c = 1000.
+ * Find the product abc.
+ */
+public class Problem9 {
+    public int solve() {
+
+        for (int a = 1; a < 1000; a++) {
+            for (int b = a + 1; b < 1000; b++) {
+                int cSquare = a*a + b*b;
+                double c = Math.sqrt(cSquare);
+
+                if (c - (int)c == 0 && a+b+c == 1000) {
+                    return a*b*(int)c;
+                }
+            }
+        }
+        return -1;
+    }
+
+    public static void main(String[] args) {
+        int result = new Problem9().solve();
+        System.out.println("Result: " + result);
+    }
+}

src/test/java/Problem10Test.java

@@ -0,0 +1,10 @@
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+
+public class Problem10Test {
+    @Test
+    public void checkValidValue() {
+        long result = new Problem10().solve();
+        Assertions.assertThat(result).isEqualTo(142913828922L);
+    }
+}

src/test/java/Problem4Test.java

@@ -0,0 +1,10 @@
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+
+public class Problem4Test {
+    @Test
+    public void checkValidValue() {
+        int result = new Problem4().solve();
+        Assertions.assertThat(result).isEqualTo(906609);
+    }
+}

src/test/java/Problem5Test.java

@@ -0,0 +1,10 @@
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+
+public class Problem5Test {
+    @Test
+    public void checkValidValue() {
+        int result = new Problem5().solve();
+        Assertions.assertThat(result).isEqualTo(232792560);
+    }
+}