Added palindrome-products exercise to the Java track (#205)

* Added palindrome-products exercise to the Java track

* Added @Ignore annotations to tests

config.json

@@ -54,7 +54,8 @@
     "pythagorean-triplet",
     "binary-search-tree",
     "binary-search",
-    "all-your-base"
+    "all-your-base",
+    "palindrome-products"
   ],
   "exercises": [
     {
@@ -311,6 +312,11 @@
       "slug": "all-your-base",
       "difficulty": 1,
       "topics": []
+    },
+    {
+      "slug": "palindrome-products",
+      "difficulty": 1,
+      "topics": []
     }
   ],
   "deprecated": [

exercises/palindrome-products/build.gradle

@@ -0,0 +1,18 @@
+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    testCompile "junit:junit:4.12"
+}
+
+test {
+    testLogging {
+        exceptionFormat = 'full'
+        events = ["passed", "failed", "skipped"]
+    }
+}

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

@@ -0,0 +1,77 @@
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.SortedMap;
+import java.util.TreeMap;
+
+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);
+                    }
+                }
+            }
+            return Collections.unmodifiableSortedMap(palindromes);
+        }
+
+        // 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;
+        }
+
+        private boolean isPalindrome(long number) {
+            return number == reverseNumber(number);
+        }
+    }
+
+    private Palindromes() {
+    }
+
+    public static PalindromeSortedSetBuilder getPalindromeSortedListBuilder() {
+        return new PalindromeSortedSetBuilder();
+    }
+}

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

@@ -0,0 +1,162 @@
+
+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;
+
+public class PalindromesTest {
+
+    @Test
+    public void largestPalindromeFromSingleDigitFactors() {
+        final List<List<Integer>> expected = Collections.unmodifiableList(
+                Arrays.asList(
+                        Arrays.asList(1, 9),
+                        Arrays.asList(3, 3)
+                )
+        );
+        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);
+
+        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);
+    }
+
+    @Test
+    @Ignore
+    public void largestPalindromeFromDoubleDigitFactors() {
+        final List<List<Integer>> expected = Collections.unmodifiableList(
+                Arrays.asList(
+                        Arrays.asList(91, 99)
+                )
+        );
+        final long expectedValue = 9009l;
+
+        final SortedMap<Long, List<List<Integer>>> palindromes
+                = Palindromes.getPalindromeSortedListBuilder()
+                        .withFactorsLessThanOrEqualTo(99)
+                        .withFactorsGreaterThanOrEqualTo(10)
+                        .build();
+
+        assertNotNull(palindromes);
+        assertFalse(palindromes.isEmpty());
+
+        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);
+    }
+
+    @Test
+    @Ignore
+    public void smallestPalindromeFromDoubleDigitFactors() {
+        final List<List<Integer>> expected = Collections.unmodifiableList(
+                Arrays.asList(
+                        Arrays.asList(11, 11)
+                )
+        );
+        final long expectedValue = 121l;
+
+        final SortedMap<Long, List<List<Integer>>> palindromes
+                = Palindromes.getPalindromeSortedListBuilder()
+                        .withFactorsLessThanOrEqualTo(99)
+                        .withFactorsGreaterThanOrEqualTo(10)
+                        .build();
+
+        assertNotNull(palindromes);
+        assertFalse(palindromes.isEmpty());
+
+        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);
+    }
+
+    @Test
+    @Ignore
+    public void largestPalindromeFromTripleDigitFactors() {
+        final List<List<Integer>> expected = Collections.unmodifiableList(
+                Arrays.asList(
+                        Arrays.asList(913, 993)
+                )
+        );
+        final long expectedValue = 906609l;
+
+        final SortedMap<Long, List<List<Integer>>> palindromes
+                = Palindromes.getPalindromeSortedListBuilder()
+                        .withFactorsLessThanOrEqualTo(999)
+                        .withFactorsGreaterThanOrEqualTo(100)
+                        .build();
+
+        assertNotNull(palindromes);
+        assertFalse(palindromes.isEmpty());
+
+        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);
+    }
+
+    @Test
+    @Ignore
+    public void smallestPalindromeFromTripleDigitFactors() {
+        final List<List<Integer>> expected = Collections.unmodifiableList(
+                Arrays.asList(
+                        Arrays.asList(101, 101)
+                )
+        );
+        final long expectedValue = 10201l;
+
+        final SortedMap<Long, List<List<Integer>>> palindromes
+                = Palindromes.getPalindromeSortedListBuilder()
+                        .withFactorsLessThanOrEqualTo(999)
+                        .withFactorsGreaterThanOrEqualTo(100)
+                        .build();
+
+        assertNotNull(palindromes);
+        assertFalse(palindromes.isEmpty());
+
+        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);
+    }
+}

exercises/settings.gradle

@@ -25,6 +25,7 @@ include 'meetup'
 include 'nth-prime'
 include 'nucleotide-count'
 include 'octal'
+include 'palindrome-products'
 include 'pangram'
 include 'pascals-triangle'
 include 'phone-number'