wordy: add to track (#192)

config.json

     "binary-search-tree",
     "binary-search",
     "all-your-base",
+    "wordy",
     "palindrome-products"
   ],
   "exercises": [
       "topics": []
     },
     {
+      "slug": "wordy",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
       "slug": "palindrome-products",
       "difficulty": 1,
       "topics": []

exercises/settings.gradle

 include 'triangle'
 include 'trinary'
 include 'word-count'
+include 'wordy'

exercises/wordy/build.gradle

+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/wordy/src/example/java/WordProblemSolver.java

+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+final class WordProblemSolver {
+
+    private static final String INTEGER_REGEX_STRING = "(-?\\d+)";
+
+    private static final String BINARY_OPERATION_REGEX_STRING = "(plus|minus|multiplied by|divided by)";
+
+    private static final String VALID_QUESTION_REGEX_STRING =
+            "^What is " + INTEGER_REGEX_STRING +
+            "( " + BINARY_OPERATION_REGEX_STRING + " " + INTEGER_REGEX_STRING + ")+" +
+            "\\?$";
+
+    int solve(final String wordProblem) {
+        if (!wordProblem.matches(VALID_QUESTION_REGEX_STRING)) {
+            throw new IllegalArgumentException("I'm sorry, I don't understand the question!");
+        }
+
+        final Matcher initialValueMatcher = Pattern.compile(INTEGER_REGEX_STRING).matcher(wordProblem);
+
+        initialValueMatcher.find();
+        int result = Integer.parseInt(initialValueMatcher.group());
+
+        final Matcher operationAndValueMatcher
+                = Pattern.compile(BINARY_OPERATION_REGEX_STRING + " " + INTEGER_REGEX_STRING).matcher(wordProblem);
+
+        while (operationAndValueMatcher.find()) {
+            result = applyBinaryOperation(
+                result,
+                operationAndValueMatcher.group(1),
+                Integer.parseInt(operationAndValueMatcher.group(2)));
+        }
+
+        return result;
+    }
+
+    private int applyBinaryOperation(
+            final int firstValue,
+            final String operationDescription,
+            final int secondValue) {
+
+        switch (operationDescription) {
+            case "plus":
+                return firstValue + secondValue;
+            case "minus":
+                return firstValue - secondValue;
+            case "multiplied by":
+                return firstValue * secondValue;
+            case "divided by":
+                return firstValue / secondValue;
+            default:
+                throw new IllegalArgumentException("This branch should never be executed.");
+        }
+    }
+
+}

exercises/wordy/src/main/java/WordProblemSolver.java

+final class WordProblemSolver {
+
+
+
+}

exercises/wordy/src/test/java/WordProblemSolverTest.java

+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 WordProblemSolverTest {
+
+    /*
+     * 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 testSingleAddition1() {
+        assertEquals(2, new WordProblemSolver().solve("What is 1 plus 1?"));
+    }
+
+    @Ignore
+    @Test
+    public void testSingleAddition2() {
+        assertEquals(55, new WordProblemSolver().solve("What is 53 plus 2?"));
+    }
+
+    @Ignore
+    @Test
+    public void testSingleAdditionWithNegativeNumbers() {
+        assertEquals(-11, new WordProblemSolver().solve("What is -1 plus -10?"));
+    }
+
+    @Ignore
+    @Test
+    public void testSingleAdditionOfLargeNumbers() {
+        assertEquals(45801, new WordProblemSolver().solve("What is 123 plus 45678?"));
+    }
+
+    @Ignore
+    @Test
+    public void testSingleSubtraction() {
+        assertEquals(16, new WordProblemSolver().solve("What is 4 minus -12?"));
+    }
+
+    @Ignore
+    @Test
+    public void testSingleMultiplication() {
+        assertEquals(-75, new WordProblemSolver().solve("What is -3 multiplied by 25?"));
+    }
+
+    @Ignore
+    @Test
+    public void testSingleDivision() {
+        assertEquals(-11, new WordProblemSolver().solve("What is 33 divided by -3?"));
+    }
+
+    @Ignore
+    @Test
+    public void testMultipleAdditions() {
+        assertEquals(3, new WordProblemSolver().solve("What is 1 plus 1 plus 1?"));
+    }
+
+    @Ignore
+    @Test
+    public void testAdditionThenSubtraction() {
+        assertEquals(8, new WordProblemSolver().solve("What is 1 plus 5 minus -2?"));
+    }
+
+    @Ignore
+    @Test
+    public void testMultipleSubtractions() {
+        assertEquals(3, new WordProblemSolver().solve("What is 20 minus 4 minus 13?"));
+    }
+
+    @Ignore
+    @Test
+    public void testSubtractionThenAddition() {
+        assertEquals(14, new WordProblemSolver().solve("What is 17 minus 6 plus 3?"));
+    }
+
+    @Ignore
+    @Test
+    public void testMultipleMultiplications() {
+        assertEquals(-12, new WordProblemSolver().solve("What is 2 multiplied by -2 multiplied by 3?"));
+    }
+
+    @Ignore
+    @Test
+    public void testAdditionThenMultiplication() {
+        assertEquals(-8, new WordProblemSolver().solve("What is -3 plus 7 multiplied by -2?"));
+    }
+
+    @Ignore
+    @Test
+    public void testMultipleDivisions() {
+        assertEquals(2, new WordProblemSolver().solve("What is -12 divided by 2 divided by -3?"));
+    }
+
+    @Ignore
+    @Test
+    public void testUnknownOperation() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("I'm sorry, I don't understand the question!");
+
+        new WordProblemSolver().solve("What is 52 cubed?");
+    }
+
+    @Ignore
+    @Test
+    public void testInvalidQuestionFormat() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("I'm sorry, I don't understand the question!");
+
+        // See https://en.wikipedia.org/wiki/President_of_the_United_States if you really need to know!
+        new WordProblemSolver().solve("Who is the President of the United States?");
+    }
+
+}