trackler 2.0.0.5 → 2.0.0.6

data/tracks/java/exercises/etl/src/test/java/EtlTest.java

@@ -1,79 +1,125 @@
-import com.google.common.collect.ImmutableMap;
 import org.junit.Test;
-import org.junit.Ignore;
 
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
+
+import static org.junit.Assert.assertEquals;
 
-import static org.assertj.core.api.Assertions.assertThat;
 
 public class EtlTest {
     private final Etl etl = new Etl();
 
-
     @Test
     public void testTransformOneValue() {
-        Map<Integer, List<String>> old = ImmutableMap.of(1, Arrays.asList("A"));
-        Map<String, Integer> expected = ImmutableMap.of("a", 1);
+        Map<Integer, List<String>> old = new HashMap<Integer, List<String>>() {
+            {
+                put(1, Arrays.asList("A"));
+            }
+        };
+        old = Collections.unmodifiableMap(old);
+
+        Map<String, Integer> expected = new HashMap<String, Integer>() {
+            {
+                put("a", 1);
+            }
+        };
+        expected = Collections.unmodifiableMap(expected);
 
-        assertThat(etl.transform(old)).isEqualTo(expected);
+        assertEquals(etl.transform(old), expected);
     }
 
-    @Ignore
     @Test
     public void testTransformMoreValues() {
-        Map<Integer, List<String>> old = ImmutableMap.of(
-                1, Arrays.asList("A", "E", "I", "O", "U")
-        );
-        Map<String, Integer> expected = ImmutableMap.of(
-                "a", 1,
-                "e", 1,
-                "i", 1,
-                "o", 1,
-                "u", 1
-        );
-
-        assertThat(etl.transform(old)).isEqualTo(expected);
+        Map<Integer, List<String>> old = new HashMap<Integer, List<String>>() {
+            {
+                put(1, Arrays.asList("A", "E", "I", "O", "U"));
+            }
+        };
+        old = Collections.unmodifiableMap(old);
+
+        Map<String, Integer> expected = new HashMap<String, Integer>() {
+            {
+                put("a", 1);
+                put("e", 1);
+                put("i", 1);
+                put("o", 1);
+                put("u", 1);
+            }
+        };
+        expected = Collections.unmodifiableMap(expected);
+
+        assertEquals(etl.transform(old), expected);
     }
 
-    @Ignore
     @Test
     public void testMoreKeys() {
-        Map<Integer, List<String>> old = ImmutableMap.of(
-                1, Arrays.asList("A", "E"),
-                2, Arrays.asList("D", "G")
-        );
-        Map<String, Integer> expected = ImmutableMap.of(
-                "a", 1,
-                "e", 1,
-                "d", 2,
-                "g", 2
-        );
-
-        assertThat(etl.transform(old)).isEqualTo(expected);
+        Map<Integer, List<String>> old = new HashMap<Integer, List<String>>() {
+            {
+                put(1, Arrays.asList("A", "E"));
+                put(2, Arrays.asList("D", "G"));
+            }
+        };
+        old = Collections.unmodifiableMap(old);
+
+        Map<String, Integer> expected = new HashMap<String, Integer>() {
+            {
+                put("a", 1);
+                put("e", 1);
+                put("d", 2);
+                put("g", 2);
+            }
+        };
+        expected = Collections.unmodifiableMap(expected);
+
+        assertEquals(etl.transform(old), expected);
     }
 
-    @Ignore
     @Test
     public void testFullDataset() {
-        Map<Integer, List<String>> old = ImmutableMap.<Integer, List<String>>builder().
-                put(1, Arrays.asList("A", "E", "I", "O", "U", "L", "N", "R", "S", "T")).
-                put(2, Arrays.asList("D", "G")).
-                put(3, Arrays.asList("B", "C", "M", "P")).
-                put(4, Arrays.asList("F", "H", "V", "W", "Y")).
-                put(5, Arrays.asList("K")).
-                put(8, Arrays.asList("J", "X")).
-                put(10, Arrays.asList("Q", "Z")).
-                build();
-        Map<String, Integer> expected = ImmutableMap.<String, Integer>builder().
-                put("a", 1).put("b", 3).put("c", 3).put("d", 2).put("e", 1).
-                put("f", 4).put("g", 2).put("h", 4).put("i", 1).put("j", 8).
-                put("k", 5).put("l", 1).put("m", 3).put("n", 1).put("o", 1).
-                put("p", 3).put("q", 10).put("r", 1).put("s", 1).put("t", 1).
-                put("u", 1).put("v", 4).put("w", 4).put("x", 8).put("y", 4).
-                put("z", 10).build();
-
-        assertThat(etl.transform(old)).isEqualTo(expected);
+        Map<Integer, List<String>> old = new HashMap<Integer, List<String>>() {
+            {
+                put(1, Arrays.asList("A", "E", "I", "O", "U", "L", "N", "R", "S", "T"));
+                put(2, Arrays.asList("D", "G"));
+                put(3, Arrays.asList("B", "C", "M", "P"));
+                put(4, Arrays.asList("F", "H", "V", "W", "Y"));
+                put(5, Arrays.asList("K"));
+                put(8, Arrays.asList("J", "X"));
+                put(10, Arrays.asList("Q", "Z"));
+            }
+        };
+        old = Collections.unmodifiableMap(old);
+
+        Map<String, Integer> expected = new HashMap<String, Integer>() {
+            {
+                put("a", 1);
+                put("b", 3);
+                put("c", 3);
+                put("d", 2);
+                put("e", 1);
+                put("f", 4);
+                put("g", 2);
+                put("h", 4);
+                put("i", 1);
+                put("j", 8);
+                put("k", 5);
+                put("l", 1);
+                put("m", 3);
+                put("n", 1);
+                put("o", 1);
+                put("p", 3);
+                put("q", 10);
+                put("r", 1);
+                put("s", 1);
+                put("t", 1);
+                put("u", 1);
+                put("v", 4);
+                put("w", 4);
+                put("x", 8);
+                put("y", 4);
+                put("z", 10);
+            }
+        };
+        expected = Collections.unmodifiableMap(expected);
+
+        assertEquals(etl.transform(old), expected);
     }
 }

