trackler 2.2.1.85 → 2.2.1.86

data/tracks/haskell/exercises/palindrome-products/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/pangram/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/parallel-letter-frequency/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/pascals-triangle/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/perfect-numbers/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/phone-number/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/pig-latin/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/pov/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/prime-factors/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/pythagorean-triplet/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/queen-attack/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/rail-fence-cipher/package.yaml

@@ -1,5 +1,5 @@
 name: rail-fence-cipher
-version: 1.1.0.1
+version: 1.0.1.2
 
 dependencies:
   - base

data/tracks/haskell/exercises/rail-fence-cipher/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/raindrops/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/rna-transcription/package.yaml

@@ -1,5 +1,5 @@
 name: rna-transcription
-version: 1.0.1.4
+version: 1.1.0.5
 
 dependencies:
   - base

data/tracks/haskell/exercises/rna-transcription/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/rna-transcription/test/Tests.hs

@@ -40,16 +40,4 @@ cases = [ Case { description = "RNA complement of cytosine is guanine"
                , dna         =      "ACGTGGTCTTAA"
                , expected    = Just "UGCACCAGAAUU"
                }
-        , Case { description = "correctly handles invalid input (RNA instead of DNA)"
-               , dna         = "U"
-               , expected    = Nothing
-               }
-        , Case { description = "correctly handles completely invalid DNA input"
-               , dna         = "XXX"
-               , expected    = Nothing
-               }
-        , Case { description = "correctly handles partially invalid DNA input"
-               , dna         = "ACGTXXXCTTAA"
-               , expected    = Nothing
-               }
         ]

data/tracks/haskell/exercises/robot-name/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/robot-simulator/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/roman-numerals/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/rotational-cipher/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/run-length-encoding/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/saddle-points/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/say/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/scrabble-score/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/secret-handshake/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/series/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/sgf-parsing/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/sieve/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/simple-cipher/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/simple-linked-list/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/space-age/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/spiral-matrix/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/strain/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/sublist/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/sum-of-multiples/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/triangle/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/trinary/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/twelve-days/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/word-count/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/wordy/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/zebra-puzzle/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/haskell/exercises/zipper/stack.yaml

@@ -1 +1 @@
-resolver: lts-9.11
+resolver: lts-10.2

data/tracks/java/config.json

@@ -612,6 +612,18 @@
       "unlocked_by": "rotational-cipher",
       "uuid": "d36ce010-210f-4e9a-9d6c-cb933e0a59af"
     },
