trackler 2.0.5.1 → 2.0.5.2

data/tracks/java/exercises/nth-prime/build.gradle

@@ -8,7 +8,6 @@ repositories {
 
 dependencies {
   testCompile "junit:junit:4.12"
-  testCompile "org.assertj:assertj-core:3.2.0"
 }
 test {
   testLogging {

data/tracks/java/exercises/nth-prime/src/test/java/PrimeTest.java

@@ -1,31 +1,32 @@
 import org.junit.Test;
 import org.junit.Ignore;
 
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.Assert.*;
 
 public class PrimeTest {
 
     @Test
     public void testFirstPrime() {
-        assertThat(Prime.nth(1)).isEqualTo(2);
+        assertThat(Prime.nth(1), is(2));
     }
 
     @Ignore
     @Test
     public void testSecondPrime() {
-        assertThat(Prime.nth(2)).isEqualTo(3);
+        assertThat(Prime.nth(2), is(3));
     }
 
     @Ignore
     @Test
     public void testSixthPrime() {
-        assertThat(Prime.nth(6)).isEqualTo(13);
+        assertThat(Prime.nth(6), is(13));
     }
 
     @Ignore
     @Test
     public void testBigPrime() {
-        assertThat(Prime.nth(10001)).isEqualTo(104743);
+        assertThat(Prime.nth(10001), is(104743));
     }
 
     @Ignore

data/tracks/java/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"]
+    }
+}

data/tracks/java/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();
+    }
+}

data/tracks/java/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);
+    }
+}

data/tracks/java/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'
@@ -48,3 +49,4 @@ include 'strain'
 include 'triangle'
 include 'trinary'
 include 'word-count'
+include 'wordy'

data/tracks/java/exercises/sum-of-multiples/src/example/java/SumOfMultiples.java

@@ -1,8 +1,7 @@
-import java.util.Arrays;
 public class SumOfMultiples {
     
     
-    public int Sum(int number, int[] set) {
+    public static int sum(int number, int[] set) {
         
         int sum = 0;
         int count = 0;

data/tracks/java/exercises/sum-of-multiples/src/main/java/SumOfMultiples.java

@@ -1,4 +1,3 @@
-import java.util.Arrays;
 public class SumOfMultiples {
     
 }

data/tracks/java/exercises/sum-of-multiples/src/test/{SumOfMultiplesTest.java → java/SumOfMultiplesTest.java}

@@ -9,12 +9,11 @@ public class SumOfMultiplesTest {
     @Test
     public void testSumOfMultiplesOf3and4UpToOne() {
         
-        SumOfMultiples mySum = new SumOfMultiples();
         int[] set = {
             3,
             5
         };
-        int output = mySum.Sum(1, set);
+        int output = SumOfMultiples.sum(1, set);
         assertEquals(0, output);
         
     }
@@ -24,12 +23,11 @@ public class SumOfMultiplesTest {
     @Ignore
     public void testSumOfMultiplesOf3and5UpToFour() {
         
-        SumOfMultiples mySum = new SumOfMultiples();
         int[] set = {
             3,
             5
         };
-        int output = mySum.Sum(4, set);
+        int output = SumOfMultiples.sum(4, set);
         assertEquals(3, output);
         
     }
@@ -39,12 +37,11 @@ public class SumOfMultiplesTest {
     @Ignore
     public void testSumOfMultiplesOf3and5UpToTen() {
         
-        SumOfMultiples mySum = new SumOfMultiples();
         int[] set = {
             3,
             5
         };
-        int output = mySum.Sum(10, set);
+        int output = SumOfMultiples.sum(10, set);
         assertEquals(23, output);
         
     }
@@ -54,12 +51,11 @@ public class SumOfMultiplesTest {
     @Ignore
     public void testSumOfMultiplesOf3and5UpToOneHundred() {
         
-        SumOfMultiples mySum = new SumOfMultiples();
         int[] set = {
             3,
             5
         };
-        int output = mySum.Sum(100, set);
+        int output = SumOfMultiples.sum(100, set);
         assertEquals(2318, output);
         
     }
@@ -69,12 +65,11 @@ public class SumOfMultiplesTest {
     @Ignore
     public void testSumOfMultiplesOf3and5UpToOneThousand() {
         
-        SumOfMultiples mySum = new SumOfMultiples();
         int[] set = {
             3,
             5
         };
-        int output = mySum.Sum(1000, set);
+        int output = SumOfMultiples.sum(1000, set);
         assertEquals(233168, output);
         
     }
@@ -84,13 +79,12 @@ public class SumOfMultiplesTest {
     @Ignore
     public void testSumOfMultiplesOf7and13and17UpToTwenty() {
         
-        SumOfMultiples mySum = new SumOfMultiples();
         int[] set = {
             7,
             13,
             17
         };
-        int output = mySum.Sum(20, set);
+        int output = SumOfMultiples.sum(20, set);
         assertEquals(51, output);
         
     }
@@ -100,12 +94,11 @@ public class SumOfMultiplesTest {
     @Ignore
     public void testSumOfMultiplesOf4and6UpToFifteen() {
         
-        SumOfMultiples mySum = new SumOfMultiples();
         int[] set = {
             4,
             6
         };
-        int output = mySum.Sum(15, set);
+        int output = SumOfMultiples.sum(15, set);
         assertEquals(30, output);
         
     }
@@ -115,13 +108,12 @@ public class SumOfMultiplesTest {
     @Ignore
     public void testSumOfMultiplesOf5and6and8UpToOneHundredFifty() {
         
-        SumOfMultiples mySum = new SumOfMultiples();
         int[] set = {
             5,
             6,
             8
         };
-        int output = mySum.Sum(150, set);
+        int output = SumOfMultiples.sum(150, set);
         assertEquals(4419, output);
         
     }
@@ -131,12 +123,11 @@ public class SumOfMultiplesTest {
     @Ignore
     public void testSumOfMultiplesOf5and25UpToTwoHundredSeventyFive() {
         
-        SumOfMultiples mySum = new SumOfMultiples();
         int[] set = {
             5,
             25
         };
-        int output = mySum.Sum(51, set);
+        int output = SumOfMultiples.sum(51, set);
         assertEquals(275, output);
         
     }
@@ -146,12 +137,11 @@ public class SumOfMultiplesTest {
     @Ignore
     public void testSumOfMultiplesOf43and47UpToTenThousand() {
         
-        SumOfMultiples mySum = new SumOfMultiples();
         int[] set = {
             43,
             47
         };
-        int output = mySum.Sum(10000, set);
+        int output = SumOfMultiples.sum(10000, set);
         assertEquals(2203160, output);
         
     }
@@ -161,11 +151,10 @@ public class SumOfMultiplesTest {
     @Ignore
     public void testSumOfMultiplesOfOneUpToOneHundred() {
         
-        SumOfMultiples mySum = new SumOfMultiples();
         int[] set = {
             1
         };
-        int output = mySum.Sum(100, set);
+        int output = SumOfMultiples.sum(100, set);
         assertEquals(4950, output);
         
     }
@@ -175,9 +164,8 @@ public class SumOfMultiplesTest {
     @Ignore
     public void testSumOfMultiplesOfNoneUpToTenThousand() {
         
-        SumOfMultiples mySum = new SumOfMultiples();
         int[] set = {};
-        int output = mySum.Sum(10000, set);
+        int output = SumOfMultiples.sum(10000, set);
         assertEquals(0, output);
         
     }