Simplify construction logic for palindrome products (#305)

* Simplify construction logic for palindrome products

Fixes issue #283

* Refactor palindrome test comparator into a named function

exercises/palindrome-products/src/example/java/Palindromes.java

@@ -1,77 +1,43 @@
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.SortedMap;
-import java.util.TreeMap;
+import java.util.*;
 
 public class Palindromes {
 
-    public static class PalindromeSortedSetBuilder {
-
-        private int minFactor = 1;
-        private int maxFactor = 1;
-
-        public PalindromeSortedSetBuilder() {
-        }
-
-        public PalindromeSortedSetBuilder withFactorsLessThanOrEqualTo(
-                final int maxFactor) {
-            this.maxFactor = maxFactor;
-            return this;
-        }
-
-        public PalindromeSortedSetBuilder withFactorsGreaterThanOrEqualTo(
-                final int minFactor) {
-            this.minFactor = minFactor;
-            return this;
-        }
-
-        public SortedMap<Long, List<List<Integer>>> build() {
-            SortedMap<Long, List<List<Integer>>> palindromes = new TreeMap<>();
-            long num;
-            List<List<Integer>> factors;
-            for (int i = this.maxFactor; i >= this.minFactor; i--) {
-                for (int j = this.maxFactor; j >= i; j--) {
-                    num = i * j;
-                    if (isPalindrome(num)) {
-                        factors = palindromes.get(num);
-                        if (factors == null) {
-                            factors = new ArrayList<>();
-                        }
-                        factors.add(Arrays.asList(i, j));
-                        palindromes.put(num, factors);
+    public static SortedMap<Long, List<List<Integer>>> getPalindromeProductsWithFactors(int minFactor, int maxFactor) {
+        SortedMap<Long, List<List<Integer>>> palindromeSortedList = new TreeMap<>();
+        long num;
+        List<List<Integer>> factors;
+        for (int i = maxFactor; i >= minFactor; i--) {
+            for (int j = maxFactor; j >= i; j--) {
+                num = i * j;
+                if (isPalindrome(num)) {
+                    factors = palindromeSortedList.get(num);
+                    if (factors == null) {
+                        factors = new ArrayList<>();
                     }
+                    factors.add(Arrays.asList(i, j));
+                    palindromeSortedList.put(num, factors);
                 }
             }
-            return Collections.unmodifiableSortedMap(palindromes);
         }
+        return Collections.unmodifiableSortedMap(palindromeSortedList);
+    }
 
-        // http://stackoverflow.com/questions/23984654/how-to-print-all-palindromes-upto-1000-without-using-any-string-stringbuilder
-        private long reverseNumber(long number) {
-            if (number < 10l) {
-                return number;
-            }
-            long result = 0;
-            long tmp = number;
-            while (tmp > 0) {
-                result = result * 10 + (tmp % 10);
-                tmp /= 10;
-
-            }
-            return result;
+    // http://stackoverflow.com/questions/23984654/how-to-print-all-palindromes-upto-1000-without-using-any-string-stringbuilder
+    private static long reverseNumber(long number) {
+        if (number < 10l) {
+            return number;
         }
+        long result = 0;
+        long tmp = number;
+        while (tmp > 0) {
+            result = result * 10 + (tmp % 10);
+            tmp /= 10;
 
-        private boolean isPalindrome(long number) {
-            return number == reverseNumber(number);
         }
+        return result;
     }
 
-    private Palindromes() {
-    }
-
-    public static PalindromeSortedSetBuilder getPalindromeSortedListBuilder() {
-        return new PalindromeSortedSetBuilder();
+    private static boolean isPalindrome(long number) {
+        return number == reverseNumber(number);
     }
 }

exercises/palindrome-products/src/test/java/PalindromesTest.java

@@ -1,14 +1,13 @@
+import org.junit.Ignore;
+import org.junit.Test;
 
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.SortedMap;
 import java.util.stream.Collectors;
-import static junit.framework.TestCase.assertEquals;
-import static junit.framework.TestCase.assertFalse;
-import static junit.framework.TestCase.assertNotNull;
-import org.junit.Ignore;
-import org.junit.Test;
+
+import static junit.framework.TestCase.*;
 
 public class PalindromesTest {
 
@@ -22,22 +21,9 @@ public class PalindromesTest {
         );
         final long expectedValue = 9l;
 
-        final SortedMap<Long, List<List<Integer>>> palindromes
-                = Palindromes.getPalindromeSortedListBuilder()
-                        .withFactorsLessThanOrEqualTo(9).build();
-
-        assertNotNull(palindromes);
-        assertFalse(palindromes.isEmpty());
-
-        long actualValue = palindromes.lastKey();
-        assertEquals(expectedValue, actualValue);
+        final SortedMap<Long, List<List<Integer>>> palindromes = Palindromes.getPalindromeProductsWithFactors(1, 9);
 
-        List<List<Integer>> actual = palindromes
-                .get(palindromes.lastKey())
-                .stream()
-                .sorted((a, b) -> Integer.compare(a.get(0), b.get(0)))
-                .collect(Collectors.toList());
-        assertEquals(expected, actual);
+        checkPalindromeWithFactorsMatchesExpected(expected, expectedValue, palindromes, palindromes.lastKey());
     }
 
     @Test
@@ -50,24 +36,9 @@ public class PalindromesTest {
         );
         final long expectedValue = 9009l;
 
-        final SortedMap<Long, List<List<Integer>>> palindromes
-                = Palindromes.getPalindromeSortedListBuilder()
-                        .withFactorsLessThanOrEqualTo(99)
-                        .withFactorsGreaterThanOrEqualTo(10)
-                        .build();
-
-        assertNotNull(palindromes);
-        assertFalse(palindromes.isEmpty());
+        final SortedMap<Long, List<List<Integer>>> palindromes = Palindromes.getPalindromeProductsWithFactors(10, 99);
 
-        long actualValue = palindromes.lastKey();
-        assertEquals(expectedValue, actualValue);
-
-        List<List<Integer>> actual = palindromes
-                .get(palindromes.lastKey())
-                .stream()
-                .sorted((a, b) -> Integer.compare(a.get(0), b.get(0)))
-                .collect(Collectors.toList());
-        assertEquals(expected, actual);
+        checkPalindromeWithFactorsMatchesExpected(expected, expectedValue, palindromes, palindromes.lastKey());
     }
 
     @Test
@@ -80,24 +51,9 @@ public class PalindromesTest {
         );
         final long expectedValue = 121l;
 
-        final SortedMap<Long, List<List<Integer>>> palindromes
-                = Palindromes.getPalindromeSortedListBuilder()
-                        .withFactorsLessThanOrEqualTo(99)
-                        .withFactorsGreaterThanOrEqualTo(10)
-                        .build();
-
-        assertNotNull(palindromes);
-        assertFalse(palindromes.isEmpty());
+        final SortedMap<Long, List<List<Integer>>> palindromes = Palindromes.getPalindromeProductsWithFactors(10, 99);
 
-        long actualValue = palindromes.firstKey();
-        assertEquals(expectedValue, actualValue);
-
-        List<List<Integer>> actual = palindromes
-                .get(palindromes.firstKey())
-                .stream()
-                .sorted((a, b) -> Integer.compare(a.get(0), b.get(0)))
-                .collect(Collectors.toList());
-        assertEquals(expected, actual);
+        checkPalindromeWithFactorsMatchesExpected(expected, expectedValue, palindromes, palindromes.firstKey());
     }
 
     @Test
@@ -110,24 +66,9 @@ public class PalindromesTest {
         );
         final long expectedValue = 906609l;
 
-        final SortedMap<Long, List<List<Integer>>> palindromes
-                = Palindromes.getPalindromeSortedListBuilder()
-                        .withFactorsLessThanOrEqualTo(999)
-                        .withFactorsGreaterThanOrEqualTo(100)
-                        .build();
-
-        assertNotNull(palindromes);
-        assertFalse(palindromes.isEmpty());
+        final SortedMap<Long, List<List<Integer>>> palindromes = Palindromes.getPalindromeProductsWithFactors(100, 999);
 
-        long actualValue = palindromes.lastKey();
-        assertEquals(expectedValue, actualValue);
-
-        List<List<Integer>> actual = palindromes
-                .get(palindromes.lastKey())
-                .stream()
-                .sorted((a, b) -> Integer.compare(a.get(0), b.get(0)))
-                .collect(Collectors.toList());
-        assertEquals(expected, actual);
+        checkPalindromeWithFactorsMatchesExpected(expected, expectedValue, palindromes, palindromes.lastKey());
     }
 
     @Test
@@ -140,23 +81,25 @@ public class PalindromesTest {
         );
         final long expectedValue = 10201l;
 
-        final SortedMap<Long, List<List<Integer>>> palindromes
-                = Palindromes.getPalindromeSortedListBuilder()
-                        .withFactorsLessThanOrEqualTo(999)
-                        .withFactorsGreaterThanOrEqualTo(100)
-                        .build();
+        final SortedMap<Long, List<List<Integer>>> palindromes = Palindromes.getPalindromeProductsWithFactors(100, 999);
+
+        checkPalindromeWithFactorsMatchesExpected(expected, expectedValue, palindromes, palindromes.firstKey());
+    }
 
-        assertNotNull(palindromes);
-        assertFalse(palindromes.isEmpty());
+    private void checkPalindromeWithFactorsMatchesExpected(List<List<Integer>> expectedPalindromeFactors,
+                                                           long expectedValueOfPalindrome,
+                                                           SortedMap<Long, List<List<Integer>>> actualPalindromes,
+                                                           long actualValueOfPalindrome) {
+        assertNotNull(actualPalindromes);
+        assertFalse(actualPalindromes.isEmpty());
 
-        long actualValue = palindromes.firstKey();
-        assertEquals(expectedValue, actualValue);
+        assertEquals(expectedValueOfPalindrome, actualValueOfPalindrome);
 
-        List<List<Integer>> actual = palindromes
-                .get(palindromes.firstKey())
+        List<List<Integer>> actualPalindromeFactors = actualPalindromes
+                .get(actualValueOfPalindrome)
                 .stream()
                 .sorted((a, b) -> Integer.compare(a.get(0), b.get(0)))
                 .collect(Collectors.toList());
-        assertEquals(expected, actual);
+        assertEquals(expectedPalindromeFactors, actualPalindromeFactors);
     }
 }