Implement alphametics exercise (#1188)

* Implement alphametics

* Patch

* Update Alphametics to throw Exception

config.json

@@ -615,6 +615,18 @@
     {
       "core": false,
       "difficulty": 6,
+      "slug": "alphametics",
+      "topics": [
+        "mathematics",
+        "logic",
+        "conditionals"
+      ],
+      "unlocked_by": "secret-handshake",
+      "uuid": "0639a1f8-5af4-4877-95c1-5db8e97c30bf"
+    },
+    {
+      "core": false,
+      "difficulty": 6,
       "slug": "spiral-matrix",
       "topics": [
         "arrays",

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());
+        }
+    }
+}

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

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

exercises/alphametics/.meta/src/version

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

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.

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"]
+  }
+}

exercises/alphametics/src/main/java/UnsolvablePuzzleException.java

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

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());
+    }
+}

exercises/settings.gradle

@@ -2,6 +2,7 @@ include 'accumulate'
 include 'acronym'
 include 'all-your-base'
 include 'allergies'
+include 'alphametics'
 include 'anagram'
 include 'armstrong-numbers'
 include 'atbash-cipher'