+    {
+      "core": false,
+      "difficulty": 6,
+      "slug": "alphametics",
+      "topics": [
+        "mathematics",
+        "logic",
+        "conditionals"
+      ],
+      "unlocked_by": "secret-handshake",
+      "uuid": "0639a1f8-5af4-4877-95c1-5db8e97c30bf"
+    },
     {
       "core": false,
       "difficulty": 6,

data/tracks/java/exercises/alphametics/.meta/src/reference/java/Alphametics.java

@@ -0,0 +1,125 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class Alphametics {
+    private final List<String> wordsToSum;
+    private final String wordResult;
+
+    Alphametics(String userInput) {
+        String[] questionAndAnswer = userInput.split("==");
+        wordsToSum = Arrays.stream(questionAndAnswer[0].split("\\+"))
+                .map(String::new)
+                .map(String::trim)
+                .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
+        wordResult = questionAndAnswer[1].trim();
+    }
+
+    Map<Character, Integer> solve() throws UnsolvablePuzzleException {
+        AlphameticsRecursion solver = new AlphameticsRecursion(getDistinctCharacters());
+        solver.generate();
+        return solver.get().orElseThrow(UnsolvablePuzzleException::new);
+    }
+
+    /**
+     * Returns the list of distinct characters in this alphametic puzzle.
+     */
+    private List<Character> getDistinctCharacters() {
+        Set<Character> distinctCharacters = new LinkedHashSet<>();
+        wordsToSum.forEach(word -> distinctCharacters.addAll(toChar(word)));
+        distinctCharacters.addAll(toChar(wordResult));
+
+        return new ArrayList<>(distinctCharacters);
+    }
+
+    private List<Character> toChar(String toChar) {
+        return toChar.chars()
+                .mapToObj(c -> (char) c)
+                .collect(Collectors.toList());
+    }
+
+    private class AlphameticsRecursion {
+        private final List<Character> characters;
+        private LinkedHashMap<Character, Integer> validPermutation;
+
+        private AlphameticsRecursion(List<Character> characters) {
+            this.characters = characters;
+        }
+
+        private void generate() {
+            generate(new LinkedHashMap<>(), 0, new boolean[10]);
+        }
+
+        private void generate(LinkedHashMap<Character, Integer> permutation, int index, boolean[] isDigitsUsed) {
+            // base case
+            if (index == characters.size()) {
+                if (!isLeadingDigitZero(permutation) && isSumTally(permutation)) {
+                    validPermutation = new LinkedHashMap<>(permutation);
+                }
+                return;
+            }
+
+            for (int i = 0; i <= 9; i++) { // loop through digits 0 to 9
+                if (isDigitsUsed[i]) {
+                    continue;
+                }
+
+                permutation.put(characters.get(index), i);
+                isDigitsUsed[i] = true;
+                generate(permutation, index + 1, isDigitsUsed);
+                isDigitsUsed[i] = false;
+            }
+        }
+
+        private Optional<LinkedHashMap<Character, Integer>> get() {
+            return Optional.ofNullable(validPermutation);
+        }
+
+        /**
+         * Returns true if the mapping letters to digits using {@code letterToDigit} will result in having zero as a
+         * leading digit.
+         */
+        private boolean isLeadingDigitZero(Map<Character, Integer> letterToDigit) {
+            return letterToDigit.keySet().stream()
+                    .filter(key -> letterToDigit.get(key) == 0) // Find the character that is mapped to digit 0
+                    .filter(charMappedToZero -> wordResult.charAt(0) == charMappedToZero // If the first character in
+                                                                                         // wordResult is mapped to 0
+                            || wordsToSum.stream() // If the first character in any of wordsToSum is mapped to 0
+                            .map(word -> word.charAt(0))
+                            .anyMatch(character -> character == charMappedToZero))
+                    .count() == 1; // One letter maps to zero and is a leading character
+        }
+
+        /**
+         * Returns true if the {@code letterToDigit} solves the alphametic puzzle.
+         */
+        private boolean isSumTally(Map<Character, Integer> letterToDigit) {
+            long actualSum = wordsToSum.stream()
+                    .mapToLong(word -> mapToNumber(letterToDigit, word))
+                    .sum();
+            long expectedSum = mapToNumber(letterToDigit, wordResult);
+            return actualSum == expectedSum;
+        }
+
+        /**
+         * Returns the long value of {@code word}, mapped using {@code letterToDigit}.
+         */
+        private long mapToNumber(Map<Character, Integer> letterToDigit, String word) {
+            StringBuilder builder = new StringBuilder();
+
+            for (int i = 0; i < word.length(); i++) {
+                int digit = letterToDigit.get(word.charAt(i));
+                builder.append(digit);
+            }
+
+            return Long.parseLong(builder.toString());
+        }
+    }
+}

data/tracks/java/exercises/alphametics/.meta/src/reference/java/UnsolvablePuzzleException.java

@@ -0,0 +1,2 @@
+class UnsolvablePuzzleException extends Exception {
+}

data/tracks/java/exercises/alphametics/.meta/src/version

@@ -0,0 +1 @@
+1.1.0

data/tracks/java/exercises/alphametics/README.md

@@ -0,0 +1,47 @@
+# Alphametics
+
+Write a function to solve alphametics puzzles.
+
+[Alphametics](https://en.wikipedia.org/wiki/Alphametics) is a puzzle where
+letters in words are replaced with numbers.
+
+For example `SEND + MORE = MONEY`:
+
+```text
+  S E N D
+  M O R E +
+-----------
+M O N E Y
+```
+
+Replacing these with valid numbers gives:
+
+```text
+  9 5 6 7
+  1 0 8 5 +
+-----------
+1 0 6 5 2
+```
+
+This is correct because every letter is replaced by a different number and the
+words, translated into numbers, then make a valid sum.
+
+Each letter must represent a different digit, and the leading digit of
+a multi-digit number must not be zero.
+
+Write a function to solve alphametics puzzles.
+
+# Running the tests
+
+You can run all the tests for an exercise by entering
+
+```sh
+$ gradle test
+```
+
+in your terminal.
+
+
+## Submitting Incomplete Solutions
+
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/java/exercises/alphametics/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/alphametics/src/main/java/UnsolvablePuzzleException.java

@@ -0,0 +1,2 @@
+class UnsolvablePuzzleException extends Exception {
+}

data/tracks/java/exercises/alphametics/src/test/java/AlphameticsTest.java

@@ -0,0 +1,150 @@
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.Assert.*;
+
+public class AlphameticsTest {
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+
+    @Test
+    public void testThreeLetters() throws UnsolvablePuzzleException {
+        LinkedHashMap<Character, Integer> expected = new LinkedHashMap<>();
+        expected.put('I', 1);
+        expected.put('B', 9);
+        expected.put('L', 0);
+
+        assertEquals(expected, new Alphametics("I + BB == ILL").solve());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testUniqueValue() throws UnsolvablePuzzleException {
+        expectedException.expect(UnsolvablePuzzleException.class);
+        new Alphametics("A == B").solve();
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testLeadingZero() throws UnsolvablePuzzleException {
+        expectedException.expect(UnsolvablePuzzleException.class);
+        assertNull(new Alphametics("ACA + DD == BD").solve());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testFourLetters() throws UnsolvablePuzzleException {
+        LinkedHashMap<Character, Integer> expected = new LinkedHashMap<>();
+        expected.put('A', 9);
+        expected.put('S', 2);
+        expected.put('M', 1);
+        expected.put('O', 0);
+
+        assertEquals(expected, new Alphametics("AS + A == MOM").solve());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testSixLetters() throws UnsolvablePuzzleException {
+        LinkedHashMap<Character, Integer> expected = new LinkedHashMap<>();
+        expected.put('N', 7);
+        expected.put('O', 4);
+        expected.put('T', 9);
+        expected.put('L', 1);
+        expected.put('A', 0);
+        expected.put('E', 2);
+
+        assertEquals(expected, new Alphametics("NO + NO + TOO == LATE").solve());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testSevenLetters() throws UnsolvablePuzzleException {
+        LinkedHashMap<Character, Integer> expected = new LinkedHashMap<>();
+        expected.put('E', 4);
+        expected.put('G', 2);
+        expected.put('H', 5);
+        expected.put('I', 0);
+        expected.put('L', 1);
+        expected.put('S', 9);
+        expected.put('T', 7);
+
+        assertEquals(expected, new Alphametics("HE + SEES + THE == LIGHT").solve());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testEightLetters() throws UnsolvablePuzzleException {
+        LinkedHashMap<Character, Integer> expected = new LinkedHashMap<>();
+        expected.put('S', 9);
+        expected.put('E', 5);
+        expected.put('N', 6);
+        expected.put('D', 7);
+        expected.put('M', 1);
+        expected.put('O', 0);
+        expected.put('R', 8);
+        expected.put('Y', 2);
+
+        assertEquals(expected, new Alphametics("SEND + MORE == MONEY").solve());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testTenLetters() throws UnsolvablePuzzleException {
+        LinkedHashMap<Character, Integer> expected = new LinkedHashMap<>();
+        expected.put('A', 5);
+        expected.put('D', 3);
+        expected.put('E', 4);
+        expected.put('F', 7);
+        expected.put('G', 8);
+        expected.put('N', 0);
+        expected.put('O', 2);
+        expected.put('R', 1);
+        expected.put('S', 6);
+        expected.put('T', 9);
+
+        assertEquals(expected, new Alphametics("AND + A + STRONG + OFFENSE + AS + A + GOOD == DEFENSE").solve());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testTenLetters41Addends() throws UnsolvablePuzzleException {
+        LinkedHashMap<Character, Integer> expected = new LinkedHashMap<>();
+        expected.put('A', 1);
+        expected.put('E', 0);
+        expected.put('F', 5);
+        expected.put('H', 8);
+        expected.put('I', 7);
+        expected.put('L', 2);
+        expected.put('O', 6);
+        expected.put('R', 3);
+        expected.put('S', 4);
+        expected.put('T', 9);
+
+        assertEquals(expected, new Alphametics("THIS + A + FIRE + THEREFORE + FOR + ALL + HISTORIES + I + TELL + A + " +
+                "TALE + THAT + FALSIFIES + ITS + TITLE + TIS + A + LIE + THE + TALE + OF + THE + LAST + FIRE + " +
+                "HORSES + LATE + AFTER + THE + FIRST + FATHERS + FORESEE + THE + HORRORS + THE + LAST + FREE + " +
+                "TROLL + TERRIFIES + THE + HORSES + OF + FIRE + THE + TROLL + RESTS + AT + THE + HOLE + OF + " +
+                "LOSSES + IT + IS + THERE + THAT + SHE + STORES + ROLES + OF + LEATHERS + AFTER + SHE + SATISFIES + " +
+                "HER + HATE + OFF + THOSE + FEARS + A + TASTE + RISES + AS + SHE + HEARS + THE + LEAST + FAR + " +
+                "HORSE + THOSE + FAST + HORSES + THAT + FIRST + HEAR + THE + TROLL + FLEE + OFF + TO + THE + " +
+                "FOREST + THE + HORSES + THAT + ALERTS + RAISE + THE + STARES + OF + THE + OTHERS + AS + THE + " +
+                "TROLL + ASSAILS + AT + THE + TOTAL + SHIFT + HER + TEETH + TEAR + HOOF + OFF + TORSO + AS + THE + " +
+                "LAST + HORSE + FORFEITS + ITS + LIFE + THE + FIRST + FATHERS + HEAR + OF + THE + HORRORS + THEIR + " +
+                "FEARS + THAT + THE + FIRES + FOR + THEIR + FEASTS + ARREST + AS + THE + FIRST + FATHERS + " +
+                "RESETTLE + THE + LAST + OF + THE + FIRE + HORSES + THE + LAST + TROLL + HARASSES + THE + FOREST + " +
+                "HEART + FREE + AT + LAST + OF + THE + LAST + TROLL + ALL + OFFER + THEIR + FIRE + HEAT + TO + THE + " +
+                "ASSISTERS + FAR + OFF + THE + TROLL + FASTS + ITS + LIFE + SHORTER + AS + STARS + RISE + THE + " +
+                "HORSES + REST + SAFE + AFTER + ALL + SHARE + HOT + FISH + AS + THEIR + AFFILIATES + TAILOR + A + " +
+                "ROOFS + FOR + THEIR + SAFE == FORTRESSES").solve());
+    }
+}