data/tracks/java/exercises/hello-world/TUTORIAL.md

@@ -419,7 +419,7 @@ for "good" design of software is a big topic.  The pursuit of it underlies
 much of what makes up the more valuable conversations on Exercism.
 
 For now, let's just take a quick review of our solution and see if there's
-any part of it we'd like to refactor.  Refactoring is changing the the way
+any part of it we'd like to refactor.  Refactoring is changing the way
 a bit of code reads without changing what it does.
 
 Right now, the details of detecting whether the caller of `hello()` has

data/tracks/java/exercises/largest-series-product/build.gradle

@@ -0,0 +1,17 @@
+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/largest-series-product/src/example/java/LargestSeriesProductCalculator.java

@@ -0,0 +1,56 @@
+public final class LargestSeriesProductCalculator {
+
+    private final String stringToSearch;
+
+    public LargestSeriesProductCalculator(final String stringToSearch) throws IllegalArgumentException {
+        this.stringToSearch = stringToSearch;
+        validateStringToSearch();
+    }
+
+    public long calculateLargestProductForSeriesLength(final int seriesLength) throws IllegalArgumentException {
+        if (seriesLength < 0) {
+            throw new IllegalArgumentException("Series length must be non-negative.");
+        } else if (seriesLength == 0) {
+            return 1;
+        } else if (seriesLength > stringToSearch.length()) {
+            throw new IllegalArgumentException(
+                    "Series length must be less than or equal to the length of the string to search.");
+        } else {
+            long result = 0;
+
+            int numberOfSeriesToCheck = stringToSearch.length() - seriesLength + 1;
+
+            for (int startIndex = 0; startIndex < numberOfSeriesToCheck; startIndex++) {
+                /*
+                 * Note: computing the product of each series fresh each time is not the most efficient solution, but
+                 * it's the simplest to reason about.
+                 */
+                result = Math.max(result, computeProductOfSeries(startIndex, seriesLength));
+            }
+
+            return result;
+        }
+    }
+
+    private void validateStringToSearch() throws IllegalArgumentException {
+        if (stringToSearch == null) {
+            throw new IllegalArgumentException("String to search must be non-null.");
+        } else if (!stringToSearch.chars().allMatch(Character::isDigit)) {
+            throw new IllegalArgumentException("String to search may only contains digits.");
+        }
+    }
+
+    private long computeProductOfSeries(final int startIndex, final int seriesLength) {
+        // The multiplicative identity is 1.
+        long result = 1;
+
+        final int endIndex = startIndex + seriesLength - 1;
+
+        for (int characterIndex = startIndex; characterIndex <= endIndex; characterIndex++) {
+            result = result * Character.getNumericValue(stringToSearch.charAt(characterIndex));
+        }
+
+        return result;
+    }
+
+}

data/tracks/java/exercises/largest-series-product/src/main/java/LargestSeriesProductCalculator.java

@@ -0,0 +1,5 @@
+public class LargestSeriesProductCalculator {
+
+
+
+}

data/tracks/java/exercises/largest-series-product/src/test/java/LargestSeriesProductCalculatorTest.java

@@ -0,0 +1,218 @@
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import static org.junit.Assert.assertEquals;
+
+public final class LargestSeriesProductCalculatorTest {
+
+    /*
+     * See https://github.com/junit-team/junit4/wiki/Rules for information on JUnit Rules in general and
+     * ExpectedExceptions in particular.
+     */
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+
+    @Test
+    public void testCorrectlyCalculatesLargestProductOfLengthTwoWithNumbersInOrder() {
+        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0123456789");
+        final long expectedProduct = 72;
+
+        final long actualProduct = calculator.calculateLargestProductForSeriesLength(2);
+
+        assertEquals(expectedProduct, actualProduct);
+    }
+
+    @Ignore
+    @Test
+    public void testCorrectlyCalculatesLargestProductOfLengthTwoWithNumbersNotInOrder() {
+        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("576802143");
+        final long expectedProduct = 48;
+
+        final long actualProduct = calculator.calculateLargestProductForSeriesLength(2);
+
+        assertEquals(expectedProduct, actualProduct);
+    }
+
+    @Ignore
+    @Test
+    public void testCorrectlyCalculatesLargestProductWhenSeriesLengthEqualsStringToSearchLength() {
+        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("29");
+        final long expectedProduct = 18;
+
+        final long actualProduct = calculator.calculateLargestProductForSeriesLength(2);
+
+        assertEquals(expectedProduct, actualProduct);
+    }
+
+    @Ignore
+    @Test
+    public void testCorrectlyCalculatesLargestProductOfLengthThreeWithNumbersInOrder() {
+        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0123456789");
+        final long expectedProduct = 504;
+
+        final long actualProduct = calculator.calculateLargestProductForSeriesLength(3);
+
+        assertEquals(expectedProduct, actualProduct);
+    }
+
+    @Ignore
+    @Test
+    public void testCorrectlyCalculatesLargestProductOfLengthThreeWithNumbersNotInOrder() {
+        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("1027839564");
+        final long expectedProduct = 270;
+
+        final long actualProduct = calculator.calculateLargestProductForSeriesLength(3);
+
+        assertEquals(expectedProduct, actualProduct);
+    }
+
+    @Ignore
+    @Test
+    public void testCorrectlyCalculatesLargestProductOfLengthFiveWithNumbersInOrder() {
+        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0123456789");
+        final long expectedProduct = 15120;
+
+        final long actualProduct = calculator.calculateLargestProductForSeriesLength(5);
+
+        assertEquals(expectedProduct, actualProduct);
+    }
+
+    @Ignore
+    @Test
+    public void testCorrectlyCalculatesLargestProductInLongStringToSearchV1() {
+        final LargestSeriesProductCalculator calculator
+                = new LargestSeriesProductCalculator("73167176531330624919225119674426574742355349194934");
+
+        final long expectedProduct = 23520;
+
+        final long actualProduct = calculator.calculateLargestProductForSeriesLength(6);
+
+        assertEquals(expectedProduct, actualProduct);
+    }
+
+    @Ignore
+    @Test
+    public void testCorrectlyCalculatesLargestProductInLongStringToSearchV2() {
+        final LargestSeriesProductCalculator calculator
+                = new LargestSeriesProductCalculator("52677741234314237566414902593461595376319419139427");
+
+        final long expectedProduct = 28350;
+
+        final long actualProduct = calculator.calculateLargestProductForSeriesLength(6);
+
+        assertEquals(expectedProduct, actualProduct);
+    }
+
+    @Ignore
+    @Test
+    public void testCorrectlyCalculatesLargestProductInLongStringToSearchFromProjectEuler() {
+        final LargestSeriesProductCalculator calculator
+                = new LargestSeriesProductCalculator("7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450");
+
+        final long expectedProduct = 23514624000L;
+
+        final long actualProduct = calculator.calculateLargestProductForSeriesLength(13);
+
+        assertEquals(expectedProduct, actualProduct);
+    }
+
+    @Ignore
+    @Test
+    public void testCorrectlyCalculatesLargestProductOfZeroIfAllDigitsAreZeroes() {
+        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0000");
+        final long expectedProduct = 0;
+
+        final long actualProduct = calculator.calculateLargestProductForSeriesLength(2);
+
+        assertEquals(expectedProduct, actualProduct);
+    }
+
+    @Ignore
+    @Test
+    public void testCorrectlyCalculatesLargestProductOfZeroIfAllSeriesOfGivenLengthContainZero() {
+        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("99099");
+        final long expectedProduct = 0;
+
+        final long actualProduct = calculator.calculateLargestProductForSeriesLength(3);
+
+        assertEquals(expectedProduct, actualProduct);
+    }
+
+    @Ignore
+    @Test
+    public void testSeriesLengthLongerThanLengthOfStringToTestIsRejected() {
+        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("123");
+
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage(
+                "Series length must be less than or equal to the length of the string to search.");
+
+        calculator.calculateLargestProductForSeriesLength(4);
+    }
+
+    @Ignore
+    @Test
+    public void testCorrectlyCalculatesLargestProductOfLength0ForEmptyStringToSearch() {
+        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("");
+        final long expectedProduct = 1;
+
+        final long actualProduct = calculator.calculateLargestProductForSeriesLength(0);
+
+        assertEquals(expectedProduct, actualProduct);
+    }
+
+    @Ignore
+    @Test
+    public void testCorrectlyCalculatesLargestProductOfLength0ForNonEmptyStringToSearch() {
+        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("123");
+        final long expectedProduct = 1;
+
+        final long actualProduct = calculator.calculateLargestProductForSeriesLength(0);
+
+        assertEquals(expectedProduct, actualProduct);
+    }
+
+    @Ignore
+    @Test
+    public void testEmptyStringToSearchAndSeriesOfNonZeroLengthIsRejected() {
+        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("");
+
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage(
+                "Series length must be less than or equal to the length of the string to search.");
+
+        calculator.calculateLargestProductForSeriesLength(1);
+    }
+
+    @Ignore
+    @Test
+    public void testStringToSearchContainingNonDigitCharacterIsRejected() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("String to search may only contains digits.");
+
+        new LargestSeriesProductCalculator("1234a5");
+    }
+
+    @Ignore
+    @Test
+    public void testNegativeSeriesLengthIsRejected() {
+        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("12345");
+
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Series length must be non-negative.");
+
+        calculator.calculateLargestProductForSeriesLength(-1);
+    }
+
+    @Ignore
+    @Test
+    public void testNullStringToSearchIsRejected() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("String to search must be non-null.");
+
+        new LargestSeriesProductCalculator(null);
+    }
+
+}

data/tracks/java/exercises/queen-attack/build.gradle

@@ -0,0 +1,17 @@
+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/queen-attack/src/example/java/BoardCoordinate.java

@@ -0,0 +1,39 @@
+public final class BoardCoordinate {
+
+    private final int rank;
+
+    private final int file;
+
+    public BoardCoordinate(final int rank, final int file) throws IllegalArgumentException {
+        this.rank = rank;
+        this.file = file;
+
+        validateInputs();
+    }
+
+    public int getRank() {
+        return rank;
+    }
+
+    public int getFile() {
+        return file;
+    }
+
+    private void validateInputs() throws IllegalArgumentException {
+        validateCoordinateComponent(rank, "rank");
+        validateCoordinateComponent(file, "file");
+    }
+
+    private void validateCoordinateComponent(final int value, final String componentName)
+            throws IllegalArgumentException {
+
+        if (value < 0) {
+            throw new IllegalArgumentException("Coordinate must have positive " + componentName + ".");
+        }
+
+        if (value > 7) {
+            throw new IllegalArgumentException("Coordinate must have " + componentName + " <= 7.");
+        }
+    }
+
+}

data/tracks/java/exercises/queen-attack/src/example/java/QueenAttackCalculator.java

@@ -0,0 +1,54 @@
+public final class QueenAttackCalculator {
+
+    private final BoardCoordinate whiteQueenCoordinate;
+
+    private final BoardCoordinate blackQueenCoordinate;
+
+    public QueenAttackCalculator(final BoardCoordinate whiteQueenCoordinate, final BoardCoordinate blackQueenCoordinate)
+            throws IllegalArgumentException {
+
+        this.whiteQueenCoordinate = whiteQueenCoordinate;
+        this.blackQueenCoordinate = blackQueenCoordinate;
+
+        validateInputs();
+    }
+
+    public boolean canQueensAttackOneAnother() {
+        return queensShareFile() || queensShareRank() || queensShareDiagonal();
+    }
+
+    private void validateInputs() throws IllegalArgumentException {
+        if (whiteQueenCoordinate == null || blackQueenCoordinate == null) {
+            throw new IllegalArgumentException("You must supply valid board coordinates for both Queens.");
+        }
+
+        if (queensShareBoardCoordinate()) {
+            throw new IllegalArgumentException("Queens may not occupy the same board coordinate.");
+        }
+    }
+
+    private boolean queensShareRank() {
+        return differenceBetweenRanks() == 0;
+    }
+
+    private boolean queensShareFile() {
+        return differenceBetweenFiles() == 0;
+    }
+
+    private boolean queensShareBoardCoordinate() {
+        return queensShareRank() && queensShareFile();
+    }
+
+    private boolean queensShareDiagonal() {
+        return differenceBetweenRanks() == differenceBetweenFiles();
+    }
+
+    private int differenceBetweenRanks() {
+        return Math.abs(whiteQueenCoordinate.getRank() - blackQueenCoordinate.getRank());
+    }
+
+    private int differenceBetweenFiles() {
+        return Math.abs(whiteQueenCoordinate.getFile() - blackQueenCoordinate.getFile());
+    }
+
+}

data/tracks/java/exercises/queen-attack/src/main/java/BoardCoordinate.java

@@ -0,0 +1,5 @@
+public final class BoardCoordinate {
+
+
+
+}

data/tracks/java/exercises/queen-attack/src/main/java/QueenAttackCalculator.java

@@ -0,0 +1,5 @@
+public final class QueenAttackCalculator {
+
+
+
+}