Merge pull request #1 from exercism/master

Merge

CONTRIBUTING.md

 * [Advanced: Complete Local Setup](#advanced-complete-local-setup)
   * [Tip: `gradle clean` before `exercism fetch`](#tip-gradle-clean-before-exercism-fetch)
 * [Adding a New Exercise](#adding-a-new-exercise)
+* [Updating the READMEs](#updating-the-readmes)
+* [Checking tests are up to date](#checking-tests-are-up-to-date)
 
 ## Overview
 
 
 Hi! Thanks for contributing to the Exercism Java track!
 
-Before opening your pull request, please review the track policies linked below and make sure your changes comply with them all. This helps us focus our review time on the more important aspects of your changes.
+Before opening your pull request, please review the [track policies](https://github.com/exercism/java/blob/master/POLICIES.md) and make sure your changes comply with them all. This helps us focus our review time on the more important aspects of your changes.
 
-- [Prefer instance methods](https://github.com/exercism/java/blob/master/POLICIES.md#prefer-instance-methods)
-- [Starter implementations](https://github.com/exercism/java/blob/master/POLICIES.md#starter-implementations)
-- [Ignore noninitial tests](https://github.com/exercism/java/blob/master/POLICIES.md#ignore-noninitial-tests)
-- [Multiple file submissions](https://github.com/exercism/java/blob/master/POLICIES.md#multiple-file-submissions)
+Also please only address one issue per pull request. This makes it easier for us to review it, and it means that if we request changes to the fix for one issue, it won't prevent to a fix for another issue being merged.
 
-One last thing to note before you get started. When you fork the repository and you want to sync your fork, you can perform a [`git rebase`](https://git-scm.com/docs/git-rebase). This is preferred over merging the changes because merging leads to a dirty commit history whereas performing a rebase adds in those changes without making extra commit messages. However, this is only preferred, so don't worry about it too much.
+It's perfectly fine to have more than one pull request open at a time. In that case it's important to keep the work for each pull request on a separate [branch](https://git-scm.com/book/en/v2/Git-Branching-Branches-in-a-Nutshell) to prevent unrelated commits being added to your pull request. This is good practice to do always, even if you only have one pull request open.
+
+One last thing to note before you get started. When you fork the repository and you want to [sync your fork](https://help.github.com/articles/syncing-a-fork/), you can perform a [`git rebase`](https://git-scm.com/docs/git-rebase). This is preferred over merging the changes because merging leads to a dirty commit history whereas performing a rebase adds in those changes without making extra commit messages. However, this is only preferred, so don't worry about it too much.
 
 ## Contributing With Minimal Setup
 
 
 There is a [general Exercism guide for porting an exercise to a new language](https://github.com/exercism/docs/blob/master/you-can-help/implement-an-exercise-from-specification.md).
 Please review this before porting an exercise to the Java track.
- 
+
 See [here](http://exercism.io/languages/java/todo) for a list of exercises that have yet to be implemented on the Java track and can therefore be ported to this track.
 Please make sure no one else has a pull request open to implement your chosen exercise before you start.
-Also please make a [dibs pull request](https://github.com/exercism/docs/blob/master/you-can-help/implement-an-exercise-from-specification.md#avoiding-duplicate-work) to make it clear to others that you are working on this exercise.
+
+It might also be a good idea to open a WIP pull request to make it clear to others that you are working on this exercise.
+This can just be a pull request with an empty commit that states which new exercise you're working on, with WIP (work in progress) in the title so that the maintainers know that it's not ready for review yet.
 
 The Java specific details you need to know about adding an exercise are:
 
 The `README.md` file can be generated using [configlet](https://github.com/exercism/configlet/releases).
 You can do this by:
 
-  1. Download configlet and put it somewhere in your PATH
+  1. Download configlet and put it somewhere in your [PATH](https://en.wikipedia.org/wiki/PATH_(variable))
 
   2. Clone [the problem-specifications repository](https://github.com/exercism/problem-specifications).
 
 The canonical data version can be found at the top of the canonical data file for that exercise.
 See other exercises, e.g. [acronym](https://github.com/exercism/java/tree/master/exercises/acronym/.meta), for an example `version` file.
 
+* Make sure you've followed the [track policies](https://github.com/exercism/java/blob/master/POLICIES.md), especially the ones for exercise added/updated.
+
 Hopefully that should be enough information to help you port an exercise to the Java track.
 Feel free to open an issue or post in the [Gitter exercism/java room](https://gitter.im/exercism/java) if you have any questions and we'll try and answer as soon as we can.
+
+## Updating the READMEs
+
+The `README.md` files are generated from the exercise descriptions in [problem specifications](https://github.com/exercism/problem-specifications/tree/master/exercises).
+They need to be regenerated regularly so that any changes to the descriptions in problem specifications propagate to our READMEs.
+This can be done using [configlet](https://github.com/exercism/configlet/releases):
+
+  1. Download configlet and put it somewhere in your [PATH](https://en.wikipedia.org/wiki/PATH_(variable))
+
+  2. Clone [the problem-specifications repository](https://github.com/exercism/problem-specifications).
+
+  3. Run `configlet generate . --spec-path path_to_problem_specifications` from the root of this repository.
+
+## Checking tests are up to date
+
+The tests for each exercise should follow the canonical data in [problem specifications](https://github.com/exercism/problem-specifications/tree/master/exercises) as closely as possible.
+The canonical data can change quite regularly, in which case the [canonical data version](https://github.com/exercism/problem-specifications#test-data-versioning) for that exercise will be updated.
+
+We keep track of which version of the canonical data each exercise implements in a version file, for example: https://github.com/exercism/java/blob/master/exercises/two-fer/.meta/version.
+Not all exercises have canonical data in problem specifications.
+For those that don't we don't add a version file.
+
+We have [a script](https://github.com/exercism/java/blob/master/scripts/canonical_data_check.sh) which can check if these version are up to date with the ones in problem specification.
+This script can be used to check if any version files, tests and reference implementations need updating.
+
+To run this script:
+
+  1. Clone [the problem-specifications repository](https://github.com/exercism/problem-specifications).
+
+  2. Run `./scripts/canonical_data_check.sh -t . -s --spec-path path_to_problem_specifications` from the root of this repository.

POLICIES.md

 
 | Track Event | Policies to review |
 |:------------|:-----------------|
-| Exercise added/updated | [Prefer instance methods](#prefer-instance-methods); [Avoid using final](#avoid-using-final); [Adhere to best practices](#adhere-to-best-practices); [Starter implementations](#starter-implementations); [Ignore noninitial tests](#ignore-noninitial-tests); [Multiple file submissions](#multiple-file-submissions); [Name test class after class under test](#name-test-class-after-class-under-test); [Add hint for the first exercises without starter implementation](#add-hint-for-the-first-exercises-without-starter-implementation)
+| Exercise added/updated | [Prefer instance methods](#prefer-instance-methods); [Avoid using final](#avoid-using-final); [Adhere to best practices](#adhere-to-best-practices); [Starter implementations](#starter-implementations); [Ignore noninitial tests](#ignore-noninitial-tests); [Multiple file submissions](#multiple-file-submissions); [Name test class after class under test](#name-test-class-after-class-under-test); [Add hint for the first exercises without starter implementation](#add-hint-for-the-first-exercises-without-starter-implementation); [Reference tutorial in the first exercises](#reference-tutorial-in-the-first-exercises); [Avoid returning null](#avoid-returning-null); [Use ExpectedException](#use-expectedexception)
 | Track rearranged | [Starter implementations](#starter-implementations); [Multiple file submissions](#multiple-file-submissions) |
 | New issue observed in track | [Good first patches](#good-first-patches) |
 | "Good first patch" issue completed | [Good first patches](#good-first-patches) |
 ### Adhere to best practices
 
 > Ensure that all Java code adheres to the best practices listed below:
-> - minimize the accessibility of classes and members ([Effective Java, item 13](http://jtechies.blogspot.com/2012/07/item-13-minimize-accessibility-of.html))
+> - Minimize the accessibility of classes and members ([Effective Java, item 13](http://jtechies.blogspot.com/2012/07/item-13-minimize-accessibility-of.html))
+> - Always use curly brackest in if statements. This makes your code easier to maintain and easier to read ([Oracle style guide, item 7.4](http://www.oracle.com/technetwork/java/javase/documentation/codeconventions-142311.html#431))
+```java
+// Please do this
+if (condition) {
+    doSomething();
+}
+
+// Please don't do this
+if (condition)
+    doSomething();
+
+if (condition) doSomething();
+```
+> - Always put opening curly bracket not on a newline ([Oracle style guide, item 7.2](http://www.oracle.com/technetwork/java/javase/documentation/codeconventions-142311.html#431))
+```java
+// Please do this
+for (int i = 0; i < 10; i++) {
+    ...
+}
+
+// Please don't do this
+for (int i = 0; i < 10; i++)
+{
+    ...
+}
+```
 
 ### Ignore noninitial tests
 
 
 ### Name test class after class under test
 
-> If you're testing a class called `SomeClassName` then your test class should be called `SomeClassNameTest`. 
+> If you're testing a class called `SomeClassName` then your test class should be called `SomeClassNameTest`.
 
 > The exception to this is if the tests are split into several test classes where each test class tests different functionality. In that case each class should be named `SomeClassNameFunctionalityTest` where `Functionality` is the name of the functionality to be tested in that class. See the [clock exercise](https://github.com/exercism/java/tree/master/exercises/clock) as an example.
 
 > We add the file to every exercise with difficulty 5 because the structure of the track means that we don't know which exercise will be the first one without starter implementation that a user will be faced with.
 
 References: [[1](https://github.com/exercism/java/issues/1075)]
+
+### Reference tutorial in the first exercises
+
+> The hello world exercise has an extensive tutorial on how to solve exercism exercises.
+> This tutorial would probably be useful to have as a reference when solving some of the other earlier exercises as well.
+> Therefore any exercise with difficulty less than 3 should have a hints.md file which references [the hello world tutorial](https://github.com/exercism/java/blob/master/exercises/hello-world/TUTORIAL.md).
+
+References: [[1](https://github.com/exercism/java/issues/1389)]
+
+### Avoid returning null
+
+> The [canonical data](https://github.com/exercism/problem-specifications/tree/master/exercises) for each exercise intentionally doesn't deal with error handling.
+> When an error has occured or a method can't return anything, the canonical data will just mark that as `"expected": null`.
+> This is because error handling varies from language to language, so the canonical data is leaving it up to each language track to decide how to deal with those situations.
+> It doesn't mean that the method needs to return `null`.
+
+> In Java it's considered bad practice to return `null`.
+> If you return `null` then the user of the method has to remember to check for `null` and they have to look at the implementation of the method to find out that this is necessary.
+
+> It's considered best practice to deal with errors and unexpected circumstances by throwing exceptions.
+> If you throw an exception then you force the user to deal with the problem.
+> You can either define your own exception (see [the triangle exercise](https://github.com/exercism/java/blob/master/exercises/triangle/.meta/src/reference/java/TriangleException.java) for an example) or use a predefined one (see [the collatz-conjecture exercise](https://github.com/exercism/java/blob/master/exercises/collatz-conjecture/src/test/java/CollatzCalculatorTest.java) for an example).
+
+> Another option is to use [Optionals](https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html).
+> This can be more suitable if the case you want to deal with isn't an exceptional occurence, but rather an expected scenario, e.g. a search method not finding what it was searching for.
+> See [the word-search exercise](https://github.com/exercism/java/blob/master/exercises/word-search/src/test/java/WordSearcherTest.java) for an example where `Optional` is used.
+
+References: [[1](https://www.codebyamir.com/blog/stop-returning-null-in-java)]
+
+### Use ExceptedException
+
+> Some exercises expect exceptions to be thrown in the tests.
+> The exercises on this track are all using JUnit's [`ExpectedException`](http://junit.org/junit4/javadoc/4.12/org/junit/rules/ExpectedException.html) `@Rule` feature to support that instead of `@Test(expected = SomeException.class)`.
+> `ExpectedException` is more powerful than using the `@Test` annotation, since with `ExpectedException` you can also inspect the exception's error message and other properties.
+> To be consistent, please use `ExpectedException` whenever you expect an exception to be thrown.
+
+> See [the triangle tests](https://github.com/exercism/java/blob/master/exercises/triangle/src/test/java/TriangleTest.java) for an example of where `ExpectedException` is used.
+
+References: [[1](https://github.com/junit-team/junit4/wiki/Exception-testing)]

config.json

         "loops",
         "strings"
       ],
-      "unlocked_by": "rna-transcription",
+      "unlocked_by": "two-fer",
       "uuid": "331073b3-bd1a-4868-b767-a64ce9fd9d97"
     },
     {
     {
       "core": false,
       "difficulty": 4,
+      "slug": "error-handling",
+      "topics": [
+        "exception_handling",
+        "optional_values"
+      ],
+      "unlocked_by": "triangle",
+      "uuid": "846ae792-7ca7-43e1-b523-bb1ec9fa08eb"
+    },
+    {
+      "core": false,
+      "difficulty": 4,
       "slug": "diamond",
       "topics": [
         "arrays",
       "uuid": "c3e89c7c-3a8a-4ddc-b653-9b0ff9e1d7d8"
     },
     {
+      "core": false,
+      "difficulty": 4,
+      "slug": "variable-length-quantity",
+      "topics": [
+        "bitwise_operations",
+        "conditionals",
+        "exception_handling",
+        "lists",
+        "loops",
+        "transforming"
+      ],
+      "unlocked_by": "secret-handshake",
+      "uuid": "d8a2c7ba-2040-4cfe-ab15-f90b3b61dd89"
+    },
+    {
       "core": true,
       "difficulty": 5,
       "slug": "flatten-array",
     {
       "core": false,
       "difficulty": 5,
-      "slug": "two-bucket",
+      "slug": "grep",
       "topics": [
-        "algorithms",
-        "loops",
-        "conditionals",
-        "mathematics"
+        "pattern_matching",
+        "strings",
+        "files",
+        "filtering",
+        "searching"
       ],
-      "unlocked_by": "triangle",
-      "uuid": "210bf628-b385-443b-8329-3483cc6e8d7e"
+      "unlocked_by": "robot-name",
+      "uuid": "9c15ddab-7b52-43d4-b38c-0bf635b363c3"
     },
     {
       "core": false,
     {
       "core": false,
       "difficulty": 7,
+      "slug": "two-bucket",
+      "topics": [
+        "algorithms",
+        "loops",
+        "conditionals",
+        "mathematics"
+      ],
+      "unlocked_by": "triangle",
+      "uuid": "210bf628-b385-443b-8329-3483cc6e8d7e"
+    },
+    {
+      "core": false,
+      "difficulty": 7,
       "slug": "anagram",
       "topics": [
         "arrays",
     },
     {
       "core": false,
+      "difficulty": 7,
+      "slug": "go-counting",
+      "topics": [
+        "algorithms",
+        "loops",
+        "conditionals",
+        "games"
+      ],
+      "unlocked_by": "scrabble-score",
+      "uuid": "2e760ae2-fadd-4d31-9639-c4554e2826e9"
+    },
+    {
+      "core": false,
+      "difficulty": 7,
+      "slug": "dominoes",
+      "topics": [
+        "games",
+        "algorithms",
+        "lists",
+        "exception_handling"
+      ],
+      "unlocked_by": "scrabble-score",
+      "uuid": "8e3cb20e-623b-4b4d-8a91-d1a51c0911b5"
+    },
+    {
+      "core": false,
       "difficulty": 8,
       "slug": "ocr-numbers",
       "topics": [

exercises/acronym/src/test/java/AcronymTest.java

 
     @Test
     public void basic() {
-        final String phrase = "Portable Network Graphics";
-        final String expected = "PNG";
+        String phrase = "Portable Network Graphics";
+        String expected = "PNG";
         assertEquals(expected, new Acronym(phrase).get());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void lowercaseWords() {
-        final String phrase = "Ruby on Rails";
-        final String expected = "ROR";
+        String phrase = "Ruby on Rails";
+        String expected = "ROR";
         assertEquals(expected, new Acronym(phrase).get());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void punctuation() {
-        final String phrase = "First In, First Out";
-        final String expected = "FIFO";
+        String phrase = "First In, First Out";
+        String expected = "FIFO";
         assertEquals(expected, new Acronym(phrase).get());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void NonAcronymAllCapsWord() {
-        final String phrase = "GNU Image Manipulation Program";
-        final String expected = "GIMP";
+        String phrase = "GNU Image Manipulation Program";
+        String expected = "GIMP";
         assertEquals(expected, new Acronym(phrase).get());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void punctuationWithoutWhitespace() {
-        final String phrase = "Complementary metal-oxide semiconductor";
-        final String expected = "CMOS";
+        String phrase = "Complementary metal-oxide semiconductor";
+        String expected = "CMOS";
         assertEquals(expected, new Acronym(phrase).get());
     }
 

exercises/all-your-base/.meta/version

-2.1.0
+2.3.0

exercises/all-your-base/src/test/java/BaseConverterTest.java

 
     @Test
     public void testSingleBitOneToDecimal() {
-        final BaseConverter baseConverter = new BaseConverter(2, new int[]{1});
+         BaseConverter baseConverter = new BaseConverter(2, new int[]{1});
 
-        final int[] expectedDigits = new int[]{1};
-        final int[] actualDigits = baseConverter.convertToBase(10);
+         int[] expectedDigits = new int[]{1};
+         int[] actualDigits = baseConverter.convertToBase(10);
 
         assertArrayEquals(
                 String.format(
     @Ignore("Remove to run test")
     @Test
     public void testBinaryToSingleDecimal() {
-        final BaseConverter baseConverter = new BaseConverter(2, new int[]{1, 0, 1});
+         BaseConverter baseConverter = new BaseConverter(2, new int[]{1, 0, 1});
 
-        final int[] expectedDigits = new int[]{5};
-        final int[] actualDigits = baseConverter.convertToBase(10);
+         int[] expectedDigits = new int[]{5};
+         int[] actualDigits = baseConverter.convertToBase(10);
 
         assertArrayEquals(
                 String.format(
     @Ignore("Remove to run test")
     @Test
     public void testSingleDecimalToBinary() {
-        final BaseConverter baseConverter = new BaseConverter(10, new int[]{5});
+         BaseConverter baseConverter = new BaseConverter(10, new int[]{5});
 
-        final int[] expectedDigits = new int[]{1, 0, 1};
-        final int[] actualDigits = baseConverter.convertToBase(2);
+         int[] expectedDigits = new int[]{1, 0, 1};
+         int[] actualDigits = baseConverter.convertToBase(2);
 
         assertArrayEquals(
                 String.format(
     @Ignore("Remove to run test")
     @Test
     public void testBinaryToMultipleDecimal() {
-        final BaseConverter baseConverter = new BaseConverter(2, new int[]{1, 0, 1, 0, 1, 0});
+         BaseConverter baseConverter = new BaseConverter(2, new int[]{1, 0, 1, 0, 1, 0});
 
-        final int[] expectedDigits = new int[]{4, 2};
-        final int[] actualDigits = baseConverter.convertToBase(10);
+         int[] expectedDigits = new int[]{4, 2};
+         int[] actualDigits = baseConverter.convertToBase(10);
 
         assertArrayEquals(
                 String.format(
     @Ignore("Remove to run test")
     @Test
     public void testDecimalToBinary() {
-        final BaseConverter baseConverter = new BaseConverter(10, new int[]{4, 2});
+         BaseConverter baseConverter = new BaseConverter(10, new int[]{4, 2});
 
-        final int[] expectedDigits = new int[]{1, 0, 1, 0, 1, 0};
-        final int[] actualDigits = baseConverter.convertToBase(2);
+         int[] expectedDigits = new int[]{1, 0, 1, 0, 1, 0};
+         int[] actualDigits = baseConverter.convertToBase(2);
 
         assertArrayEquals(
                 String.format(
     @Ignore("Remove to run test")
     @Test
     public void testTrinaryToHexadecimal() {
-        final BaseConverter baseConverter = new BaseConverter(3, new int[]{1, 1, 2, 0});
+         BaseConverter baseConverter = new BaseConverter(3, new int[]{1, 1, 2, 0});
 
-        final int[] expectedDigits = new int[]{2, 10};
-        final int[] actualDigits = baseConverter.convertToBase(16);
+         int[] expectedDigits = new int[]{2, 10};
+         int[] actualDigits = baseConverter.convertToBase(16);
 
         assertArrayEquals(
                 String.format(
     @Ignore("Remove to run test")
     @Test
     public void testHexadecimalToTrinary() {
-        final BaseConverter baseConverter = new BaseConverter(16, new int[]{2, 10});
+         BaseConverter baseConverter = new BaseConverter(16, new int[]{2, 10});
 
-        final int[] expectedDigits = new int[]{1, 1, 2, 0};
-        final int[] actualDigits = baseConverter.convertToBase(3);
+         int[] expectedDigits = new int[]{1, 1, 2, 0};
+         int[] actualDigits = baseConverter.convertToBase(3);
 
         assertArrayEquals(
                 String.format(
     @Ignore("Remove to run test")
     @Test
     public void test15BitInteger() {
-        final BaseConverter baseConverter = new BaseConverter(97, new int[]{3, 46, 60});
+         BaseConverter baseConverter = new BaseConverter(97, new int[]{3, 46, 60});
 
-        final int[] expectedDigits = new int[]{6, 10, 45};
-        final int[] actualDigits = baseConverter.convertToBase(73);
+         int[] expectedDigits = new int[]{6, 10, 45};
+         int[] actualDigits = baseConverter.convertToBase(73);
 
         assertArrayEquals(
                 String.format(
     @Ignore("Remove to run test")
     @Test
     public void testEmptyDigits() {
-        final BaseConverter baseConverter = new BaseConverter(2, new int[]{});
+         BaseConverter baseConverter = new BaseConverter(2, new int[]{});
 
-        final int[] expectedDigits = new int[]{0};
-        final int[] actualDigits = baseConverter.convertToBase(10);
+         int[] expectedDigits = new int[]{0};
+         int[] actualDigits = baseConverter.convertToBase(10);
 
         assertArrayEquals(
             String.format(
     @Ignore("Remove to run test")
     @Test
     public void testSingleZero() {
-        final BaseConverter baseConverter = new BaseConverter(10, new int[]{0});
+         BaseConverter baseConverter = new BaseConverter(10, new int[]{0});
 
-        final int[] expectedDigits = new int[]{0};
-        final int[] actualDigits = baseConverter.convertToBase(2);
+         int[] expectedDigits = new int[]{0};
+         int[] actualDigits = baseConverter.convertToBase(2);
 
         assertArrayEquals(
                 String.format(
     @Ignore("Remove to run test")
     @Test
     public void testMultipleZeros() {
-        final BaseConverter baseConverter = new BaseConverter(10, new int[]{0, 0, 0});
+         BaseConverter baseConverter = new BaseConverter(10, new int[]{0, 0, 0});
 
-        final int[] expectedDigits = new int[]{0};
-        final int[] actualDigits = baseConverter.convertToBase(2);
+         int[] expectedDigits = new int[]{0};
+         int[] actualDigits = baseConverter.convertToBase(2);
 
         assertArrayEquals(
             String.format(
     @Ignore("Remove to run test")
     @Test
     public void testLeadingZeros() {
-        final BaseConverter baseConverter = new BaseConverter(7, new int[]{0, 6, 0});
+         BaseConverter baseConverter = new BaseConverter(7, new int[]{0, 6, 0});
 
-        final int[] expectedDigits = new int[]{4, 2};
-        final int[] actualDigits = baseConverter.convertToBase(10);
+         int[] expectedDigits = new int[]{4, 2};
+         int[] actualDigits = baseConverter.convertToBase(10);
 
         assertArrayEquals(
             String.format(
         expectedException.expect(IllegalArgumentException.class);
         expectedException.expectMessage("Bases must be at least 2.");
 
-        new BaseConverter(1, new int[]{});
+        new BaseConverter(1, new int[]{1});
     }
 
     @Ignore("Remove to run test")
     @Ignore("Remove to run test")
     @Test
     public void testSecondBaseIsOne() {
-        final BaseConverter baseConverter = new BaseConverter(2, new int[]{1, 0, 1, 0, 1, 0});
+         BaseConverter baseConverter = new BaseConverter(2, new int[]{1, 0, 1, 0, 1, 0});
 
         expectedException.expect(IllegalArgumentException.class);
         expectedException.expectMessage("Bases must be at least 2.");
     @Ignore("Remove to run test")
     @Test
     public void testSecondBaseIsZero() {
-        final BaseConverter baseConverter = new BaseConverter(10, new int[]{7});
+         BaseConverter baseConverter = new BaseConverter(10, new int[]{7});
 
         expectedException.expect(IllegalArgumentException.class);
         expectedException.expectMessage("Bases must be at least 2.");
     @Ignore("Remove to run test")
     @Test
     public void testSecondBaseIsNegative() {
-        final BaseConverter baseConverter = new BaseConverter(2, new int[]{1});
+         BaseConverter baseConverter = new BaseConverter(2, new int[]{1});
 
         expectedException.expect(IllegalArgumentException.class);
         expectedException.expectMessage("Bases must be at least 2.");

exercises/alphametics/.meta/version

+1.2.0

exercises/binary-search-tree/.meta/version

+1.0.0

exercises/binary-search-tree/src/test/java/BinarySearchTreeTest.java

         );
 
         List<Character> treeData = Collections.unmodifiableList(
-                Arrays.asList('4', '2', '6', '1', '3', '7', '5')
+                Arrays.asList('4', '2', '6', '1', '3', '5', '7')
         );
         treeData.forEach(binarySearchTree::insert);
 
     public void sortsSingleElement() {
         BinarySearchTree<String> binarySearchTree = new BinarySearchTree<>();
         List<String> expected = Collections.unmodifiableList(
-                Collections.singletonList("4")
+                Collections.singletonList("2")
         );
 
-        binarySearchTree.insert("4");
+        binarySearchTree.insert("2");
 
         List<String> actual = binarySearchTree.getAsSortedList();
         assertEquals(expected, actual);
     public void sortsCollectionOfTwoIfSecondInsertedIsSmallerThanFirst() {
         BinarySearchTree<Integer> binarySearchTree = new BinarySearchTree<>();
         List<Integer> expected = Collections.unmodifiableList(
-                Arrays.asList(2, 4)
+                Arrays.asList(1, 2)
         );
 
-        binarySearchTree.insert(4);
         binarySearchTree.insert(2);
+        binarySearchTree.insert(1);
 
         List<Integer> actual = binarySearchTree.getAsSortedList();
         assertEquals(expected, actual);
     }
+    
+    @Ignore("Remove to run test")
+    @Test
+    public void sortsCollectionOfTwoIfSecondNumberisSameAsFirst() {
+        BinarySearchTree<Character> binarySearchTree = new BinarySearchTree<>();
+        List<Character> expected = Collections.unmodifiableList(
+                Arrays.asList('2', '2')
+        );
+
+        binarySearchTree.insert('2');
+        binarySearchTree.insert('2');
+
+        List<Character> actual = binarySearchTree.getAsSortedList();
+        assertEquals(expected, actual);
+    }
 
     @Ignore("Remove to run test")
     @Test
     public void sortsCollectionOfTwoIfSecondInsertedIsBiggerThanFirst() {
         BinarySearchTree<Character> binarySearchTree = new BinarySearchTree<>();
         List<Character> expected = Collections.unmodifiableList(
-                Arrays.asList('4', '5')
+                Arrays.asList('2', '3')
         );
 
-        binarySearchTree.insert('4');
-        binarySearchTree.insert('5');
+        binarySearchTree.insert('2');
+        binarySearchTree.insert('3');
 
         List<Character> actual = binarySearchTree.getAsSortedList();
         assertEquals(expected, actual);
     public void iteratesOverComplexTree() {
         BinarySearchTree<String> binarySearchTree = new BinarySearchTree<>();
         List<String> expected = Collections.unmodifiableList(
-                Arrays.asList("1", "2", "3", "4", "5", "6", "7")
+                Arrays.asList("1", "2", "3", "5", "6", "7")
         );
 
         List<String> treeData = Collections.unmodifiableList(
-                Arrays.asList("4", "2", "1", "3", "6", "7", "5")
+                Arrays.asList("2", "1", "3", "6", "7", "5")
         );
         treeData.forEach(binarySearchTree::insert);
 

exercises/book-store/.meta/version

-1.2.0
+1.3.0

exercises/bowling/.meta/version

-1.1.0
+1.2.0

exercises/bowling/src/test/java/BowlingTest.java

 
         game.score();
     }
-    
+
     @Ignore("Remove to run test")
     @Test
     public void twoBonusRollsAfterAStrikeInTheLastFrameCanNotScoreMoreThan10Points() {
 
         assertEquals(26, game.score());
     }
-    
+
     @Ignore("Remove to run test")
     @Test
     public void theSecondBonusRollsAfterAStrikeInTheLastFrameCanNotBeAStrikeIfTheFirstOneIsNotAStrike() {
 
         game.score();
     }
-    
+
     @Ignore("Remove to run test")
     @Test
     public void secondBonusRollAfterAStrikeInTheLastFrameCanNotScoreMoreThan10Points() {
 
         game.score();
     }
-    
+
     @Ignore("Remove to run test")
     @Test
     public void anUnstartedGameCanNotBeScored() {
         game.score();
     }
 
-}
+    @Ignore("Remove to run test")
+    @Test
+    public void canNotRollAfterBonusRollForSpare() {
+        int[] rolls = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 3, 2, 2};
+
+        playGame(rolls);
+
+        expectedException.expect(IllegalStateException.class);
+        expectedException.expectMessage("Cannot roll after game is over");
+
+        game.score();
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void canNotRollAfterBonusRollForStrike() {
+        int[] rolls = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 3, 2, 2};
+
+        playGame(rolls);
+
+        expectedException.expect(IllegalStateException.class);
+        expectedException.expectMessage("Cannot roll after game is over");
+
+        game.score();
+    }
+}

exercises/bracket-push/src/test/java/BracketCheckerTest.java

 
     @Test
     public void testPairedSquareBrackets() {
-        final BracketChecker bracketChecker = new BracketChecker("[]");
+        BracketChecker bracketChecker = new BracketChecker("[]");
         assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testEmptyString() {
-        final BracketChecker bracketChecker = new BracketChecker("");
+        BracketChecker bracketChecker = new BracketChecker("");
         assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testUnpairedBrackets() {
-        final BracketChecker bracketChecker = new BracketChecker("[[");
+        BracketChecker bracketChecker = new BracketChecker("[[");
         assertFalse(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testIncorrectlyOrderedBrackets() {
-        final BracketChecker bracketChecker = new BracketChecker("}{");
+        BracketChecker bracketChecker = new BracketChecker("}{");
         assertFalse(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testSingleOpenBracketWithIncorrectClosingBracket() {
-        final BracketChecker bracketChecker = new BracketChecker("{]");
+        BracketChecker bracketChecker = new BracketChecker("{]");
         assertFalse(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testPairedBracketsWithWhitespace() {
-        final BracketChecker bracketChecker = new BracketChecker("{ }");
+        BracketChecker bracketChecker = new BracketChecker("{ }");
         assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testSimpleNestedBrackets() {
-        final BracketChecker bracketChecker = new BracketChecker("{[]}");
+        BracketChecker bracketChecker = new BracketChecker("{[]}");
         assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testSeveralPairedBrackets() {
-        final BracketChecker bracketChecker = new BracketChecker("{}[]");
+        BracketChecker bracketChecker = new BracketChecker("{}[]");
         assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testPairedAndNestedBrackets() {
-        final BracketChecker bracketChecker = new BracketChecker("([{}({}[])])");
+        BracketChecker bracketChecker = new BracketChecker("([{}({}[])])");
         assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testUnopenedClosingBracket() {
-        final BracketChecker bracketChecker = new BracketChecker("{[)][]}");
+        BracketChecker bracketChecker = new BracketChecker("{[)][]}");
         assertFalse(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testUnpairedAndNestedBracket() {
-        final BracketChecker bracketChecker = new BracketChecker("([{])");
+        BracketChecker bracketChecker = new BracketChecker("([{])");
         assertFalse(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testPairedAndIncorrectlyNestedBrackets() {
-        final BracketChecker bracketChecker = new BracketChecker("[({]})");
+        BracketChecker bracketChecker = new BracketChecker("[({]})");
         assertFalse(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testValidMathExpression() {
-        final BracketChecker bracketChecker = new BracketChecker("(((185 + 223.85) * 15) - 543)/2");
+        BracketChecker bracketChecker = new BracketChecker("(((185 + 223.85) * 15) - 543)/2");
         assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testValidComplexLaTeXExpression() {
-        final BracketChecker bracketChecker = new BracketChecker(
+        BracketChecker bracketChecker = new BracketChecker(
                 "\\left(\\begin{array}{cc} \\frac{1}{3} & x\\\\ \\mathrm{e}^{x} &... x^2 \\end{array}\\right)");
 
         assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());

exercises/change/.meta/version

-1.1.0
+1.2.0

exercises/circular-buffer/.meta/version

-1.0.1
+1.1.0

exercises/clock/.meta/version

-1.0.1
+2.2.1

exercises/collatz-conjecture/.meta/version

-1.1.1
+1.2.0

exercises/complex-numbers/.meta/version

-1.0.0
+1.3.0

exercises/complex-numbers/src/test/java/ComplexNumberTest.java

     // Tests
 
     @Test
+    public void testRealPartOfPurelyRealNumber() {
+        double expected = 1.0;
+        double actual = new ComplexNumber(1.0, 0).getReal();
+        assertDoublesEqual(expected, actual, "real");
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testRealPartOfPurelyImaginaryNumber() {
+        double expected = 0.0;
+        double actual = new ComplexNumber(0, 1.0).getReal();
+        assertDoublesEqual(expected, actual, "real");
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testRealPartOfNumberWithRealAndImaginaryParts() {
+        double expected = 1.0;
+        double actual = new ComplexNumber(1.0, 2.0).getReal();
+        assertDoublesEqual(expected, actual, "real");
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testImaginaryPartOfPurelyRealNumber() {
+        double expected = 0.0;
+        double actual = new ComplexNumber(1.0, 0).getImag();
+        assertDoublesEqual(expected, actual, "imaginary");
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testImaginaryPartOfPurelyImaginaryNumber() {
+        double expected = 1.0;
+        double actual = new ComplexNumber(0, 1.0).getImag();
+        assertDoublesEqual(expected, actual, "imaginary");
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testImaginaryPartOfNumberWithRealAndImaginaryParts() {
+        double expected = 2.0;
+        double actual = new ComplexNumber(1.0, 2.0).getImag();
+        assertDoublesEqual(expected, actual, "imaginary");
+    }
+
+    @Ignore("Remove to run test")
+    @Test
     public void testImaginaryUnitExhibitsDefiningProperty() {
         ComplexNumber expected = new ComplexNumber(-1.0, 0);
         ComplexNumber actual = new ComplexNumber(0, 1.0).times(new ComplexNumber(0, 1.0));
 
     @Ignore("Remove to run test")
     @Test
-    public void testRealPartOfPurelyRealNumber() {
-        double expected = 1.0;
-        double actual = new ComplexNumber(1.0, 0).getReal();
-        assertDoublesEqual(expected, actual, "real");
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void testRealPartOfPurelyImaginaryNumber() {
-        double expected = 0.0;
-        double actual = new ComplexNumber(0, 1.0).getReal();
-        assertDoublesEqual(expected, actual, "real");
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void testRealPartOfNumberWithRealAndImaginaryParts() {
-        double expected = 1.0;
-        double actual = new ComplexNumber(1.0, 2.0).getReal();
-        assertDoublesEqual(expected, actual, "real");
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void testImaginaryPartOfPurelyRealNumber() {
-        double expected = 0.0;
-        double actual = new ComplexNumber(1.0, 0).getImag();
-        assertDoublesEqual(expected, actual, "imaginary");
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void testImaginaryPartOfPurelyImaginaryNumber() {
-        double expected = 1.0;
-        double actual = new ComplexNumber(0, 1.0).getImag();
-        assertDoublesEqual(expected, actual, "imaginary");
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void testImaginaryPartOfNumberWithRealAndImaginaryParts() {
-        double expected = 2.0;
-        double actual = new ComplexNumber(1.0, 2.0).getImag();
-        assertDoublesEqual(expected, actual, "imaginary");
-    }
-
-    @Ignore("Remove to run test")
-    @Test
     public void testExponentialOfPurelyImaginaryNumber() {
         ComplexNumber expected = new ComplexNumber(-1.0, 0);
         ComplexNumber actual = new ComplexNumber(0, Math.PI).exponentialOf();
         assertComplexNumbersEqual(expected, actual);
     }
 
+    @Ignore("Remove to run test")
+    @Test
+    public void testExponentialOfNumberWithRealAndImaginaryParts() {
+        ComplexNumber expected = new ComplexNumber(-2.0, 0);
+        ComplexNumber actual = new ComplexNumber(Math.log(2.0), Math.PI).exponentialOf();
+        assertComplexNumbersEqual(expected, actual);
+    }
+
 }

exercises/crypto-square/.meta/version

-3.1.0
+3.2.0

exercises/crypto-square/README.md

 imtgdvsfearwermayoogoanouuiontnnlvtwttddesaohghnsseoau
 ```
 
-Output the encoded text in chunks.  Phrases that fill perfect rectangles
-`(r X c)` should be output `c` chunks of `r` length, separated by spaces.
-Phrases that do not fill perfect rectangles will have `n` empty spaces.
-Those spaces should be distributed evenly, added to the end of the last
-`n` chunks.
+Output the encoded text in chunks that fill perfect rectangles `(r X c)`,
+with `c` chunks of `r` length, separated by spaces. For phrases that are
+`n` characters short of the perfect rectangle, pad each of the last `n`
+chunks with a single trailing space.
 
 ```text
 imtgdvs fearwer mayoogo anouuio ntnnlvt wttddes aohghn  sseoau 

exercises/custom-set/.meta/version

-1.1.0
+1.3.0

exercises/difference-of-squares/src/test/java/DifferenceOfSquaresCalculatorTest.java

 
     @Test
     public void testSquareOfSumUpToOne() {
-        final int expected = 1;
-        final int actual = calculator.computeSquareOfSumTo(1);
+        int expected = 1;
+        int actual = calculator.computeSquareOfSumTo(1);
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testSquareOfSumUpToFive() {
-        final int expected = 225;
-        final int actual = calculator.computeSquareOfSumTo(5);
+        int expected = 225;
+        int actual = calculator.computeSquareOfSumTo(5);
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testSquareOfSumUpToHundred() {
-        final int expected = 25502500;
-        final int actual = calculator.computeSquareOfSumTo(100);
+        int expected = 25502500;
+        int actual = calculator.computeSquareOfSumTo(100);
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testSumOfSquaresUpToOne() {
-        final int expected = 1;
-        final int actual = calculator.computeSumOfSquaresTo(1);
+        int expected = 1;
+        int actual = calculator.computeSumOfSquaresTo(1);
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testSumOfSquaresUpToFive() {
-        final int expected = 55;
-        final int actual = calculator.computeSumOfSquaresTo(5);
+        int expected = 55;
+        int actual = calculator.computeSumOfSquaresTo(5);
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testSumOfSquaresUpToHundred() {
-        final int expected = 338350;
-        final int actual = calculator.computeSumOfSquaresTo(100);
+        int expected = 338350;
+        int actual = calculator.computeSumOfSquaresTo(100);
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testDifferenceOfSquaresUpToOne() {
-        final int expected = 0;
-        final int actual = calculator.computeDifferenceOfSquares(1);
+        int expected = 0;
+        int actual = calculator.computeDifferenceOfSquares(1);
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testDifferenceOfSquaresUpToFive() {
-        final int expected = 170;
-        final int actual = calculator.computeDifferenceOfSquares(5);
+        int expected = 170;
+        int actual = calculator.computeDifferenceOfSquares(5);
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testDifferenceOfSquaresUpToHundred() {
-        final int expected = 25164150;
-        final int actual = calculator.computeDifferenceOfSquares(100);
+        int expected = 25164150;
+        int actual = calculator.computeDifferenceOfSquares(100);
         assertEquals(expected, actual);
     }
 

exercises/dominoes/.meta/src/reference/java/ChainNotFoundException.java

+class ChainNotFoundException extends Exception {
+	public ChainNotFoundException(String message) {
+		super(message);
+	}
+}

exercises/dominoes/.meta/src/reference/java/Domino.java

+import java.util.Objects;
+
+class Domino {
+    private int left;
+    private int right;
+    Domino(int left, int right) {
+        this.left = left;
+        this.right = right;
+    }
+    
+    int getLeft() {
+    	return this.left;
+    }
+    
+    int getRight() {
+    	return this.right;
+    }
+    
+    @Override
+    public boolean equals(Object o) {
+    	Domino otherDomino = (Domino) o;
+    	return (this.getLeft() == otherDomino.getLeft() && this.getRight() == otherDomino.getRight()) ||
+    			(this.getLeft() == otherDomino.getRight() && this.getRight() == otherDomino.getLeft());
+    }
+    
+    @Override
+    public int hashCode() {
+    	return Objects.hash(left, right);
+    }
+}

exercises/dominoes/.meta/src/reference/java/Dominoes.java

+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+class Dominoes {
+	
+	List<Domino> formChain(List<Domino> inputDominoes) throws ChainNotFoundException {
+		if (inputDominoes.size() == 0) {
+			return inputDominoes;
+		} else {
+			return formPartialChain(new ArrayList<Domino>(), inputDominoes);
+		}
+	}
+	
+	private boolean isValidChain(ArrayList<Domino> chain) {
+		return isValidPartialChain(chain) && (chain.get(0).getLeft() == chain.get(chain.size() - 1).getRight());
+	}
+	
+	private boolean isValidPartialChain(ArrayList<Domino> chain) {
+		for (int i = 0; i < chain.size() - 1; i++) {
+			if (chain.get(i).getRight() != chain.get(i+1).getLeft()) {
+				return false;
+			}
+		}
+		
+		return true;
+	}
+	
+	ArrayList<Domino> formPartialChain(ArrayList<Domino> current, List<Domino> remaining) throws ChainNotFoundException {
+		if (remaining.size() == 0) {
+			if (isValidChain(current)) {
+				return current;
+			} else {
+				throw new ChainNotFoundException("No domino chain found.");
+			}
+		}
+		
+		for (int i = 0; i < remaining.size(); i++) {
+			ArrayList<Domino> newRemaining = new ArrayList<Domino>(remaining);
+			newRemaining.remove(i);
+			
+			ArrayList<Domino> newChainA = new ArrayList<Domino>(current);
+			newChainA.add(remaining.get(i));
+			
+			ArrayList<Domino> newChainB = new ArrayList<Domino>(current);
+			newChainB.add(new Domino(remaining.get(i).getRight(), remaining.get(i).getLeft()));
+			
+			if (isValidPartialChain(newChainA)) {
+				try {
+					return formPartialChain(newChainA, newRemaining);
+				} catch (ChainNotFoundException e) {
+					//This path does not have a valid chain
+				}
+			}
+			
+			if (isValidPartialChain(newChainB)) {
+				try {
+					return formPartialChain(newChainB, newRemaining);
+				} catch (ChainNotFoundException e) {
+					//This path doesn't have a valid chain
+				}
+			}
+		}
+		
+		throw new ChainNotFoundException("No domino chain found.");
+	}
+}

exercises/dominoes/.meta/version

+2.1.0
+

exercises/dominoes/README.md

+# Dominoes
+
+Make a chain of dominoes.
+
+Compute a way to order a given set of dominoes in such a way that they form a
+correct domino chain (the dots on one half of a stone match the dots on the
+neighbouring half of an adjacent stone) and that dots on the halfs of the stones
+which don't have a neighbour (the first and last stone) match each other.
+
+For example given the stones `[2|1]`, `[2|3]` and `[1|3]` you should compute something
+like `[1|2] [2|3] [3|1]` or `[3|2] [2|1] [1|3]` or `[1|3] [3|2] [2|1]` etc, where the first and last numbers are the same.
+
+For stones `[1|2]`, `[4|1]` and `[2|3]` the resulting chain is not valid: `[4|1] [1|2] [2|3]`'s first and last numbers are not the same. 4 != 3
+
+Some test cases may use duplicate stones in a chain solution, assume that multiple Domino sets are being used.
+
+# 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/dominoes/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/dominoes/src/main/java/ChainNotFoundException.java

+class ChainNotFoundException extends Exception {
+	public ChainNotFoundException(String message) {
+		super(message);
+	}
+}

exercises/dominoes/src/main/java/Domino.java

+import java.util.Objects;
+
+class Domino {
+    private int left;
+    private int right;
+    Domino(int left, int right) {
+        this.left = left;
+        this.right = right;
+    }
+    
+    int getLeft() {
+    	return this.left;
+    }
+    
+    int getRight() {
+    	return this.right;
+    }
+    
+    @Override
+    public boolean equals(Object o) {
+    	Domino otherDomino = (Domino) o;
+    	return (this.getLeft() == otherDomino.getLeft() && this.getRight() == otherDomino.getRight()) ||
+    			(this.getLeft() == otherDomino.getRight() && this.getRight() == otherDomino.getLeft());
+    }
+    
+    @Override
+    public int hashCode() {
+    	return Objects.hash(left, right);
+    }
+}

exercises/dominoes/src/test/java/DominoesTest.java

+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+import org.junit.Rule;
+import org.junit.rules.ExpectedException;
+
+public class DominoesTest {
+	
+	@Rule
+	public ExpectedException expectedException = ExpectedException.none(); 
+	
+	@Test
+	public void emtpyInputEmptyOutputTest() throws ChainNotFoundException {
+		Dominoes dominoes = new Dominoes();
+		
+		List<Domino> dominoesList = new ArrayList<>();
+		
+		List<Domino> chain = dominoes.formChain(dominoesList);
+		
+		assertEquals("The output list should be empty.", 0, chain.size());
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void singletonInputSingletonOutput() throws ChainNotFoundException {
+		Dominoes dominoes = new Dominoes();
+		
+		Domino[] dominoesArray = {new Domino(1, 1)};
+		List<Domino> dominoesList = Arrays.asList(dominoesArray);
+		
+		List<Domino> chain = dominoes.formChain(dominoesList);
+		
+		assertValidChain(dominoesList, chain);
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void singletonCantBeChainedTest() throws ChainNotFoundException {
+		Dominoes dominoes = new Dominoes();
+		
+		Domino[] dominoesArray = {new Domino(1, 2)};
+		List<Domino> dominoesList = Arrays.asList(dominoesArray);
+		
+		expectedException.expect(ChainNotFoundException.class);
+		expectedException.expectMessage("No domino chain found.");
+		
+		dominoes.formChain(dominoesList);
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void threeElementsTest() throws ChainNotFoundException {
+		Dominoes dominoes = new Dominoes();
+		
+		Domino[] dominoesArray = {new Domino(1, 2), new Domino(3, 1), new Domino(2, 3)};
+		List<Domino> dominoesList = Arrays.asList(dominoesArray);
+		
+		List<Domino> chain = dominoes.formChain(dominoesList);
+		
+		assertValidChain(dominoesList, chain);
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void canReverseDominoesTest() throws ChainNotFoundException {
+		Dominoes dominoes = new Dominoes();
+		
+		Domino[] dominoesArray = {new Domino(1, 2), new Domino(1, 3), new Domino(2, 3)};
+		List<Domino> dominoesList = Arrays.asList(dominoesArray);
+		
+		List<Domino> chain = dominoes.formChain(dominoesList);
+		
+		assertValidChain(dominoesList, chain);
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void cantBeChainedTest() throws ChainNotFoundException {
+		Dominoes dominoes = new Dominoes();
+		
+		Domino[] dominoesArray = {new Domino(1, 2), new Domino(4, 1), new Domino(2, 3)};
+		List<Domino> dominoesList = Arrays.asList(dominoesArray);
+		
+		expectedException.expect(ChainNotFoundException.class);
+		expectedException.expectMessage("No domino chain found.");
+		
+		dominoes.formChain(dominoesList);
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void disconnectedSimpleTest() throws ChainNotFoundException {
+		Dominoes dominoes = new Dominoes();
+		
+		Domino[] dominoesArray = {new Domino(1, 1), new Domino(2, 2)};
+		List<Domino> dominoesList = Arrays.asList(dominoesArray);
+		
+		expectedException.expect(ChainNotFoundException.class);
+		expectedException.expectMessage("No domino chain found.");
+		
+		dominoes.formChain(dominoesList);
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void disconnectedDoubleLoopTest() throws ChainNotFoundException {
+		Dominoes dominoes = new Dominoes();
+		
+		Domino[] dominoesArray = {new Domino(1, 2), new Domino(2, 1), new Domino(3, 4), new Domino(4, 3)};
+		List<Domino> dominoesList = Arrays.asList(dominoesArray);
+		
+		expectedException.expect(ChainNotFoundException.class);
+		expectedException.expectMessage("No domino chain found.");
+		
+		dominoes.formChain(dominoesList);
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void disconnectedSingleIsolatedTest() throws ChainNotFoundException {
+		Dominoes dominoes = new Dominoes();
+		
+		Domino[] dominoesArray = {new Domino(1, 2), new Domino(2, 3), new Domino(3, 1), new Domino(4, 4)};
+		List<Domino> dominoesList = Arrays.asList(dominoesArray);
+		
+		expectedException.expect(ChainNotFoundException.class);
+		expectedException.expectMessage("No domino chain found.");
+		
+		dominoes.formChain(dominoesList);
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void needBacktrackTest() throws ChainNotFoundException {
+		Dominoes dominoes = new Dominoes();
+		
+		Domino[] dominoesArray = {new Domino(1, 2), new Domino(2, 3), new Domino(3, 1), new Domino(2, 4), new Domino(4, 2)};
+		List<Domino> dominoesList = Arrays.asList(dominoesArray);
+		
+		List<Domino> chain = dominoes.formChain(dominoesList);
+		
+		assertValidChain(dominoesList, chain);
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void separateLoopsTest() throws ChainNotFoundException {
+		Dominoes dominoes = new Dominoes();
+		
+		Domino[] dominoesArray = {new Domino(1, 2), new Domino(2, 3), new Domino(3, 1),
+				new Domino(1, 1), new Domino(2, 2), new Domino(3, 3)};
+		List<Domino> dominoesList = Arrays.asList(dominoesArray);
+		
+		List<Domino> chain = dominoes.formChain(dominoesList);
+		
+		assertValidChain(dominoesList, chain);
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void nineElementsTest() throws ChainNotFoundException {
+		Dominoes dominoes = new Dominoes();
+		Domino[] dominoesArray = {new Domino(1, 2), new Domino(5, 3), new Domino(3, 1),
+				new Domino(1, 2), new Domino(2, 4), new Domino(1, 6),
+				new Domino(2, 3), new Domino(3, 4), new Domino(5, 6)};
+		List<Domino> dominoesList = Arrays.asList(dominoesArray);
+		
+		List<Domino> chain = dominoes.formChain(dominoesList);
+		
+		assertValidChain(dominoesList, chain);
+	}
+	
+	private void assertValidChain(List<Domino> inputDominoes, List<Domino> outputDominoes) {
+		assertSameDominoes(inputDominoes, outputDominoes);
+		assertEndDominoesMatch(outputDominoes);
+		assertConsecutiveDominoes(outputDominoes);
+	}
+	
+	private void assertEndDominoesMatch(List<Domino> outputDominoes) {
+		int leftValueOfFirstDomino = outputDominoes.get(0).getLeft();
+		int rightValueOfLastDomino = outputDominoes.get(outputDominoes.size() - 1).getRight();
+		String errorMessage = "The left value of the first domino ("
+		    + leftValueOfFirstDomino
+		    + ") needs to match the right value of the last domino ("
+		    + rightValueOfLastDomino
+		    + ").";
+		
+		assertEquals(errorMessage, leftValueOfFirstDomino, rightValueOfLastDomino);
+	}
+	
+	private void assertSameDominoes(List<Domino> inputDominoes, List<Domino> outputDominoes) {
+		String errorMessage = "The number of dominoes in the input list (" + inputDominoes.size()
+				+ ") needs to match the number of dominoes in the output chain (" + outputDominoes.size() + ")";
+		
+		assertEquals(errorMessage, inputDominoes.size(), outputDominoes.size());
+		
+		for (Domino domino : inputDominoes) {
+			int inputFrequency = Collections.frequency(inputDominoes, domino);
+			int outputFrequency = Collections.frequency(outputDominoes, domino);
+			
+			String frequencyErrorMessage = "The frequency of domino (" + domino.getLeft() + ", " + domino.getRight() + ")"
+					+ " in the input is (" + inputFrequency + "), but (" + outputFrequency + ") in the output.";
+					
+			assertEquals(frequencyErrorMessage, inputFrequency, outputFrequency);
+		}
+	}
+	
+	private void assertConsecutiveDominoes(List<Domino> dominoes) {
+		for (int i = 0; i < dominoes.size() - 1; i++) {
+			
+			int rightValueOfIthDomino = dominoes.get(i).getRight();
+			int leftValueOfNextDomino = dominoes.get(i+1).getLeft();
+			String errorMessage = "The right value of domino number " + i + " ("
+			    + rightValueOfIthDomino
+			    + ") needs to match the left value of domino number " + (i+1) + " ("
+			    + leftValueOfNextDomino
+			    + ").";
+			
+			assertEquals(errorMessage, dominoes.get(i).getRight(), dominoes.get(i+1).getLeft());
+		}
+	}
+}

exercises/error-handling/.meta/hints.md

+This exercise requires you to handle exceptions. An [exception](https://docs.oracle.com/javase/tutorial/essential/exceptions/definition.html) is an event, which occurs during the execution of a program, that disrupts the normal flow of the program's instructions.
+
+In Java, there are two types of exceptions: checked and unchecked exceptions.
+
+- [Checked vs Unchecked Exceptions in Java](https://www.geeksforgeeks.org/checked-vs-unchecked-exceptions-in-java/)
+
+- [Unchecked Exceptions — The Controversy](https://docs.oracle.com/javase/tutorial/essential/exceptions/runtime.html)
+
+## Checked exceptions
+
+Checked exceptions are the exceptions that are checked at [compile time](https://en.wikipedia.org/wiki/Compile_time).
+
+### Practical implications
+
+You have to declare them in the [method signature](https://docs.oracle.com/javase/tutorial/java/javaOO/methods.html) of any method that can [throw](https://docs.oracle.com/javase/tutorial/essential/exceptions/throwing.html) a checked exception and handle or rethrow them when calling any method that can throw a checked exception.
+
+This is because checked exceptions are meant to be handled at runtime, i.e. they are errors you can recover from.
+
+### Examples of where they are used
+
+They're often used when a method can't return any valid result, for example a search method which hasn't found the item it was searching for.
+
+It's an alternative to returning null or a error code. A checked exception is better than those alternatives because it forces the user of the method to consider the error case.
+
+## Unchecked exceptions
+
+Unchecked exceptions are the exceptions that are not checked at [compile time](https://en.wikipedia.org/wiki/Compile_time).
+
+### Practical implications
+
+You don't have to declare them in the [method signature](https://docs.oracle.com/javase/tutorial/java/javaOO/methods.html) of methods that can [throw](https://docs.oracle.com/javase/tutorial/essential/exceptions/throwing.html) an unchecked exception and handle or rethrow them when calling any method that can throw an unchecked exception.
+
+### Examples of where they are used
+
+Unchecked exceptions are mean to be used for any error than can't be handled at runtime, e.g. running out of memory.

exercises/error-handling/.meta/src/reference/java/CustomCheckedException.java

+class CustomCheckedException extends Exception {
+
+    CustomCheckedException() {
+        super();
+    }
+
+    CustomCheckedException(String message) {
+        super(message);
+    }
+
+}

exercises/error-handling/.meta/src/reference/java/CustomUncheckedException.java

+class CustomUncheckedException extends RuntimeException {
+
+    CustomUncheckedException() {
+        super();
+    }
+
+    CustomUncheckedException(String message) {
+        super(message);
+    }
+
+}

exercises/error-handling/.meta/src/reference/java/ErrorHandling.java

+import java.io.IOException;
+import java.util.Optional;
+
+class ErrorHandling {
+
+    void handleErrorByThrowingIllegalArgumentException() {
+        throw new IllegalArgumentException();
+    }
+
+    void handleErrorByThrowingIllegalArgumentExceptionWithDetailMessage(String message) {
+        throw new IllegalArgumentException(message);
+    }
+
+    void handleErrorByThrowingAnyCheckedException() throws IOException {
+        throw new IOException();
+    }
+
+    void handleErrorByThrowingAnyCheckedExceptionWithDetailMessage(String message) throws IOException {
+        throw new IOException(message);
+    }
+
+    void handleErrorByThrowingAnyUncheckedException() {
+        throw new NullPointerException();
+    }
+
+    void handleErrorByThrowingAnyUncheckedExceptionWithDetailMessage(String message) {
+        throw new NullPointerException(message);
+    }
+
+    void handleErrorByThrowingCustomCheckedException() throws CustomCheckedException {
+        throw new CustomCheckedException();
+    }
+
+    void handleErrorByThrowingCustomCheckedExceptionWithDetailMessage(String message) throws CustomCheckedException {
+        throw new CustomCheckedException(message);
+    }
+
+    void handleErrorByThrowingCustomUncheckedException() {
+        throw new CustomUncheckedException();
+    }
+
+    void handleErrorByThrowingCustomUncheckedExceptionWithDetailMessage(String message) {
+        throw new CustomUncheckedException(message);
+    }
+
+    Optional<Integer> handleErrorByReturningOptionalInstance(String integer) {
+        if (tryParseInt(integer)) {
+            return Optional.of(Integer.parseInt(integer));
+        } else {
+            return Optional.empty();
+        }
+    }
+
+    private boolean tryParseInt(String integer) {
+        try {
+            Integer.parseInt(integer);
+            return true;
+        } catch (NumberFormatException e) {
+            return false;
+        }
+    }
+
+}

exercises/error-handling/README.md

+# Error Handling
+
+Implement various kinds of error handling and resource management.
+
+An important point of programming is how to handle errors and close
+resources even if errors occur.
+
+This exercise requires you to handle various errors. Because error handling
+is rather programming language specific you'll have to refer to the tests
+for your track to see what's exactly required.
+
+# Java Tips
+
+This exercise requires you to handle exceptions. An [exception](https://docs.oracle.com/javase/tutorial/essential/exceptions/definition.html) is an event, which occurs during the execution of a program, that disrupts the normal flow of the program's instructions.
+
+In Java, there are two types of exceptions: checked and unchecked exceptions.
+
+- [Checked vs Unchecked Exceptions in Java](https://www.geeksforgeeks.org/checked-vs-unchecked-exceptions-in-java/)
+
+- [Unchecked Exceptions — The Controversy](https://docs.oracle.com/javase/tutorial/essential/exceptions/runtime.html)
+
+## Checked exceptions
+
+Checked exceptions are the exceptions that are checked at [compile time](https://en.wikipedia.org/wiki/Compile_time).
+
+### Practical implications
+
+You have to declare them in the [method signature](https://docs.oracle.com/javase/tutorial/java/javaOO/methods.html) of any method that can [throw](https://docs.oracle.com/javase/tutorial/essential/exceptions/throwing.html) a checked exception and handle or rethrow them when calling any method that can throw a checked exception.
+
+This is because checked exceptions are meant to be handled at runtime, i.e. they are errors you can recover from.
+
+### Examples of where they are used
+
+They're often used when a method can't return any valid result, for example a search method which hasn't found the item it was searching for.
+
+It's an alternative to returning null or a error code. A checked exception is better than those alternatives because it forces the user of the method to consider the error case.
+
+## Unchecked exceptions
+
+Unchecked exceptions are the exceptions that are not checked at [compile time](https://en.wikipedia.org/wiki/Compile_time).
+
+### Practical implications
+
+You don't have to declare them in the [method signature](https://docs.oracle.com/javase/tutorial/java/javaOO/methods.html) of methods that can [throw](https://docs.oracle.com/javase/tutorial/essential/exceptions/throwing.html) an unchecked exception and handle or rethrow them when calling any method that can throw an unchecked exception.
+
+### Examples of where they are used
+
+Unchecked exceptions are mean to be used for any error than can't be handled at runtime, e.g. running out of memory.
+
+# 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/error-handling/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/error-handling/src/main/java/CustomCheckedException.java

+class CustomCheckedException extends Exception {
+
+    CustomCheckedException() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    CustomCheckedException(String message) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+}

exercises/error-handling/src/main/java/CustomUncheckedException.java

+class CustomUncheckedException extends RuntimeException {
+
+    CustomUncheckedException() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    CustomUncheckedException(String message) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+}

exercises/error-handling/src/main/java/ErrorHandling.java

+import java.util.Optional;
+
+class ErrorHandling {
+
+    void handleErrorByThrowingIllegalArgumentException() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    void handleErrorByThrowingIllegalArgumentExceptionWithDetailMessage(String message) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    void handleErrorByThrowingAnyCheckedException() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    void handleErrorByThrowingAnyCheckedExceptionWithDetailMessage(String message) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    void handleErrorByThrowingAnyUncheckedException() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    void handleErrorByThrowingAnyUncheckedExceptionWithDetailMessage(String message) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    void handleErrorByThrowingCustomCheckedException() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    void handleErrorByThrowingCustomCheckedExceptionWithDetailMessage(String message) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    void handleErrorByThrowingCustomUncheckedException() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    void handleErrorByThrowingCustomUncheckedExceptionWithDetailMessage(String message) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    Optional<Integer> handleErrorByReturningOptionalInstance(String integer) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+}

exercises/error-handling/src/test/java/ErrorHandlingTest.java

+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Optional;
+
+public class ErrorHandlingTest {
+
+    private ErrorHandling errorHandling;
+
+    @Rule
+    public ExpectedException thrown = ExpectedException.none();
+
+    @Before
+    public void setUp() {
+        errorHandling = new ErrorHandling();
+    }
+
+    @Test
+    public void testThrowIllegalArgumentException() {
+        thrown.expect(IllegalArgumentException.class);
+        errorHandling.handleErrorByThrowingIllegalArgumentException();
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testThrowIllegalArgumentExceptionWithDetailMessage() {
+        thrown.expect(IllegalArgumentException.class);
+        thrown.expectMessage("This is the detail message.");
+        errorHandling.handleErrorByThrowingIllegalArgumentExceptionWithDetailMessage("This is the detail message.");
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testThrowAnyCheckedException() {
+        try {
+            errorHandling.handleErrorByThrowingAnyCheckedException();
+        } catch (Exception e) {
+            assertFalse(e instanceof RuntimeException);
+        }
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testThrowAnyCheckedExceptionWithDetailMessage() {
+        try {
+            errorHandling.handleErrorByThrowingAnyCheckedExceptionWithDetailMessage("This is the detail message.");
+        } catch (Exception e) {
+            assertFalse(e instanceof RuntimeException);
+            assertEquals("This is the detail message.", e.getMessage());
+        }
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testThrowAnyUncheckedException() {
+        thrown.expect(RuntimeException.class);
+        errorHandling.handleErrorByThrowingAnyUncheckedException();
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testThrowAnyUncheckedExceptionWithDetailMessage() {
+        thrown.expect(RuntimeException.class);
+        thrown.expectMessage("This is the detail message.");
+        errorHandling.handleErrorByThrowingAnyUncheckedExceptionWithDetailMessage("This is the detail message.");
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testThrowCustomCheckedException() throws CustomCheckedException {
+        thrown.expect(CustomCheckedException.class);
+        errorHandling.handleErrorByThrowingCustomCheckedException();
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testThrowCustomCheckedExceptionWithDetailMessage() throws CustomCheckedException {
+        thrown.expect(CustomCheckedException.class);
+        thrown.expectMessage("This is the detail message.");
+        errorHandling.handleErrorByThrowingCustomCheckedExceptionWithDetailMessage("This is the detail message.");
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testThrowCustomUncheckedException() {
+        thrown.expect(CustomUncheckedException.class);
+        errorHandling.handleErrorByThrowingCustomUncheckedException();
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testThrowCustomUncheckedExceptionWithDetailMessage() {
+        thrown.expect(CustomUncheckedException.class);
+        thrown.expectMessage("This is the detail message.");
+        errorHandling.handleErrorByThrowingCustomUncheckedExceptionWithDetailMessage("This is the detail message.");
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testReturnOptionalInstance() {
+        Optional<Integer> successfulResult = errorHandling.handleErrorByReturningOptionalInstance("1");
+        assertTrue(successfulResult.isPresent());
+        assertEquals(1, (int) successfulResult.get());
+
+        Optional<Integer> failureResult = errorHandling.handleErrorByReturningOptionalInstance("a");
+        assertFalse(failureResult.isPresent());
+    }
+
+}

exercises/flatten-array/.meta/version

-1.1.0
+1.2.0

exercises/forth/.meta/version

-1.4.0
+1.5.0

exercises/go-counting/.meta/src/reference/java/GoCounting.java

+import java.awt.Point;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Set;
+
+class GoCounting {
+	private Player[][] board;
+	
+	GoCounting (String boardString) {
+		String[] lines = boardString.split("\n");
+		
+		board = new Player[lines[0].length()][lines.length];
+		
+		for (int i = 0; i < lines.length; i++) {
+			for (int j = 0; j < lines[i].length(); j++) {
+				if (lines[i].charAt(j) == 'B') {
+					board[j][i] = Player.BLACK;
+				} else if (lines[i].charAt(j) == 'W') {
+					board[j][i] = Player.WHITE;
+				} else {
+					board[j][i] = Player.NONE;
+				}
+			}
+		}
+	}
+	
+	private ArrayList<Point> getAdjacent(Point p) {
+		ArrayList<Point> adjacent = new ArrayList<>();
+		if (p.x > 0) {
+			adjacent.add(new Point(p.x - 1, p.y));
+		}
+		if (p.x < board.length - 1) {
+			adjacent.add(new Point(p.x + 1, p.y)); 
+		}
+		if (p.y > 0) {
+			adjacent.add(new Point(p.x, p.y - 1));
+		}
+		if (p.y < board[0].length - 1) {
+			adjacent.add(new Point(p.x, p.y + 1));
+		}
+		return adjacent;
+	}
+	
+	Player getTerritoryOwner(int x, int y) {
+		
+		if (x < 0 || x >= board.length || y < 0 || y >= board[0].length) {
+			throw new IllegalArgumentException("Invalid coordinate");
+		}
+		
+		if (board[x][y] == Player.BLACK || board[x][y] == Player.WHITE) {
+			return Player.NONE;
+		}
+		
+		ArrayList<Point> visited = new ArrayList<>();
+		ArrayList<Point> edges = new ArrayList<>();
+		ArrayList<Point> territory = new ArrayList<>();
+		
+		ArrayList<Point> tovisit = new ArrayList<>();
+		
+		tovisit.add(new Point(x, y));
+		
+		while (tovisit.size() > 0) {
+			Point current = tovisit.remove(0);
+			
+			if (board[current.x][current.y] == Player.NONE) {
+				visited.add(current);
+				territory.add(current);
+				
+				ArrayList<Point> adjacent = getAdjacent(current);
+				
+				for (Point p : adjacent) {
+					if (!visited.contains(p) && !tovisit.contains(p)) {
+						tovisit.add(p);
+					}
+				}
+			} else {
+				edges.add(current);
+			}
+		}
+		
+		if (edges.size() == 0) {
+			return Player.NONE;
+		}
+		
+		Player owner = board[edges.get(0).x][edges.get(0).y];
+		for (int i = 0; i < edges.size(); i++) {
+			if (owner != board[edges.get(i).x][edges.get(i).y]) {
+				owner = Player.NONE;
+			}
+		}
+		
+		return owner;
+	}
+	
+	Set<Point> getTerritory(int x, int y) {
+		
+		if (x < 0 || x >= board.length || y < 0 || y >= board[0].length) {
+			throw new IllegalArgumentException("Invalid coordinate");
+		}
+		
+		ArrayList<Point> visited = new ArrayList<>();
+		HashSet<Point> territory = new HashSet<>();
+		
+		ArrayList<Point> tovisit = new ArrayList<>();
+		
+		tovisit.add(new Point(x, y));
+		
+		while (tovisit.size() > 0) {
+			Point current = tovisit.remove(0);
+			
+			if (board[current.x][current.y] == Player.NONE) {
+				visited.add(current);
+				territory.add(current);
+				
+				ArrayList<Point> adjacent = getAdjacent(current);
+				
+				for (Point p : adjacent) {
+					if (!visited.contains(p) && !tovisit.contains(p)) {
+						tovisit.add(p);
+					}
+				}
+			}
+		}
+		
+		return territory;
+	}
+	
+	HashMap<String, Set<Point>> getTerritories() {
+		HashMap<String, Set<Point>> territories = new HashMap<String, Set<Point>>();
+		
+		territories.put("WHITE", new HashSet<Point>());
+		territories.put("BLACK", new HashSet<Point>());
+		territories.put("NONE", new HashSet<Point>());
+		
+		for (int i = 0; i < board[0].length; i++) {
+			for (int j = 0; j < board.length; j++) {
+				if (board[j][i] == Player.NONE) {
+					if (getTerritoryOwner(j, i) == Player.NONE) {
+						territories.get("NONE").add(new Point(j, i));
+					} else if (getTerritoryOwner(j, i) == Player.BLACK) {
+						territories.get("BLACK").add(new Point(j, i));
+					} else {
+						territories.get("WHITE").add(new Point(j, i));
+					}
+				}
+			}
+		}
+		
+		return territories;
+	}
+}

exercises/go-counting/.meta/src/reference/java/Player.java

+enum Player {
+    NONE, BLACK, WHITE
+}

exercises/go-counting/.meta/version

+1.0.0
+

exercises/go-counting/README.md

+# Go Counting
+
+Count the scored points on a Go board.
+
+In the game of go (also known as baduk, igo, cờ vây and wéiqí) points
+are gained by completely encircling empty intersections with your
+stones. The encircled intersections of a player are known as its
+territory.
+
+Write a function that determines the territory of each player. You may
+assume that any stones that have been stranded in enemy territory have
+already been taken off the board.
+
+Write a function that determines the territory which includes a specified coordinate.
+
+Multiple empty intersections may be encircled at once and for encircling
+only horizontal and vertical neighbours count. In the following diagram
+the stones which matter are marked "O" and the stones that don't are
+marked "I" (ignored).  Empty spaces represent empty intersections.
+
+```text
++----+
+|IOOI|
+|O  O|
+|O OI|
+|IOI |
++----+
+```
+
+To be more precise an empty intersection is part of a player's territory
+if all of its neighbours are either stones of that player or empty
+intersections that are part of that player's territory.
+
+For more information see
+[wikipedia](https://en.wikipedia.org/wiki/Go_%28game%29) or [Sensei's
+Library](http://senseis.xmp.net/).
+
+# 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/go-counting/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/go-counting/src/main/java/Player.java

+enum Player {
+    NONE, BLACK, WHITE
+}

exercises/go-counting/src/test/java/GoCountingTest.java

+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.awt.Point;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Set;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Rule;
+import org.junit.rules.ExpectedException;
+
+public class GoCountingTest {
+	
+	@Rule
+	public ExpectedException expectedException = ExpectedException.none(); 
+	
+	String board5x5 = "  B  \n" +
+	                  " B B \n" +
+	                  "B W B\n" +
+	                  " W W \n" +
+	                  "  W  ";
+	
+	@Test
+	public void blackCorner5x5BoardTest() {
+		GoCounting gocounting = new GoCounting(board5x5);
+		
+		Set<Point> territory = new HashSet<>();
+		territory.add(new Point(0, 0));
+		territory.add(new Point(0, 1));
+		territory.add(new Point(1, 0));
+		
+		assertEquals(Player.BLACK, gocounting.getTerritoryOwner(0, 1));
+		assertEquals(territory, gocounting.getTerritory(0, 1));
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void whiteCenter5x5BoardTest() {
+		GoCounting gocounting = new GoCounting(board5x5);
+		
+		Set<Point> territory = new HashSet<>();
+		territory.add(new Point(2, 3));
+		
+		assertEquals(Player.WHITE, gocounting.getTerritoryOwner(2, 3));
+		assertEquals(territory, gocounting.getTerritory(2, 3));
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void openCorner5x5BoardTest() {
+		GoCounting gocounting = new GoCounting(board5x5);
+		
+		Set<Point> territory = new HashSet<>();
+		territory.add(new Point(0, 3));
+		territory.add(new Point(0, 4));
+		territory.add(new Point(1, 4));
+		
+		assertEquals(Player.NONE, gocounting.getTerritoryOwner(1, 4));
+		assertEquals(territory, gocounting.getTerritory(1, 4));
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void stoneNotTerritory5x5Board() {
+		GoCounting gocounting = new GoCounting(board5x5);
+		
+		Set<Point> territory = new HashSet<>();
+		
+		assertEquals(Player.NONE, gocounting.getTerritoryOwner(1, 1));
+		assertEquals(territory, gocounting.getTerritory(1, 1));
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void invalidXTooLow5x5Board() {
+		GoCounting gocounting = new GoCounting(board5x5);
+		
+		expectedException.expect(IllegalArgumentException.class);
+		expectedException.expectMessage("Invalid coordinate");
+		
+		gocounting.getTerritory(-1, 1);
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void invalidXTooHigh5x5Board() {
+		GoCounting gocounting = new GoCounting(board5x5);
+		
+		expectedException.expect(IllegalArgumentException.class);
+		expectedException.expectMessage("Invalid coordinate");
+		
+		gocounting.getTerritory(5, 1);
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void invalidYTooLow5x5Board() {
+		GoCounting gocounting = new GoCounting(board5x5);
+		
+		expectedException.expect(IllegalArgumentException.class);
+		expectedException.expectMessage("Invalid coordinate");
+		
+		gocounting.getTerritory(1, -1);
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void invalidYTooHigh5x5Board() {
+		GoCounting gocounting = new GoCounting(board5x5);
+		
+		expectedException.expect(IllegalArgumentException.class);
+		expectedException.expectMessage("Invalid coordinate");
+		
+		gocounting.getTerritory(1, 5);
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void oneTerritoryIsWholeBoardTest() {
+		GoCounting gocounting = new GoCounting(" ");
+		
+		HashMap<String, Set<Point>> territories = new HashMap<>();
+		Set<Point> blackTerritory = new HashSet<>();
+		Set<Point> whiteTerritory = new HashSet<>();
+		Set<Point> noneTerritory = new HashSet<>();
+		noneTerritory.add(new Point(0, 0));
+		
+		territories.put("BLACK", blackTerritory);
+		territories.put("WHITE", whiteTerritory);
+		territories.put("NONE", noneTerritory);
+		
+		assertEquals(territories, gocounting.getTerritories());
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void twoTerritoryRectangularBoardTest() {
+		GoCounting gocounting = new GoCounting(" BW \n BW ");
+		
+		Set<Point> blackTerritory = new HashSet<>();
+		blackTerritory.add(new Point(0, 0));
+		blackTerritory.add(new Point(0, 1));
+		
+		Set<Point> whiteTerritory = new HashSet<>();
+		whiteTerritory.add(new Point(3, 0));
+		whiteTerritory.add(new Point(3, 1));
+		
+		Set<Point> noneTerritory = new HashSet<>();
+		
+		HashMap<String, Set<Point>> territories = new HashMap<>();
+		territories.put("BLACK", blackTerritory);
+		territories.put("WHITE", whiteTerritory);
+		territories.put("NONE", noneTerritory);
+		
+		assertEquals(territories, gocounting.getTerritories());
+	}
+	
+	@Ignore("Remove to run test")
+	@Test
+	public void twoRegionRectangularBoardTest() {
+		GoCounting gocounting = new GoCounting(" B ");
+		
+		HashMap<String, Set<Point>> territories = new HashMap<>();
+		Set<Point> blackTerritory = new HashSet<>();
+		blackTerritory.add(new Point(0, 0));
+		blackTerritory.add(new Point(2, 0));
+		Set<Point> whiteTerritory = new HashSet<>();
+		Set<Point> noneTerritory = new HashSet<>();
+		
+		territories.put("BLACK", blackTerritory);
+		territories.put("WHITE", whiteTerritory);
+		territories.put("NONE", noneTerritory);
+		
+		assertEquals(territories, gocounting.getTerritories());
+	}
+}

exercises/grep/.meta/hints.md

+Since this exercise has difficulty 5 it doesn't come with any starter implementation.
+This is so that you get to practice creating classes and methods which is an important part of programming in Java.
+It does mean that when you first try to run the tests, they won't compile.
+They will give you an error similar to:
+```
+ path-to-exercism-dir\exercism\java\name-of-exercise\src\test\java\ExerciseClassNameTest.java:14: error: cannot find symbol
+        ExerciseClassName exerciseClassName = new ExerciseClassName();
+        ^
+ symbol:   class ExerciseClassName
+ location: class ExerciseClassNameTest
+```
+This error occurs because the test refers to a class that hasn't been created yet (`ExerciseClassName`).
+To resolve the error you need to add a file matching the class name in the error to the `src/main/java` directory.
+For example, for the error above you would add a file called `ExerciseClassName.java`.
+
+When you try to run the tests again you will get slightly different errors.
+You might get an error similar to:
+```
+  constructor ExerciseClassName in class ExerciseClassName cannot be applied to given types;
+        ExerciseClassName exerciseClassName = new ExerciseClassName("some argument");
+                                              ^
+  required: no arguments
+  found: String
+  reason: actual and formal argument lists differ in length
+```
+This error means that you need to add a [constructor](https://docs.oracle.com/javase/tutorial/java/javaOO/constructors.html) to your new class.
+If you don't add a constructor, Java will add a default one for you.
+This default constructor takes no arguments.
+So if the tests expect your class to have a constructor which takes arguments, then you need to create this constructor yourself.
+In the example above you could add:
+```
+ExerciseClassName(String input) {
+
+}
+``` 
+That should make the error go away, though you might need to add some more code to your constructor to make the test pass!
+
+You might also get an error similar to:
+```
+  error: cannot find symbol
+        assertEquals(expectedOutput, exerciseClassName.someMethod());
+                                                       ^
+  symbol:   method someMethod()
+  location: variable exerciseClassName of type ExerciseClassName
+```
+This error means that you need to add a method called `someMethod` to your new class.
+In the example above you would add:
+```
+String someMethod() {
+  return "";
+}
+```
+Make sure the return type matches what the test is expecting.
+You can find out which return type it should have by looking at the type of object it's being compared to in the tests.
+Or you could set your method to return some random type (e.g. `void`), and run the tests again.
+The new error should tell you which type it's expecting.
+
+After having resolved these errors you should be ready to start making the tests pass!

exercises/grep/.meta/src/reference/java/GrepTool.java

+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+class GrepTool {
+
+    String grep(String pattern, List<String> flags, List<String> files) {
+        boolean shouldAddFilenameToEachLine = files.size() > 1;
+        return files
+            .stream()
+            .map(file -> grepFile(pattern, flags, file, shouldAddFilenameToEachLine))
+            .filter(line -> !line.isEmpty())
+            .collect(Collectors.joining("\n"));
+    }
+
+    private String grepFile(String pattern, List<String> flags, String filename, boolean shouldAddFilenameToEachLine) {
+        List<String> lines = readFile(filename);
+
+        String matchingLines = IntStream.range(0, lines.size())
+            .filter(lineIndex -> lineMatchesPattern(lines.get(lineIndex), pattern, flags))
+            .mapToObj(lineIndex -> {
+                String lineWithFlagsApplied = applyFlagsToLine(lines.get(lineIndex), flags, lineIndex + 1);
+                return shouldAddFilenameToEachLine ? filename + ":" + lineWithFlagsApplied : lineWithFlagsApplied;
+            })
+            .collect(Collectors.joining("\n"));
+
+        boolean shouldPrintFilenameInsteadOfMatchingLines = flags.contains("-l");
+        return shouldPrintFilenameInsteadOfMatchingLines && !matchingLines.isEmpty() ? filename : matchingLines;
+    }
+
+    private boolean lineMatchesPattern(String line, String pattern, List<String> flags) {
+        boolean isCaseInsensitive = flags.contains("-i");
+        String lineToCompare = isCaseInsensitive ? line.toLowerCase() : line;
+        String patternToCompare = isCaseInsensitive ? pattern.toLowerCase() : pattern;
+
+        boolean shouldMatchEntireLine = flags.contains("-x");
+        boolean matchesPattern = shouldMatchEntireLine
+            ? lineToCompare.equals(patternToCompare)
+            : lineToCompare.contains(patternToCompare);
+
+        boolean shouldInvertMatch = flags.contains("-v");
+        //noinspection SimplifiableConditionalExpression
+        return shouldInvertMatch ? !matchesPattern : matchesPattern;
+    }
+
+
+    private String applyFlagsToLine(String line, List<String> flags, int lineNumber) {
+        boolean shouldAddLineNumber = flags.contains("-n");
+        return shouldAddLineNumber ? lineNumber + ":" + line : line;
+    }
+
+    private List<String> readFile(String filename) {
+        try {
+            return Files.readAllLines(Paths.get(filename), Charset.forName("UTF-8"));
+        } catch (IOException e) {
+            return Collections.emptyList();
+        }
+    }
+
+}

exercises/grep/README.md

+# Grep
+
+Search a file for lines matching a regular expression pattern. Return the line
+number and contents of each matching line.
+
+The Unix [`grep`](http://pubs.opengroup.org/onlinepubs/9699919799/utilities/grep.html) command can be used to search for lines in one or more files
+that match a user-provided search query (known as the *pattern*).
+
+The `grep` command takes three arguments:
+
+1. The pattern used to match lines in a file.
+2. Zero or more flags to customize the matching behavior.
+3. One or more files in which to search for matching lines.
+
+Your task is to implement the `grep` function, which should read the contents
+of the specified files, find the lines that match the specified pattern
+and then output those lines as a single string. Note that the lines should
+be output in the order in which they were found, with the first matching line
+in the first file being output first.
+
+As an example, suppose there is a file named "input.txt" with the following contents:
+
+```text
+hello
+world
+hello again
+```
+
+If we were to call `grep "hello" input.txt`, the returned string should be:
+
+```text
+hello
+hello again
+```
+
+### Flags
+
+As said earlier, the `grep` command should also support the following flags:
+
+- `-n` Print the line numbers of each matching line.
+- `-l` Print only the names of files that contain at least one matching line.
+- `-i` Match line using a case-insensitive comparison.
+- `-v` Invert the program -- collect all lines that fail to match the pattern.
+- `-x` Only match entire lines, instead of lines that contain a match.
+
+If we run `grep -n "hello" input.txt`, the `-n` flag will require the matching
+lines to be prefixed with its line number:
+
+```text
+1:hello
+3:hello again
+```
+
+And if we run `grep -i "HELLO" input.txt`, we'll do a case-insensitive match,
+and the output will be:
+
+```text
+hello
+hello again
+```
+
+The `grep` command should support multiple flags at once.
+
+For example, running `grep -l -v "hello" file1.txt file2.txt` should
+print the names of files that do not contain the string "hello".
+
+# Java Tips
+
+Since this exercise has difficulty 5 it doesn't come with any starter implementation.
+This is so that you get to practice creating classes and methods which is an important part of programming in Java.
+It does mean that when you first try to run the tests, they won't compile.
+They will give you an error similar to:
+```
+ path-to-exercism-dir\exercism\java\name-of-exercise\src\test\java\ExerciseClassNameTest.java:14: error: cannot find symbol
+        ExerciseClassName exerciseClassName = new ExerciseClassName();
+        ^
+ symbol:   class ExerciseClassName
+ location: class ExerciseClassNameTest
+```
+This error occurs because the test refers to a class that hasn't been created yet (`ExerciseClassName`).
+To resolve the error you need to add a file matching the class name in the error to the `src/main/java` directory.
+For example, for the error above you would add a file called `ExerciseClassName.java`.
+
+When you try to run the tests again you will get slightly different errors.
+You might get an error similar to:
+```
+  constructor ExerciseClassName in class ExerciseClassName cannot be applied to given types;
+        ExerciseClassName exerciseClassName = new ExerciseClassName("some argument");
+                                              ^
+  required: no arguments
+  found: String
+  reason: actual and formal argument lists differ in length
+```
+This error means that you need to add a [constructor](https://docs.oracle.com/javase/tutorial/java/javaOO/constructors.html) to your new class.
+If you don't add a constructor, Java will add a default one for you.
+This default constructor takes no arguments.
+So if the tests expect your class to have a constructor which takes arguments, then you need to create this constructor yourself.
+In the example above you could add:
+```
+ExerciseClassName(String input) {
+
+}
+``` 
+That should make the error go away, though you might need to add some more code to your constructor to make the test pass!
+
+You might also get an error similar to:
+```
+  error: cannot find symbol
+        assertEquals(expectedOutput, exerciseClassName.someMethod());
+                                                       ^
+  symbol:   method someMethod()
+  location: variable exerciseClassName of type ExerciseClassName
+```
+This error means that you need to add a method called `someMethod` to your new class.
+In the example above you would add:
+```
+String someMethod() {
+  return "";
+}
+```
+Make sure the return type matches what the test is expecting.
+You can find out which return type it should have by looking at the type of object it's being compared to in the tests.
+Or you could set your method to return some random type (e.g. `void`), and run the tests again.
+The new error should tell you which type it's expecting.
+
+After having resolved these errors you should be ready to start making the tests pass!
+
+
+# Running the tests
+
+You can run all the tests for an exercise by entering
+
+```sh
+$ gradle test
+```
+
+in your terminal.
+
+## Source
+
+Conversation with Nate Foster. [http://www.cs.cornell.edu/Courses/cs3110/2014sp/hw/0/ps0.pdf](http://www.cs.cornell.edu/Courses/cs3110/2014sp/hw/0/ps0.pdf)
+
+## Submitting Incomplete Solutions
+
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

exercises/grep/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/grep/src/test/java/GrepToolTest.java

+import org.junit.After;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class GrepToolTest {
+    private GrepTool grepTool;
+
+    @Before
+    public void setUp() throws IOException {
+        List<String> iliadText = Arrays.asList(
+            "Achilles sing, O Goddess! Peleus' son;",
+            "His wrath pernicious, who ten thousand woes",
+            "Caused to Achaia's host, sent many a soul",
+            "Illustrious into Ades premature,",
+            "And Heroes gave (so stood the will of Jove)",
+            "To dogs and to all ravening fowls a prey,",
+            "When fierce dispute had separated once",
+            "The noble Chief Achilles from the son",
+            "Of Atreus, Agamemnon, King of men."
+        );
+        writeToFile("iliad.txt", iliadText);
+
+        List<String> midsummerNightText = Arrays.asList(
+            "I do entreat your grace to pardon me.",
+            "I know not by what power I am made bold,",
+            "Nor how it may concern my modesty,",
+            "In such a presence here to plead my thoughts;",
+            "But I beseech your grace that I may know",
+            "The worst that may befall me in this case,",
+            "If I refuse to wed Demetrius."
+        );
+        writeToFile("midsummer-night.txt", midsummerNightText);
+
+        List<String> paradiseLostText = Arrays.asList(
+            "Of Mans First Disobedience, and the Fruit",
+            "Of that Forbidden Tree, whose mortal tast",
+            "Brought Death into the World, and all our woe,",
+            "With loss of Eden, till one greater Man",
+            "Restore us, and regain the blissful Seat,",
+            "Sing Heav'nly Muse, that on the secret top",
+            "Of Oreb, or of Sinai, didst inspire",
+            "That Shepherd, who first taught the chosen Seed"
+        );
+        writeToFile("paradise-lost.txt", paradiseLostText);
+
+        grepTool = new GrepTool();
+    }
+
+    @After
+    public void tearDown() throws IOException {
+        deleteFile("iliad.txt");
+        deleteFile("midsummer-night.txt");
+        deleteFile("paradise-lost.txt");
+    }
+
+    @Test
+    public void oneFileOneMatchNoFlags() {
+        String expected = "Of Atreus, Agamemnon, King of men.";
+
+        String actual = grepTool.grep(
+            "Agamemnon",
+            Collections.emptyList(),
+            Collections.singletonList("iliad.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void oneFileOneMatchPrintLineNumbersFlag() {
+        String expected = "2:Of that Forbidden Tree, whose mortal tast";
+
+        String actual = grepTool.grep(
+            "Forbidden",
+            Collections.singletonList("-n"),
+            Collections.singletonList("paradise-lost.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void oneFileOneMatchCaseInsensitiveFlag() {
+        String expected = "Of that Forbidden Tree, whose mortal tast";
+
+        String actual = grepTool.grep(
+            "FORBIDDEN",
+            Collections.singletonList("-i"),
+            Collections.singletonList("paradise-lost.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void oneFileOneMatchPrintFileNamesFlag() {
+        String expected = "paradise-lost.txt";
+
+        String actual = grepTool.grep(
+            "Forbidden",
+            Collections.singletonList("-l"),
+            Collections.singletonList("paradise-lost.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void oneFileOneMatchEntireLinesFlag() {
+        String expected = "With loss of Eden, till one greater Man";
+
+        String actual = grepTool.grep(
+            "With loss of Eden, till one greater Man",
+            Collections.singletonList("-x"),
+            Collections.singletonList("paradise-lost.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void oneFileOneMatchMultipleFlags() {
+        String expected = "9:Of Atreus, Agamemnon, King of men.";
+
+        String actual = grepTool.grep(
+            "OF ATREUS, Agamemnon, KIng of MEN.",
+            Arrays.asList("-n", "-i", "-x"),
+            Collections.singletonList("iliad.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void oneFileSeveralMatchesNoFlags() {
+        String expected = "Nor how it may concern my modesty,\n"
+            + "But I beseech your grace that I may know\n"
+            + "The worst that may befall me in this case,";
+
+        String actual = grepTool.grep(
+            "may",
+            Collections.emptyList(),
+            Collections.singletonList("midsummer-night.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void oneFileSeveralMatchesPrintLineNumbersFlag() {
+        String expected = "3:Nor how it may concern my modesty,\n"
+            + "5:But I beseech your grace that I may know\n"
+            + "6:The worst that may befall me in this case,";
+
+        String actual = grepTool.grep(
+            "may",
+            Collections.singletonList("-n"),
+            Collections.singletonList("midsummer-night.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void oneFileSeveralMatchesMatchEntireLineFlag() {
+        String expected = "";
+
+        String actual = grepTool.grep(
+            "may",
+            Collections.singletonList("-x"),
+            Collections.singletonList("midsummer-night.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void oneFileSeveralMatchesCaseInsensitiveFlag() {
+        String expected = "Achilles sing, O Goddess! Peleus' son;\n"
+            + "The noble Chief Achilles from the son";
+
+        String actual = grepTool.grep(
+            "ACHILLES",
+            Collections.singletonList("-i"),
+            Collections.singletonList("iliad.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void oneFileSeveralMatchesInvertedFlag() {
+        String expected = "Brought Death into the World, and all our woe,\n"
+            + "With loss of Eden, till one greater Man\n"
+            + "Restore us, and regain the blissful Seat,\n"
+            + "Sing Heav'nly Muse, that on the secret top\n"
+            + "That Shepherd, who first taught the chosen Seed";
+
+        String actual = grepTool.grep(
+            "Of",
+            Collections.singletonList("-v"),
+            Collections.singletonList("paradise-lost.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void oneFileNoMatchesVariousFlags() {
+        String expected = "";
+
+        String actual = grepTool.grep(
+            "Gandalf",
+            Arrays.asList("-n", "-l", "-x", "-i"),
+            Collections.singletonList("iliad.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void multipleFilesOneMatchNoFlags() {
+        String expected = "iliad.txt:Of Atreus, Agamemnon, King of men.";
+
+        String actual = grepTool.grep(
+            "Agamemnon",
+            Collections.emptyList(),
+            Arrays.asList("iliad.txt", "midsummer-night.txt", "paradise-lost.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void multipleFilesSeveralMatchesNoFlags() {
+        String expected = "midsummer-night.txt:Nor how it may concern my modesty,\n"
+            + "midsummer-night.txt:But I beseech your grace that I may know\n"
+            + "midsummer-night.txt:The worst that may befall me in this case,";
+
+        String actual = grepTool.grep(
+            "may",
+            Collections.emptyList(),
+            Arrays.asList("iliad.txt", "midsummer-night.txt", "paradise-lost.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void multipleFilesSeveralMatchesPrintLineNumbersFlag() {
+        String expected = "midsummer-night.txt:5:But I beseech your grace that I may know\n"
+            + "midsummer-night.txt:6:The worst that may befall me in this case,\n"
+            + "paradise-lost.txt:2:Of that Forbidden Tree, whose mortal tast\n"
+            + "paradise-lost.txt:6:Sing Heav'nly Muse, that on the secret top";
+
+        String actual = grepTool.grep(
+            "that",
+            Collections.singletonList("-n"),
+            Arrays.asList("iliad.txt", "midsummer-night.txt", "paradise-lost.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void multipleFilesOneMatchPrintFileNamesFlag() {
+        String expected = "iliad.txt\n"
+            + "paradise-lost.txt";
+
+        String actual = grepTool.grep(
+            "who",
+            Collections.singletonList("-l"),
+            Arrays.asList("iliad.txt", "midsummer-night.txt", "paradise-lost.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void multipleFilesSeveralMatchesCaseInsensitiveFlag() {
+        String expected = "iliad.txt:Caused to Achaia's host, sent many a soul\n"
+            + "iliad.txt:Illustrious into Ades premature,\n"
+            + "iliad.txt:And Heroes gave (so stood the will of Jove)\n"
+            + "iliad.txt:To dogs and to all ravening fowls a prey,\n"
+            + "midsummer-night.txt:I do entreat your grace to pardon me.\n"
+            + "midsummer-night.txt:In such a presence here to plead my thoughts;\n"
+            + "midsummer-night.txt:If I refuse to wed Demetrius.\n"
+            + "paradise-lost.txt:Brought Death into the World, and all our woe,\n"
+            + "paradise-lost.txt:Restore us, and regain the blissful Seat,\n"
+            + "paradise-lost.txt:Sing Heav'nly Muse, that on the secret top";
+
+        String actual = grepTool.grep(
+            "TO",
+            Collections.singletonList("-i"),
+            Arrays.asList("iliad.txt", "midsummer-night.txt", "paradise-lost.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void multipleFilesSeveralMatchesInvertedFlag() {
+        String expected = "iliad.txt:Achilles sing, O Goddess! Peleus' son;\n"
+            + "iliad.txt:The noble Chief Achilles from the son\n"
+            + "midsummer-night.txt:If I refuse to wed Demetrius.";
+
+        String actual = grepTool.grep(
+            "a",
+            Collections.singletonList("-v"),
+            Arrays.asList("iliad.txt", "midsummer-night.txt", "paradise-lost.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void multipleFilesOneMatchEntireLinesFlag() {
+        String expected = "midsummer-night.txt:But I beseech your grace that I may know";
+
+        String actual = grepTool.grep(
+            "But I beseech your grace that I may know",
+            Collections.singletonList("-x"),
+            Arrays.asList("iliad.txt", "midsummer-night.txt", "paradise-lost.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void multipleFilesOneMatchMultipleFlags() {
+        String expected = "paradise-lost.txt:4:With loss of Eden, till one greater Man";
+
+        String actual = grepTool.grep(
+            "WITH LOSS OF EDEN, TILL ONE GREATER MAN",
+            Arrays.asList("-n", "-i", "-x"),
+            Arrays.asList("iliad.txt", "midsummer-night.txt", "paradise-lost.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void multipleFilesNoMatchesVariousFlags() {
+        String expected = "";
+
+        String actual = grepTool.grep(
+            "Frodo",
+            Arrays.asList("-n", "-l", "-i", "-x"),
+            Arrays.asList("iliad.txt", "midsummer-night.txt", "paradise-lost.txt")
+        );
+
+        assertEquals(expected, actual);
+    }
+
+    private void writeToFile(String filename, List<String> contents) throws IOException {
+        Path file = Paths.get(filename);
+        Files.write(file, contents, Charset.forName("UTF-8"));
+    }
+
+    private void deleteFile(String filename) throws IOException {
+        Files.deleteIfExists(Paths.get(filename));
+    }
+}

exercises/house/.meta/src/reference/java/House.java

         verse.append("This is the " + CHARACTERS[verseNumber - 1]);
 
         for (int i = verseNumber - 2; i >= 0; i--) {
-            verse.append("\nthat " + ACTIONS[i] + " the " + CHARACTERS[i]);
+            verse.append(" that " + ACTIONS[i] + " the " + CHARACTERS[i]);
         }
 
         return verse.toString();
             verses[i - startVerse] = verse(i);
         }
 
-        return String.join("\n\n", verses);
+        return String.join("\n", verses);
     }
 
     String sing() {

exercises/house/.meta/version

-2.0.0
+2.2.0

exercises/house/src/test/java/HouseTest.java

     @Test
     public void verseTwo() {
         String expected =
-                "This is the malt\n" +
+                "This is the malt " +
                 "that lay in the house that Jack built.";
         int verse = 2;
 
     @Test
     public void verseThree() {
         String expected =
-                "This is the rat\n" +
-                "that ate the malt\n" +
+                "This is the rat " +
+                "that ate the malt " +
                 "that lay in the house that Jack built.";
         int verse = 3;
 
     @Test
     public void verseFour() {
         String expected =
-                "This is the cat\n" +
-                "that killed the rat\n" +
-                "that ate the malt\n" +
+                "This is the cat " +
+                "that killed the rat " +
+                "that ate the malt " +
                 "that lay in the house that Jack built.";
         int verse = 4;
 
     @Test
     public void verseFive() {
         String expected =
-                "This is the dog\n" +
-                "that worried the cat\n" +
-                "that killed the rat\n" +
-                "that ate the malt\n" +
+                "This is the dog " +
+                "that worried the cat " +
+                "that killed the rat " +
+                "that ate the malt " +
                 "that lay in the house that Jack built.";
         int verse = 5;
 
     @Test
     public void verseSix() {
         String expected =
-                "This is the cow with the crumpled horn\n" +
-                "that tossed the dog\n" +
-                "that worried the cat\n" +
-                "that killed the rat\n" +
-                "that ate the malt\n" +
+                "This is the cow with the crumpled horn " +
+                "that tossed the dog " +
+                "that worried the cat " +
+                "that killed the rat " +
+                "that ate the malt " +
                 "that lay in the house that Jack built.";
         int verse = 6;
 
     @Test
     public void verseSeven() {
         String expected =
-                "This is the maiden all forlorn\n" +
-                "that milked the cow with the crumpled horn\n" +
-                "that tossed the dog\n" +
-                "that worried the cat\n" +
-                "that killed the rat\n" +
-                "that ate the malt\n" +
+                "This is the maiden all forlorn " +
+                "that milked the cow with the crumpled horn " +
+                "that tossed the dog " +
+                "that worried the cat " +
+                "that killed the rat " +
+                "that ate the malt " +
                 "that lay in the house that Jack built.";
         int verse = 7;
 
     @Test
     public void verseEight() {
         String expected =
-                "This is the man all tattered and torn\n" +
-                "that kissed the maiden all forlorn\n" +
-                "that milked the cow with the crumpled horn\n" +
-                "that tossed the dog\n" +
-                "that worried the cat\n" +
-                "that killed the rat\n" +
-                "that ate the malt\n" +
+                "This is the man all tattered and torn " +
+                "that kissed the maiden all forlorn " +
+                "that milked the cow with the crumpled horn " +
+                "that tossed the dog " +
+                "that worried the cat " +
+                "that killed the rat " +
+                "that ate the malt " +
                 "that lay in the house that Jack built.";
         int verse = 8;
 
     @Test
     public void verseNine() {
         String expected =
-                "This is the priest all shaven and shorn\n" +
-                "that married the man all tattered and torn\n" +
-                "that kissed the maiden all forlorn\n" +
-                "that milked the cow with the crumpled horn\n" +
-                "that tossed the dog\n" +
-                "that worried the cat\n" +
-                "that killed the rat\n" +
-                "that ate the malt\n" +
+                "This is the priest all shaven and shorn " +
+                "that married the man all tattered and torn " +
+                "that kissed the maiden all forlorn " +
+                "that milked the cow with the crumpled horn " +
+                "that tossed the dog " +
+                "that worried the cat " +
+                "that killed the rat " +
+                "that ate the malt " +
                 "that lay in the house that Jack built.";
         int verse = 9;
 
     @Test
     public void verse10() {
         String expected =
-                "This is the rooster that crowed in the morn\n" +
-                "that woke the priest all shaven and shorn\n" +
-                "that married the man all tattered and torn\n" +
-                "that kissed the maiden all forlorn\n" +
-                "that milked the cow with the crumpled horn\n" +
-                "that tossed the dog\n" +
-                "that worried the cat\n" +
-                "that killed the rat\n" +
-                "that ate the malt\n" +
+                "This is the rooster that crowed in the morn " +
+                "that woke the priest all shaven and shorn " +
+                "that married the man all tattered and torn " +
+                "that kissed the maiden all forlorn " +
+                "that milked the cow with the crumpled horn " +
+                "that tossed the dog " +
+                "that worried the cat " +
+                "that killed the rat " +
+                "that ate the malt " +
                 "that lay in the house that Jack built.";
         int verse = 10;
 
     @Test
     public void verse11() {
         String expected =
-                "This is the farmer sowing his corn\n" +
-                "that kept the rooster that crowed in the morn\n" +
-                "that woke the priest all shaven and shorn\n" +
-                "that married the man all tattered and torn\n" +
-                "that kissed the maiden all forlorn\n" +
-                "that milked the cow with the crumpled horn\n" +
-                "that tossed the dog\n" +
-                "that worried the cat\n" +
-                "that killed the rat\n" +
-                "that ate the malt\n" +
+                "This is the farmer sowing his corn " +
+                "that kept the rooster that crowed in the morn " +
+                "that woke the priest all shaven and shorn " +
+                "that married the man all tattered and torn " +
+                "that kissed the maiden all forlorn " +
+                "that milked the cow with the crumpled horn " +
+                "that tossed the dog " +
+                "that worried the cat " +
+                "that killed the rat " +
+                "that ate the malt " +
                 "that lay in the house that Jack built.";
         int verse = 11;
 
     @Test
     public void verse12() {
         String expected =
-                "This is the horse and the hound and the horn\n" +
-                "that belonged to the farmer sowing his corn\n" +
-                "that kept the rooster that crowed in the morn\n" +
-                "that woke the priest all shaven and shorn\n" +
-                "that married the man all tattered and torn\n" +
-                "that kissed the maiden all forlorn\n" +
-                "that milked the cow with the crumpled horn\n" +
-                "that tossed the dog\n" +
-                "that worried the cat\n" +
-                "that killed the rat\n" +
-                "that ate the malt\n" +
+                "This is the horse and the hound and the horn " +
+                "that belonged to the farmer sowing his corn " +
+                "that kept the rooster that crowed in the morn " +
+                "that woke the priest all shaven and shorn " +
+                "that married the man all tattered and torn " +
+                "that kissed the maiden all forlorn " +
+                "that milked the cow with the crumpled horn " +
+                "that tossed the dog " +
+                "that worried the cat " +
+                "that killed the rat " +
+                "that ate the malt " +
                 "that lay in the house that Jack built.";
         int verse = 12;
 
     @Test
     public void multipleVerses() {
         String expected =
-                "This is the cat\n" +
-                "that killed the rat\n" +
-                "that ate the malt\n" +
+                "This is the cat " +
+                "that killed the rat " +
+                "that ate the malt " +
                 "that lay in the house that Jack built.\n" +
-                "\n" +
-                "This is the dog\n" +
-                "that worried the cat\n" +
-                "that killed the rat\n" +
-                "that ate the malt\n" +
+                "This is the dog " +
+                "that worried the cat " +
+                "that killed the rat " +
+                "that ate the malt " +
                 "that lay in the house that Jack built.\n" +
-                "\n" +
-                "This is the cow with the crumpled horn\n" +
-                "that tossed the dog\n" +
-                "that worried the cat\n" +
-                "that killed the rat\n" +
-                "that ate the malt\n" +
+                "This is the cow with the crumpled horn " +
+                "that tossed the dog " +
+                "that worried the cat " +
+                "that killed the rat " +
+                "that ate the malt " +
                 "that lay in the house that Jack built.\n" +
-                "\n" +
-                "This is the maiden all forlorn\n" +
-                "that milked the cow with the crumpled horn\n" +
-                "that tossed the dog\n" +
-                "that worried the cat\n" +
-                "that killed the rat\n" +
-                "that ate the malt\n" +
+                "This is the maiden all forlorn " +
+                "that milked the cow with the crumpled horn " +
+                "that tossed the dog " +
+                "that worried the cat " +
+                "that killed the rat " +
+                "that ate the malt " +
                 "that lay in the house that Jack built.\n" +
-                "\n" +
-                "This is the man all tattered and torn\n" +
-                "that kissed the maiden all forlorn\n" +
-                "that milked the cow with the crumpled horn\n" +
-                "that tossed the dog\n" +
-                "that worried the cat\n" +
-                "that killed the rat\n" +
-                "that ate the malt\n" +
+                "This is the man all tattered and torn " +
+                "that kissed the maiden all forlorn " +
+                "that milked the cow with the crumpled horn " +
+                "that tossed the dog " +
+                "that worried the cat " +
+                "that killed the rat " +
+                "that ate the malt " +
                 "that lay in the house that Jack built.";
 
         int startVerse = 4;
     public void wholeRhyme() {
         String expected =
                 "This is the house that Jack built.\n" +
-                "\n" +
-                "This is the malt\n" +
+                "This is the malt " +
                 "that lay in the house that Jack built.\n" +
-                "\n" +
-                "This is the rat\n" +
-                "that ate the malt\n" +
+                "This is the rat " +
+                "that ate the malt " +
                 "that lay in the house that Jack built.\n" +
-                "\n" +
-                "This is the cat\n" +
-                "that killed the rat\n" +
-                "that ate the malt\n" +
+                "This is the cat " +
+                "that killed the rat " +
+                "that ate the malt " +
                 "that lay in the house that Jack built.\n" +
-                "\n" +
-                "This is the dog\n" +
-                "that worried the cat\n" +
-                "that killed the rat\n" +
-                "that ate the malt\n" +
+                "This is the dog " +
+                "that worried the cat " +
+                "that killed the rat " +
+                "that ate the malt " +
                 "that lay in the house that Jack built.\n" +
-                "\n" +
-                "This is the cow with the crumpled horn\n" +
-                "that tossed the dog\n" +
-                "that worried the cat\n" +
-                "that killed the rat\n" +
-                "that ate the malt\n" +
+                "This is the cow with the crumpled horn " +
+                "that tossed the dog " +
+                "that worried the cat " +
+                "that killed the rat " +
+                "that ate the malt " +
                 "that lay in the house that Jack built.\n" +
-                "\n" +
-                "This is the maiden all forlorn\n" +
-                "that milked the cow with the crumpled horn\n" +
-                "that tossed the dog\n" +
-                "that worried the cat\n" +
-                "that killed the rat\n" +
-                "that ate the malt\n" +
+                "This is the maiden all forlorn " +
+                "that milked the cow with the crumpled horn " +
+                "that tossed the dog " +
+                "that worried the cat " +
+                "that killed the rat " +
+                "that ate the malt " +
                 "that lay in the house that Jack built.\n" +
-                "\n" +
-                "This is the man all tattered and torn\n" +
-                "that kissed the maiden all forlorn\n" +
-                "that milked the cow with the crumpled horn\n" +
-                "that tossed the dog\n" +
-                "that worried the cat\n" +
-                "that killed the rat\n" +
-                "that ate the malt\n" +
+                "This is the man all tattered and torn " +
+                "that kissed the maiden all forlorn " +
+                "that milked the cow with the crumpled horn " +
+                "that tossed the dog " +
+                "that worried the cat " +
+                "that killed the rat " +
+                "that ate the malt " +
                 "that lay in the house that Jack built.\n" +
-                "\n" +
-                "This is the priest all shaven and shorn\n" +
-                "that married the man all tattered and torn\n" +
-                "that kissed the maiden all forlorn\n" +
-                "that milked the cow with the crumpled horn\n" +
-                "that tossed the dog\n" +
-                "that worried the cat\n" +
-                "that killed the rat\n" +
-                "that ate the malt\n" +
+                "This is the priest all shaven and shorn " +
+                "that married the man all tattered and torn " +
+                "that kissed the maiden all forlorn " +
+                "that milked the cow with the crumpled horn " +
+                "that tossed the dog " +
+                "that worried the cat " +
+                "that killed the rat " +
+                "that ate the malt " +
                 "that lay in the house that Jack built.\n" +
-                "\n" +
-                "This is the rooster that crowed in the morn\n" +
-                "that woke the priest all shaven and shorn\n" +
-                "that married the man all tattered and torn\n" +
-                "that kissed the maiden all forlorn\n" +
-                "that milked the cow with the crumpled horn\n" +
-                "that tossed the dog\n" +
-                "that worried the cat\n" +
-                "that killed the rat\n" +
-                "that ate the malt\n" +
+                "This is the rooster that crowed in the morn " +
+                "that woke the priest all shaven and shorn " +
+                "that married the man all tattered and torn " +
+                "that kissed the maiden all forlorn " +
+                "that milked the cow with the crumpled horn " +
+                "that tossed the dog " +
+                "that worried the cat " +
+                "that killed the rat " +
+                "that ate the malt " +
                 "that lay in the house that Jack built.\n" +
-                "\n" +
-                "This is the farmer sowing his corn\n" +
-                "that kept the rooster that crowed in the morn\n" +
-                "that woke the priest all shaven and shorn\n" +
-                "that married the man all tattered and torn\n" +
-                "that kissed the maiden all forlorn\n" +
-                "that milked the cow with the crumpled horn\n" +
-                "that tossed the dog\n" +
-                "that worried the cat\n" +
-                "that killed the rat\n" +
-                "that ate the malt\n" +
+                "This is the farmer sowing his corn " +
+                "that kept the rooster that crowed in the morn " +
+                "that woke the priest all shaven and shorn " +
+                "that married the man all tattered and torn " +
+                "that kissed the maiden all forlorn " +
+                "that milked the cow with the crumpled horn " +
+                "that tossed the dog " +
+                "that worried the cat " +
+                "that killed the rat " +
+                "that ate the malt " +
                 "that lay in the house that Jack built.\n" +
-                "\n" +
-                "This is the horse and the hound and the horn\n" +
-                "that belonged to the farmer sowing his corn\n" +
-                "that kept the rooster that crowed in the morn\n" +
-                "that woke the priest all shaven and shorn\n" +
-                "that married the man all tattered and torn\n" +
-                "that kissed the maiden all forlorn\n" +
-                "that milked the cow with the crumpled horn\n" +
-                "that tossed the dog\n" +
-                "that worried the cat\n" +
-                "that killed the rat\n" +
-                "that ate the malt\n" +
+                "This is the horse and the hound and the horn " +
+                "that belonged to the farmer sowing his corn " +
+                "that kept the rooster that crowed in the morn " +
+                "that woke the priest all shaven and shorn " +
+                "that married the man all tattered and torn " +
+                "that kissed the maiden all forlorn " +
+                "that milked the cow with the crumpled horn " +
+                "that tossed the dog " +
+                "that worried the cat " +
+                "that killed the rat " +
+                "that ate the malt " +
                 "that lay in the house that Jack built.";
 
         assertEquals(expected, house.sing());

exercises/isogram/.meta/version

-1.2.0
+1.3.0

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

 
     @Test
     public void testCorrectlyCalculatesLargestProductWhenSeriesLengthEqualsStringToSearchLength() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("29");
-        final long expectedProduct = 18;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("29");
+        long expectedProduct = 18;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(2);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(2);
 
         assertEquals(expectedProduct, actualProduct);
     }
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfLengthTwoWithNumbersInOrder() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0123456789");
-        final long expectedProduct = 72;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0123456789");
+        long expectedProduct = 72;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(2);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(2);
 
         assertEquals(expectedProduct, actualProduct);
     }
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfLengthTwoWithNumbersNotInOrder() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("576802143");
-        final long expectedProduct = 48;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("576802143");
+        long expectedProduct = 48;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(2);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(2);
 
         assertEquals(expectedProduct, actualProduct);
     }
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfLengthThreeWithNumbersInOrder() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0123456789");
-        final long expectedProduct = 504;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0123456789");
+        long expectedProduct = 504;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(3);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(3);
 
         assertEquals(expectedProduct, actualProduct);
     }
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfLengthThreeWithNumbersNotInOrder() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("1027839564");
-        final long expectedProduct = 270;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("1027839564");
+        long expectedProduct = 270;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(3);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(3);
 
         assertEquals(expectedProduct, actualProduct);
     }
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfLengthFiveWithNumbersInOrder() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0123456789");
-        final long expectedProduct = 15120;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0123456789");
+        long expectedProduct = 15120;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(5);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(5);
 
         assertEquals(expectedProduct, actualProduct);
     }
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductInLongStringToSearchV1() {
-        final LargestSeriesProductCalculator calculator
+        LargestSeriesProductCalculator calculator
                 = new LargestSeriesProductCalculator("73167176531330624919225119674426574742355349194934");
 
-        final long expectedProduct = 23520;
+        long expectedProduct = 23520;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(6);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(6);
 
         assertEquals(expectedProduct, actualProduct);
     }
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfZeroIfAllDigitsAreZeroes() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0000");
-        final long expectedProduct = 0;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("0000");
+        long expectedProduct = 0;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(2);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(2);
 
         assertEquals(expectedProduct, actualProduct);
     }
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfZeroIfAllSeriesOfGivenLengthContainZero() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("99099");
-        final long expectedProduct = 0;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("99099");
+        long expectedProduct = 0;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(3);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(3);
 
         assertEquals(expectedProduct, actualProduct);
     }
     @Ignore("Remove to run test")
     @Test
     public void testSeriesLengthLongerThanLengthOfStringToTestIsRejected() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("123");
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("123");
 
         expectedException.expect(IllegalArgumentException.class);
         expectedException.expectMessage(
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfLength0ForEmptyStringToSearch() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("");
-        final long expectedProduct = 1;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("");
+        long expectedProduct = 1;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(0);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(0);
 
         assertEquals(expectedProduct, actualProduct);
     }
     @Ignore("Remove to run test")
     @Test
     public void testCorrectlyCalculatesLargestProductOfLength0ForNonEmptyStringToSearch() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("123");
-        final long expectedProduct = 1;
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("123");
+        long expectedProduct = 1;
 
-        final long actualProduct = calculator.calculateLargestProductForSeriesLength(0);
+        long actualProduct = calculator.calculateLargestProductForSeriesLength(0);
 
         assertEquals(expectedProduct, actualProduct);
     }
     @Ignore("Remove to run test")
     @Test
     public void testEmptyStringToSearchAndSeriesOfNonZeroLengthIsRejected() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("");
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("");
 
         expectedException.expect(IllegalArgumentException.class);
         expectedException.expectMessage(
     @Ignore("Remove to run test")
     @Test
     public void testNegativeSeriesLengthIsRejected() {
-        final LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("12345");
+        LargestSeriesProductCalculator calculator = new LargestSeriesProductCalculator("12345");
 
         expectedException.expect(IllegalArgumentException.class);
         expectedException.expectMessage("Series length must be non-negative.");

exercises/list-ops/.meta/version

-2.0.0
+2.2.0

exercises/markdown/.meta/version

-1.1.0
+1.2.0

exercises/minesweeper/.meta/version

-1.0.0
+1.1.0

exercises/minesweeper/src/test/java/MinesweeperBoardTest.java

 
     @Test
     public void testInputBoardWithNoRowsAndNoColumns() {
-        final List<String> inputBoard = Collections.emptyList();
-        final List<String> expectedNumberedBoard = Collections.emptyList();
-        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
+        List<String> inputBoard = Collections.emptyList();
+        List<String> expectedNumberedBoard = Collections.emptyList();
+        List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
         assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
     @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithOneRowAndNoColumns() {
-        final List<String> inputBoard = Collections.singletonList("");
-        final List<String> expectedNumberedBoard = Collections.singletonList("");
-        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
+        List<String> inputBoard = Collections.singletonList("");
+        List<String> expectedNumberedBoard = Collections.singletonList("");
+        List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
         assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
     @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithNoMines() {
-        final List<String> inputBoard = Arrays.asList(
+        List<String> inputBoard = Arrays.asList(
                 "   ",
                 "   ",
                 "   "
         );
 
-        final List<String> expectedNumberedBoard = Arrays.asList(
+        List<String> expectedNumberedBoard = Arrays.asList(
                 "   ",
                 "   ",
                 "   "
         );
 
-        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
+        List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
         assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
     @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithOnlyMines() {
-        final List<String> inputBoard = Arrays.asList(
+        List<String> inputBoard = Arrays.asList(
                 "***",
                 "***",
                 "***"
         );
 
-        final List<String> expectedNumberedBoard = Arrays.asList(
+        List<String> expectedNumberedBoard = Arrays.asList(
                 "***",
                 "***",
                 "***"
         );
 
-        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
+        List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
         assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
     @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithSingleMineAtCenter() {
-        final List<String> inputBoard = Arrays.asList(
+        List<String> inputBoard = Arrays.asList(
                 "   ",
                 " * ",
                 "   "
         );
 
-        final List<String> expectedNumberedBoard = Arrays.asList(
+        List<String> expectedNumberedBoard = Arrays.asList(
                 "111",
                 "1*1",
                 "111"
         );
 
-        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
+        List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
         assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
     @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithMinesAroundPerimeter() {
-        final List<String> inputBoard = Arrays.asList(
+        List<String> inputBoard = Arrays.asList(
                 "***",
                 "* *",
                 "***"
         );
 
-        final List<String> expectedNumberedBoard = Arrays.asList(
+        List<String> expectedNumberedBoard = Arrays.asList(
                 "***",
                 "*8*",
                 "***"
         );
 
-        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
+        List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
         assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
     @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithSingleRowAndTwoMines() {
-        final List<String> inputBoard = Collections.singletonList(
+        List<String> inputBoard = Collections.singletonList(
                 " * * "
         );
 
-        final List<String> expectedNumberedBoard = Collections.singletonList(
+        List<String> expectedNumberedBoard = Collections.singletonList(
                 "1*2*1"
         );
 
-        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
+        List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
         assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
     @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithSingleRowAndTwoMinesAtEdges() {
-        final List<String> inputBoard = Collections.singletonList(
+        List<String> inputBoard = Collections.singletonList(
                 "*   *"
         );
 
-        final List<String> expectedNumberedBoard = Collections.singletonList(
+        List<String> expectedNumberedBoard = Collections.singletonList(
                 "*1 1*"
         );
 
-        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
+        List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
         assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
     @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithSingleColumnAndTwoMines() {
-        final List<String> inputBoard = Arrays.asList(
+        List<String> inputBoard = Arrays.asList(
                 " ",
                 "*",
                 " ",
                 " "
         );
 
-        final List<String> expectedNumberedBoard = Arrays.asList(
+        List<String> expectedNumberedBoard = Arrays.asList(
                 "1",
                 "*",
                 "2",
                 "1"
         );
 
-        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
+        List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
         assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
     @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithSingleColumnAndTwoMinesAtEdges() {
-        final List<String> inputBoard = Arrays.asList(
+        List<String> inputBoard = Arrays.asList(
                 "*",
                 " ",
                 " ",
                 "*"
         );
 
-        final List<String> expectedNumberedBoard = Arrays.asList(
+        List<String> expectedNumberedBoard = Arrays.asList(
                 "*",
                 "1",
                 " ",
                 "*"
         );
 
-        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
+        List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
         assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
     @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithMinesInCross() {
-        final List<String> inputBoard = Arrays.asList(
+        List<String> inputBoard = Arrays.asList(
                 "  *  ",
                 "  *  ",
                 "*****",
                 "  *  "
         );
 
-        final List<String> expectedNumberedBoard = Arrays.asList(
+        List<String> expectedNumberedBoard = Arrays.asList(
                 " 2*2 ",
                 "25*52",
                 "*****",
                 " 2*2 "
         );
 
-        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
+        List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
         assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
     @Ignore("Remove to run test")
     @Test
     public void testLargeInputBoard() {
-        final List<String> inputBoard = Arrays.asList(
+        List<String> inputBoard = Arrays.asList(
                 " *  * ",
                 "  *   ",
                 "    * ",
                 "      "
         );
 
-        final List<String> expectedNumberedBoard = Arrays.asList(
+        List<String> expectedNumberedBoard = Arrays.asList(
                 "1*22*1",
                 "12*322",
                 " 123*2",
                 "111111"
         );
 
-        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
+        List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
         assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }

exercises/nth-prime/.meta/version

-2.0.0
+2.1.0

exercises/ocr-numbers/.meta/version

-1.0.0
+1.1.0

exercises/perfect-numbers/.meta/version

-1.0.1
+1.1.0

exercises/phone-number/src/test/java/PhoneNumberTest.java

 import static org.junit.Assert.assertEquals;
 
 public class PhoneNumberTest {
-    private final static String wrongLengthExceptionMessage = "Number must be 10 or 11 digits";
-    private final static String numberIs11DigitsButDoesNotStartWith1ExceptionMessage =
+    private static String wrongLengthExceptionMessage = "Number must be 10 or 11 digits";
+    private static String numberIs11DigitsButDoesNotStartWith1ExceptionMessage =
             "Can only have 11 digits if number starts with '1'";
-    private final static String illegalCharacterExceptionMessage =
+    private static String illegalCharacterExceptionMessage =
             "Illegal character in phone number. Only digits, spaces, parentheses, hyphens or dots accepted.";
-    private final static String illegalAreaOrExchangeCodeMessage =
+    private static String illegalAreaOrExchangeCodeMessage =
             "Illegal Area Or Exchange Code. Only 2-9 are valid digits";
 
     @Rule
 
     @Test
     public void cleansTheNumber() {
-        final String expectedNumber = "2234567890";
-        final String actualNumber = new PhoneNumber("(223) 456-7890").getNumber();
+        String expectedNumber = "2234567890";
+        String actualNumber = new PhoneNumber("(223) 456-7890").getNumber();
 
         assertEquals(
                 expectedNumber, actualNumber
     @Ignore("Remove to run test")
     @Test
     public void cleansNumbersWithDots() {
-        final String expectedNumber = "2234567890";
-        final String actualNumber = new PhoneNumber("223.456.7890").getNumber();
+        String expectedNumber = "2234567890";
+        String actualNumber = new PhoneNumber("223.456.7890").getNumber();
 
         assertEquals(
                 expectedNumber, actualNumber
     @Ignore("Remove to run test")
     @Test
     public void cleansNumbersWithMultipleSpaces() {
-        final String expectedNumber = "2234567890";
-        final String actualNumber = new PhoneNumber("223 456   7890   ").getNumber();
+        String expectedNumber = "2234567890";
+        String actualNumber = new PhoneNumber("223 456   7890   ").getNumber();
 
         assertEquals(
                 expectedNumber, actualNumber
     @Ignore("Remove to run test")
     @Test
     public void validWhen11DigitsAndStartingWith1() {
-        final String expectedNumber = "2234567890";
-        final String actualNumber = new PhoneNumber("12234567890").getNumber();
+        String expectedNumber = "2234567890";
+        String actualNumber = new PhoneNumber("12234567890").getNumber();
 
         assertEquals(
                 expectedNumber, actualNumber
     @Ignore("Remove to run test")
     @Test
     public void validWhen11DigitsAndStartingWith1EvenWithPunctuation() {
-        final String expectedNumber = "2234567890";
-        final String actualNumber = new PhoneNumber("+1 (223) 456-7890").getNumber();
+        String expectedNumber = "2234567890";
+        String actualNumber = new PhoneNumber("+1 (223) 456-7890").getNumber();
 
         assertEquals(
                 expectedNumber, actualNumber

exercises/pig-latin/README.md

 quickly it's really difficult for non-children (and non-native speakers)
 to understand.
 
-- **Rule 1**: If a word begins with a vowel sound, add an "ay" sound to
-  the end of the word.
-- **Rule 2**: If a word begins with a consonant sound, move it to the
-  end of the word, and then add an "ay" sound to the end of the word.
+- **Rule 1**: If a word begins with a vowel sound, add an "ay" sound to the end of the word. Please note that "xr" and "yt" at the beginning of a word make vowel sounds (e.g. "xray" -> "xrayay", "yttria" -> "yttriaay").
+- **Rule 2**: If a word begins with a consonant sound, move it to the end of the word and then add an "ay" sound to the end of the word. Consonant sounds can be made up of multiple consonants, a.k.a. a consonant cluster (e.g. "chair" -> "airchay").
+- **Rule 3**: If a word starts with a consonant sound followed by "qu", move it to the end of the word, and then add an "ay" sound to the end of the word (e.g. "square" -> "aresquay").
+- **Rule 4**: If a word contains a "y" after a consonant cluster or as the second letter in a two letter word it makes a vowel sound (e.g. "rhythm" -> "ythmrhay", "my" -> "ymay").
 
 There are a few more rules for edge cases, and there are regional
 variants too.

exercises/poker/.meta/src/reference/java/Card.java

     }
 
     private int parseRank(String card) {
-        return "..23456789TJQKA".indexOf(card.charAt(0));
+    	if (card.substring(0, 2).equals("10")) {
+    		return 10;
+    	}
+    	return "..23456789TJQKA".indexOf(card.charAt(0));
     }
 
     private int parseSuit(String card) {
-        return ".HSDC".indexOf(card.charAt(1));
+        return ".HSDC".indexOf(card.charAt(card.length() - 1));
     }
 }

exercises/poker/.meta/src/reference/java/Hand.java

         }
         return frequencyMap;
     }
-
+    
     private int scoreHand(List<Card> cards) {
-        List<Card> cardsByRank = cards
-                .stream()
+        List<Card> cardsByRank = cards.stream()
                 .sorted(Comparator.comparing(Card::getRank))
                 .unordered()
                 .collect(Collectors.toList());
                 .stream()
                 .map(Map.Entry::getValue)
                 .collect(Collectors.toList());
-        List<Integer> suits = cards.stream().map(Card::getSuit).collect(Collectors.toList());
+        List<Integer> suits = cards
+                .stream()
+                .map(Card::getSuit)
+                .collect(Collectors.toList());
 
         return calculatedScore(frequencyMap, cardsByRank, ranks, rankCounts, suits);
     }
             ranks = Arrays.asList(5, 4, 3, 2, 1);
         }
 
-        boolean flush = suits.stream().distinct().count() == 1;
-        boolean straight = ranks.stream().distinct().count() == 5 && ranks.get(0) - ranks.get(4) == 4;
+        boolean flush = suits
+                .stream()
+                .distinct()
+                .count() == 1;
+        boolean straight = ranks.stream().distinct().count() == 5 
+            && ranks.get(0) - ranks.get(4) == 4;
+        
         Iterator<Integer> iteratorOverFrequencies = frequencyMap.keySet().iterator();
+        
         int highestFrequency = iteratorOverFrequencies.next();
 
         if (straight && flush) {
             return 700 + cardsByRank.get(0).getRank();
         }
         if (rankCounts.equals(Arrays.asList(3, 2))) {
-            return 600 + cardsByRank.get(0).getRank();
+            int triplet = 0;
+            int pair = 0;
+            for (Integer key : frequencyMap.keySet()) {
+                if (frequencyMap.get(key) == 2) {
+                    pair = (int) key;
+                }
+                if (frequencyMap.get(key) == 3) {
+                    triplet = 3 * (int) key;
+                }
+            }
+            return 600 + 3 * triplet + pair;
         }
         if (flush) {
             return 500 + highestFrequency;
         }
         if (straight) {
-            return 400 + highestFrequency;
+            int maxValue = Collections.max(ranks);
+            return 400 + maxValue;
         }
         if (rankCounts.equals(Arrays.asList(3, 1, 1))) {
-            return 300 + cardsByRank.get(0).getRank();
+            List<Integer> uniqueCards = new ArrayList<Integer>();
+            int triplet = 0;
+            for (Integer key : frequencyMap.keySet()) {
+                if (frequencyMap.get(key) == 1) {
+                    uniqueCards.add((int) key);
+                }
+                if (frequencyMap.get(key) == 3) {
+                    triplet = 3 * (int) key;
+                }
+            }
+            return 300 + triplet + Collections.max(uniqueCards);
         }
         if (rankCounts.equals(Arrays.asList(2, 2, 1))) {
-            return 200 + Math.max(highestFrequency, iteratorOverFrequencies.next());
+            int productsOfFrequencyAndValue = 0;
+            for (Integer key : frequencyMap.keySet()) {
+                int frequencyKey = (int) key;
+                int frequencyValue = frequencyMap.get(key);
+                productsOfFrequencyAndValue += frequencyKey * frequencyValue;
+            }
+            return 200 + productsOfFrequencyAndValue + 2 * Math.max(highestFrequency, iteratorOverFrequencies.next());
         }
         if (rankCounts.equals(Arrays.asList(2, 1, 1, 1))) {
             return 100 + highestFrequency;
         }
         ranks.sort(Comparator.naturalOrder());
-        return ranks.get(0);
+        int result = 0;
+        for (int i = 0; i < ranks.size(); i++) {
+            result += ranks.get(0) * (i + 1);
+        }
+        return result + ranks.get(ranks.size() - 1);
     }
-}
+}               

exercises/poker/.meta/version.txt

+1.1.0

exercises/poker/src/test/java/PokerTest.java

 import org.junit.Test;
 
 import java.util.Arrays;
+import java.util.Collections;
 
 import static org.junit.Assert.assertEquals;
 
 public class PokerTest {
     @Test
     public void oneHand() {
-        final String hand = "4S 5S 7H 8D JC";
-        assertEquals(Arrays.asList(hand), new Poker(Arrays.asList(hand)).getBestHands());
+        String hand = "4S 5S 7H 8D JC";
+        assertEquals(Collections.singletonList(hand), new Poker(Collections.singletonList(hand)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void highestCardWins() {
+        String highest8 = "4D 5S 6S 8D 3C";
+        String highest10 = "2S 4C 7S 9H 10H";
+        String highestJ = "3S 4S 5D 6H JH";
+        assertEquals(Collections.singletonList(highestJ), new Poker(Arrays.asList(highest8, highest10, highestJ)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void tieHasMultipleWinners() {
+        String highest8 = "4D 5S 6S 8D 3C";
+        String highest10 = "2S 4C 7S 9H 10H";
+        String highestJh = "3S 4S 5D 6H JH";
+        String highestJd = "3H 4H 5C 6C JD";
+        assertEquals(Arrays.asList(highestJh, highestJd),
+                new Poker(Arrays.asList(highest8, highest10, highestJh, highestJd)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void sameHighCards() {
+        String nextHighest3 = "3S 5H 6S 8D 7H";
+        String nextHighest2 = "2S 5D 6D 8C 7S";
+        assertEquals(Collections.singletonList(nextHighest3), new Poker(Arrays.asList(nextHighest3, nextHighest2)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void nothingVsOnePair() {
-        final String nothing = "4S 5H 6S 8D JH";
-        final String pairOf4 = "2S 4H 6S 4D JH";
-        assertEquals(Arrays.asList(pairOf4), new Poker(Arrays.asList(nothing, pairOf4)).getBestHands());
+        String nothing = "4S 5H 6C 8D KH";
+        String pairOf4 = "2S 4H 6S 4D JH";
+        assertEquals(Collections.singletonList(pairOf4), new Poker(Arrays.asList(nothing, pairOf4)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void twoPairs() {
-        final String pairOf2 = "4S 2H 6S 2D JH";
-        final String pairOf4 = "2S 4H 6S 4D JH";
-        assertEquals(Arrays.asList(pairOf4), new Poker(Arrays.asList(pairOf2, pairOf4)).getBestHands());
+        String pairOf2 = "4S 2H 6S 2D JH";
+        String pairOf4 = "2S 4H 6C 4D JD";
+        assertEquals(Collections.singletonList(pairOf4), new Poker(Arrays.asList(pairOf2, pairOf4)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void onePairVsDoublePair() {
-        final String pairOf8 = "2S 8H 6S 8D JH";
-        final String doublePair = "4S 5H 4S 8D 5H";
-        assertEquals(Arrays.asList(doublePair), new Poker(Arrays.asList(pairOf8, doublePair)).getBestHands());
+        String pairOf8 = "2S 8H 6S 8D JH";
+        String doublePair = "4S 5H 4C 8C 5C";
+        assertEquals(Collections.singletonList(doublePair), new Poker(Arrays.asList(pairOf8, doublePair)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void twoDoublePairs() {
-        final String doublePair2And8 = "2S 8H 2S 8D JH";
-        final String doublePair4And5 = "4S 5H 4S 8D 5H";
-        assertEquals(Arrays.asList(doublePair2And8), new Poker(Arrays.asList(doublePair2And8, doublePair4And5)).getBestHands());
+        String doublePair2And8 = "2S 8H 2D 8D 3H";
+        String doublePair4And5 = "4S 5H 4C 8S 5D";
+        assertEquals(Collections.singletonList(doublePair2And8),
+                new Poker(Arrays.asList(doublePair2And8, doublePair4And5)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void sameHighestPair() {
+        String doublePair2AndQ = "2S QS 2C QD JH";
+        String doublePairJAndQ = "JD QH JS 8D QC";
+        assertEquals(Collections.singletonList(doublePairJAndQ),
+                new Poker(Arrays.asList(doublePairJAndQ, doublePair2AndQ)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void identicallyRankedPairs() {
+        String kicker8 = "JD QH JS 8D QC";
+        String kicker2 = "JS QS JC 2D QD";
+        assertEquals(Collections.singletonList(kicker8), new Poker(Arrays.asList(kicker8, kicker2)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void doublePairVsThree() {
-        final String doublePair2And8 = "2S 8H 2S 8D JH";
-        final String threeOf4 = "4S 5H 4S 8D 4H";
-        assertEquals(Arrays.asList(threeOf4), new Poker(Arrays.asList(doublePair2And8, threeOf4)).getBestHands());
+        String doublePair2And8 = "2S 8H 2H 8D JH";
+        String threeOf4 = "4S 5H 4C 8S 4H";
+        assertEquals(Collections.singletonList(threeOf4), new Poker(Arrays.asList(doublePair2And8, threeOf4)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void twoThrees() {
-        final String threeOf2 = "2S 2H 2S 8D JH";
-        final String threeOf1 = "4S AH AS 8D AH";
-        assertEquals(Arrays.asList(threeOf1), new Poker(Arrays.asList(threeOf2, threeOf1)).getBestHands());
+        String threeOf2 = "2S 2H 2C 8D JH";
+        String threeOf1 = "4S AH AS 8C AD";
+        assertEquals(Collections.singletonList(threeOf1), new Poker(Arrays.asList(threeOf2, threeOf1)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void sameThreesMultipleDecks() {
+        String remainingCard7 = "4S AH AS 7C AD";
+        String remainingCard8 = "4S AH AS 8C AD";
+        assertEquals(Collections.singletonList(remainingCard8),
+                new Poker(Arrays.asList(remainingCard7, remainingCard8)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void threeVsStraight() {
-        final String threeOf4 = "4S 5H 4S 8D 4H";
-        final String straight = "3S 4H 2S 6D 5H";
-        assertEquals(Arrays.asList(straight), new Poker(Arrays.asList(threeOf4, straight)).getBestHands());
+        String threeOf4 = "4S 5H 4C 8D 4H";
+        String straight = "3S 4D 2S 6D 5C";
+        assertEquals(Collections.singletonList(straight), new Poker(Arrays.asList(threeOf4, straight)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void AcesCanEndAStraight() {
+        String hand = "4S 5H 4C 8D 4H";
+        String straightEndsA = "10D JH QS KD AC";
+        assertEquals(Collections.singletonList(straightEndsA), new Poker(Arrays.asList(hand, straightEndsA)).getBestHands());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void AcesCanStartAStraight() {
+        String hand = "4S 5H 4C 8D 4H";
+        String straightStartA = "4D AH 3S 2D 5C";
+        assertEquals(Collections.singletonList(straightStartA), new Poker(Arrays.asList(hand, straightStartA)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void twoStraights() {
-        final String straightTo8 = "4S 6H 7S 8D 5H";
-        final String straightTo9 = "5S 7H 8S 9D 6H";
-        assertEquals(Arrays.asList(straightTo9), new Poker(Arrays.asList(straightTo8, straightTo9)).getBestHands());
+        String straightTo8 = "4S 6C 7S 8D 5H";
+        String straightTo9 = "5S 7H 8S 9D 6H";
+        assertEquals(Collections.singletonList(straightTo9), new Poker(Arrays.asList(straightTo8, straightTo9)).getBestHands());
+    }
 
-        final String straightTo1 = "AS QH KS TD JH";
-        final String straightTo5 = "4S AH 3S 2D 5H";
-        assertEquals(Arrays.asList(straightTo1), new Poker(Arrays.asList(straightTo1, straightTo5)).getBestHands());
+    @Ignore("Remove to run test")
+    @Test
+    public void theLowestStraightStartsWithAce() {
+        String straight = "2H 3C 4D 5D 6H";
+        String straightStartA = "4S AH 3S 2D 5H";
+        assertEquals(Collections.singletonList(straight), new Poker(Arrays.asList(straight, straightStartA)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void straightVsFlush() {
-        final String straightTo8 = "4S 6H 7S 8D 5H";
-        final String flushTo7 = "2S 4S 5S 6S 7S";
-        assertEquals(Arrays.asList(flushTo7), new Poker(Arrays.asList(straightTo8, flushTo7)).getBestHands());
+        String straightTo8 = "4C 6H 7D 8D 5H";
+        String flushTo7 = "2S 4S 5S 6S 7S";
+        assertEquals(Collections.singletonList(flushTo7), new Poker(Arrays.asList(straightTo8, flushTo7)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void twoFlushes() {
-        final String flushTo8 = "3H 6H 7H 8H 5H";
-        final String flushTo7 = "2S 4S 5S 6S 7S";
-        assertEquals(Arrays.asList(flushTo8), new Poker(Arrays.asList(flushTo8, flushTo7)).getBestHands());
+        String flushTo8 = "4H 7H 8H 9H 6H";
+        String flushTo7 = "2S 4S 5S 6S 7S";
+        assertEquals(Collections.singletonList(flushTo8), new Poker(Arrays.asList(flushTo8, flushTo7)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void flushVsFull() {
-        final String flushTo8 = "3H 6H 7H 8H 5H";
-        final String full = "4S 5H 4S 5D 4H";
-        assertEquals(Arrays.asList(full), new Poker(Arrays.asList(full, flushTo8)).getBestHands());
+        String flushTo8 = "3H 6H 7H 8H 5H";
+        String full = "4S 5H 4C 5D 4H";
+        assertEquals(Collections.singletonList(full), new Poker(Arrays.asList(full, flushTo8)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void twoFulls() {
-        final String fullOf4By9 = "4H 4S 4D 9S 9D";
-        final String fullOf5By8 = "5H 5S 5D 8S 8D";
-        assertEquals(Arrays.asList(fullOf5By8), new Poker(Arrays.asList(fullOf4By9, fullOf5By8)).getBestHands());
+        String fullOf4By9 = "4H 4S 4D 9S 9D";
+        String fullOf5By8 = "5H 5S 5D 8S 8D";
+        assertEquals(Collections.singletonList(fullOf5By8), new Poker(Arrays.asList(fullOf4By9, fullOf5By8)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void fullVsSquare() {
-        final String full = "4S 5H 4S 5D 4H";
-        final String squareOf3 = "3S 3H 2S 3D 3H";
-        assertEquals(Arrays.asList(squareOf3), new Poker(Arrays.asList(full, squareOf3)).getBestHands());
+    public void twoFullssameThripletMultipleDecks() {
+        String fullOf5By9 = "5H 5S 5D 9S 9D";
+        String fullOf5By8 = "5H 5S 5D 8S 8D";
+        assertEquals(Collections.singletonList(fullOf5By9), new Poker(Arrays.asList(fullOf5By9, fullOf5By8)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void twoSquares() {
-        final String squareOf2 = "2S 2H 2S 8D 2H";
-        final String squareOf5 = "4S 5H 5S 5D 5H";
-        assertEquals(Arrays.asList(squareOf5), new Poker(Arrays.asList(squareOf2, squareOf5)).getBestHands());
+    public void fullVsSquare() {
+        String full = "4S 5H 4D 5D 4H";
+        String squareOf3 = "3S 3H 2S 3D 3C";
+        assertEquals(Collections.singletonList(squareOf3), new Poker(Arrays.asList(full, squareOf3)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void squareVsStraightFlush() {
-        final String squareOf5 = "4S 5H 5S 5D 5H";
-        final String straightFlushTo9 = "5S 7S 8S 9S 6S";
-        assertEquals(Arrays.asList(straightFlushTo9), new Poker(Arrays.asList(squareOf5, straightFlushTo9)).getBestHands());
+    public void twoSquares() {
+        String squareOf2 = "2S 2H 2C 8D 2D";
+        String squareOf5 = "4S 5H 5S 5D 5C";
+        assertEquals(Collections.singletonList(squareOf5), new Poker(Arrays.asList(squareOf2, squareOf5)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void twoStraightFlushes() {
-        final String straightFlushTo8 = "4H 6H 7H 8H 5H";
-        final String straightFlushTo9 = "5S 7S 8S 9S 6S";
-        assertEquals(Arrays.asList(straightFlushTo9), new Poker(Arrays.asList(straightFlushTo8, straightFlushTo9)).getBestHands());
+    public void sameSquaresMultipleDecks() {
+        String kicker2 = "3S 3H 2S 3D 3C";
+        String kicker4 = "3S 3H 4S 3D 3C";
+        assertEquals(Collections.singletonList(kicker4), new Poker(Arrays.asList(kicker2, kicker4)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void threeHandWithTie() {
-        final String spadeStraightTo9 = "9S 8S 7S 6S 5S";
-        final String diamondStraightTo9 = "9D 8D 7D 6D 5D";
-        final String threeOf4 = "4D 4S 4H QS KS";
-        assertEquals(Arrays.asList(spadeStraightTo9, diamondStraightTo9), new Poker(Arrays.asList(spadeStraightTo9, diamondStraightTo9, threeOf4)).getBestHands());
+    public void squareVsStraightFlush() {
+        String squareOf5 = "4S 5H 5S 5D 5C";
+        String straightFlushTo9 = "7S 8S 9S 6S 10S";
+        assertEquals(Collections.singletonList(straightFlushTo9),
+                new Poker(Arrays.asList(squareOf5, straightFlushTo9)).getBestHands());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void straightTo5AgainstAPairOfJacks() {
-        final String straightTo5 = "2S 4D 5C 3S AS";
-        final String twoJacks = "JD 8D 7D JC 5D";
-        assertEquals(Arrays.asList(straightTo5), new Poker(Arrays.asList(straightTo5, twoJacks)).getBestHands());
+    public void twoStraightFlushes() {
+        String straightFlushTo8 = "4H 6H 7H 8H 5H";
+        String straightFlushTo9 = "5S 7S 8S 9S 6S";
+        assertEquals(Collections.singletonList(straightFlushTo9),
+                new Poker(Arrays.asList(straightFlushTo8, straightFlushTo9)).getBestHands());
     }
 }

exercises/pythagorean-triplet/src/test/java/PythagoreanTripletTest.java

     @Test
     public void shouldCalculateSum() {
         PythagoreanTriplet triplet = new PythagoreanTriplet(3, 4, 5);
-        final int expected = 12;
-        final int actual = triplet.calculateSum();
+        int expected = 12;
+        int actual = triplet.calculateSum();
         assertEquals(expected, actual);
     }
 
     @Test
     public void shouldCalculateProduct() {
         PythagoreanTriplet triplet = new PythagoreanTriplet(3, 4, 5);
-        final long expected = 60l;
-        final long actual = triplet.calculateProduct();
+        long expected = 60l;
+        long actual = triplet.calculateProduct();
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void shouldMakeTripletsUpToTen() {
-        final List<Long> actual
+        List<Long> actual
                 = PythagoreanTriplet
                         .makeTripletsList()
                         .withFactorsLessThanOrEqualTo(10)
                         .map(t -> t.calculateProduct())
                         .sorted()
                         .collect(Collectors.toList());
-        final List<Long> expected = Arrays.asList(60l, 480l);
+        List<Long> expected = Arrays.asList(60l, 480l);
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void shouldMakeTripletsElevenToTwenty() {
-        final List<Long> actual
+        List<Long> actual
                 = PythagoreanTriplet
                         .makeTripletsList()
                         .withFactorsGreaterThanOrEqualTo(11)
                         .map(t -> t.calculateProduct())
                         .sorted((p1, p2) -> Double.compare(p1, p2))
                         .collect(Collectors.toList());
-        final List<Long> expected = Arrays.asList(3840l);
+        List<Long> expected = Arrays.asList(3840l);
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void shouldMakeTripletsAndFilterOnSum() {
-        final List<Long> actual
+        List<Long> actual
                 = PythagoreanTriplet
                         .makeTripletsList()
                         .withFactorsLessThanOrEqualTo(100)
                         .map(t -> t.calculateProduct())
                         .sorted((p1, p2) -> Double.compare(p1, p2))
                         .collect(Collectors.toList());
-        final List<Long> expected = Arrays.asList(118080l, 168480l, 202500l);
+        List<Long> expected = Arrays.asList(118080l, 168480l, 202500l);
         assertEquals(expected, actual);
     }
 }

exercises/queen-attack/.meta/src/reference/java/BoardCoordinate.java

-final class BoardCoordinate {
-
-    private final int row;
-
-    private final int column;
-
-    BoardCoordinate(final int row, final int column) throws IllegalArgumentException {
-        this.row = row;
-        this.column = column;
-
-        validateInputs();
-    }
-
-    int getRow() {
-        return row;
-    }
-
-    int getColumn() {
-        return column;
-    }
-
-    private void validateInputs() throws IllegalArgumentException {
-        validateCoordinateComponent(row, "row");
-        validateCoordinateComponent(column, "column");
-    }
-
-    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.");
-        }
-    }
-
-}

exercises/queen-attack/.meta/src/reference/java/Queen.java

+final class Queen {
+
+    private final int row;
+
+    private final int column;
+
+    Queen(final int row, final int column) {
+        this.row = row;
+        this.column = column;
+
+        validatePosition();
+    }
+
+    int getRow() {
+        return row;
+    }
+
+    int getColumn() {
+        return column;
+    }
+
+    private void validatePosition() {
+        validatePositionComponent(row, "row");
+        validatePositionComponent(column, "column");
+    }
+
+    private void validatePositionComponent(final int value, final String componentName) {
+
+        if (value < 0) {
+            throw new IllegalArgumentException("Queen position must have positive " + componentName + ".");
+        }
+
+        if (value > 7) {
+            throw new IllegalArgumentException("Queen position must have " + componentName + " <= 7.");
+        }
+    }
+
+}

exercises/queen-attack/.meta/src/reference/java/QueenAttackCalculator.java

 final class QueenAttackCalculator {
 
-    private final BoardCoordinate whiteQueenCoordinate;
+    private final Queen whiteQueen;
 
-    private final BoardCoordinate blackQueenCoordinate;
+    private final Queen blackQueen;
 
-    QueenAttackCalculator(final BoardCoordinate whiteQueenCoordinate, final BoardCoordinate blackQueenCoordinate)
-            throws IllegalArgumentException {
+    QueenAttackCalculator(final Queen whiteQueen, final Queen blackQueen) {
 
-        this.whiteQueenCoordinate = whiteQueenCoordinate;
-        this.blackQueenCoordinate = blackQueenCoordinate;
+        this.whiteQueen = whiteQueen;
+        this.blackQueen = blackQueen;
 
         validateInputs();
     }
         return queensShareColumn() || queensShareRow() || queensShareDiagonal();
     }
 
-    private void validateInputs() throws IllegalArgumentException {
-        if (whiteQueenCoordinate == null || blackQueenCoordinate == null) {
-            throw new IllegalArgumentException("You must supply valid board coordinates for both Queens.");
+    private void validateInputs() {
+        if (whiteQueen == null || blackQueen == null) {
+            throw new IllegalArgumentException("You must supply valid positions for both Queens.");
         }
 
         if (queensShareBoardCoordinate()) {
-            throw new IllegalArgumentException("Queens may not occupy the same board coordinate.");
+            throw new IllegalArgumentException("Queens cannot occupy the same position.");
         }
     }
 
     }
 
     private int differenceBetweenRows() {
-        return Math.abs(whiteQueenCoordinate.getRow() - blackQueenCoordinate.getRow());
+        return Math.abs(whiteQueen.getRow() - blackQueen.getRow());
     }
 
     private int differenceBetweenColumns() {
-        return Math.abs(whiteQueenCoordinate.getColumn() - blackQueenCoordinate.getColumn());
+        return Math.abs(whiteQueen.getColumn() - blackQueen.getColumn());
     }
 
 }

exercises/queen-attack/.meta/version

-2.0.0
+2.1.0

exercises/queen-attack/src/test/java/QueenAttackCalculatorTest.java

     public ExpectedException expectedException = ExpectedException.none();
 
     @Test
-    public void testQueensThatDoNotShareRowColumnOrDiagonalCannotAttack() {
-        final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 4), new BoardCoordinate(6, 6));
+    public void testCreateQueenWithAValidPosition() {
+        new Queen(2, 2);
+    }
 
-        assertFalse(calculator.canQueensAttackOneAnother());
+    @Ignore("Remove to run test")
+    @Test
+    public void testCreateQueenMustHavePositiveRow() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Queen position must have positive row.");
+
+        new Queen(-2, 2);
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testQueensCanAttackOnTheSameRow() {
-        final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 4), new BoardCoordinate(2, 6));
+    public void testCreateQueenMustHaveRowOnBoard() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Queen position must have row <= 7.");
 
-        assertTrue(calculator.canQueensAttackOneAnother());
+        new Queen(8, 4);
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testQueensCanAttackOnTheSameColumn() {
-        final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(4, 5), new BoardCoordinate(2, 5));
+    public void testCreateQueenMustHavePositiveColumn() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Queen position must have positive column.");
 
-        assertTrue(calculator.canQueensAttackOneAnother());
+        new Queen(2, -2);
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testQueensCanAttackOnFirstDiagonal() {
-        final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(0, 4));
+    public void testCreateQueenMustHaveColumnOnBoard() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Queen position must have column <= 7.");
 
-        assertTrue(calculator.canQueensAttackOneAnother());
+        new Queen(4, 8);
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testQueensCanAttackOnSecondDiagonal() {
+    public void testQueensCannotAttack() {
         final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(3, 1));
+                = new QueenAttackCalculator(new Queen(2, 4), new Queen(6, 6));
 
-        assertTrue(calculator.canQueensAttackOneAnother());
+        assertFalse(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testQueensCanAttackOnThirdDiagonal() {
+    public void testQueensCanAttackOnTheSameRow() {
         final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(1, 1));
+                = new QueenAttackCalculator(new Queen(2, 4), new Queen(2, 6));
 
         assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testQueensCanAttackOnFourthDiagonal() {
+    public void testQueensCanAttackOnTheSameColumn() {
         final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(5, 5));
+                = new QueenAttackCalculator(new Queen(4, 5), new Queen(2, 5));
 
         assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testCoordinateWithNegativeRowNotAllowed() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Coordinate must have positive row.");
+    public void testQueensCanAttackOnFirstDiagonal() {
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new Queen(2, 2), new Queen(0, 4));
 
-        new BoardCoordinate(-2, 2);
+        assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testCoordinateWithRowGreaterThan7NotAllowed() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Coordinate must have row <= 7.");
+    public void testQueensCanAttackOnSecondDiagonal() {
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new Queen(2, 2), new Queen(3, 1));
 
-        new BoardCoordinate(8, 4);
+        assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testCoordinateWithNegativeColumnNotAllowed() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Coordinate must have positive column.");
+    public void testQueensCanAttackOnThirdDiagonal() {
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new Queen(2, 2), new Queen(1, 1));
 
-        new BoardCoordinate(2, -2);
+        assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testCoordinateWithColumnGreaterThan7NotAllowed() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Coordinate must have column <= 7.");
+    public void testQueensCanAttackOnFourthDiagonal() {
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new Queen(2, 2), new Queen(5, 5));
 
-        new BoardCoordinate(4, 8);
+        assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testNullCoordinateNotAllowed() {
+    public void testNullPositionsNotAllowed() {
         expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("You must supply valid board coordinates for both Queens.");
+        expectedException.expectMessage("You must supply valid positions for both Queens.");
 
-        new QueenAttackCalculator(null, new BoardCoordinate(0, 7));
+        new QueenAttackCalculator(null, new Queen(0, 7));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testQueensMustNotOccupyTheSameSquare() {
         expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Queens may not occupy the same board coordinate.");
+        expectedException.expectMessage("Queens cannot occupy the same position.");
 
-        new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(2, 2));
+        new QueenAttackCalculator(new Queen(2, 2), new Queen(2, 2));
     }
 
 }

exercises/rectangles/.meta/version

-1.0.0
+1.1.0

exercises/rectangles/src/test/java/RectangleCounterTest.java

     }
 
     @Test
-    public void testInputWithNoColumnsContainsNoRectangles() {
+    public void testInputWithNoRowsContainsNoRectangles() {
         String[] inputGrid = new String[]{};
 
         assertEquals(0, rectangleCounter.countRectangles(inputGrid));
     }
+    
+    @Ignore("Remove to run test")
+    @Test
+    public void testInputWithNoColumnsContainsNoRectangles() {
+        String[] inputGrid = new String[]{""};
 
+        assertEquals(0, rectangleCounter.countRectangles(inputGrid));
+    }
+    
     @Ignore("Remove to run test")
     @Test
     public void testNonTrivialInputWithNoRectangles() {

exercises/rna-transcription/.meta/hints.md

+For more help on how to solve this exercise, please refer to the tutorial provided as part of the hello world exercise:
+[TUTORIAL.md](https://github.com/exercism/java/blob/master/exercises/hello-world/TUTORIAL.md)

exercises/rna-transcription/README.md

 * `T` -> `A`
 * `A` -> `U`
 
+# Java Tips
+
+For more help on how to solve this exercise, please refer to the tutorial provided as part of the hello world exercise:
+[TUTORIAL.md](https://github.com/exercism/java/blob/master/exercises/hello-world/TUTORIAL.md)
+
+
 # Running the tests
 
 You can run all the tests for an exercise by entering

exercises/robot-simulator/.meta/version

-1.0.0
+2.2.0

exercises/robot-simulator/src/test/java/RobotTest.java

 public class RobotTest {
 
     @Test
-    public void testRobotIsCreatedWithCorrectInitialPositionAndOrientation() {
+    public void robotIsCreatedWithInitialPositionAndOrientation() {
         final Orientation initialOrientation = Orientation.NORTH;
         final GridPosition initialGridPosition = new GridPosition(0, 0);
         final Robot robot = new Robot(initialGridPosition, initialOrientation);

exercises/roman-numerals/.meta/version

-1.0.0
+1.2.0

exercises/roman-numerals/src/test/java/RomanNumeralsTest.java

         romanNumeral = new RomanNumeral(48);
         assertEquals("XLVIII", romanNumeral.getRomanNumeral());
     }
+    
+    @Ignore("Remove to run test")
+    @Test
+    public void test49ToRomanNumberXLIX() {
+        romanNumeral = new RomanNumeral(49);
+        assertEquals("XLIX", romanNumeral.getRomanNumeral());
+    }
 
     @Ignore("Remove to run test")
     @Test

exercises/saddle-points/.meta/version

-1.0.0
+1.1.0

exercises/series/README.md

 # Series
 
 Given a string of digits, output all the contiguous substrings of length `n` in
-that string.
+that string in the order that they appear.
 
 For example, the string "49142" has the following 3-digit series:
 
-- 491
-- 914
-- 142
+- "491"
+- "914"
+- "142"
 
 And the following 4-digit series:
 
-- 4914
-- 9142
+- "4914"
+- "9142"
 
 And if you ask for a 6-digit series from a 5-digit string, you deserve
 whatever you get.

exercises/settings.gradle

 include 'diamond'
 include 'difference-of-squares'
 include 'diffie-hellman'
+include 'dominoes'
+include 'error-handling'
 include 'etl'
 include 'flatten-array'
 include 'food-chain'
 include 'forth'
 include 'gigasecond'
+include 'go-counting'
 include 'grade-school'
+include 'grep'
 include 'hamming'
 include 'hexadecimal'
 include 'hello-world'
 include 'twelve-days'
 include 'two-bucket'
 include 'two-fer'
+include 'variable-length-quantity'
 include 'word-count'
 include 'word-search'
 include 'wordy'

exercises/sieve/README.md

 
 The Sieve of Eratosthenes is a simple, ancient algorithm for finding all
 prime numbers up to any given limit. It does so by iteratively marking as
-composite (i.e. not prime) the multiples of each prime,
-starting with the multiples of 2.
+composite (i.e. not prime) the multiples of each prime, starting with the
+multiples of 2. It does not use any division or remainder operation.
 
 Create your range, starting at two and continuing up to and including the given limit. (i.e. [2, limit])
 
 
 Notice that this is a very specific algorithm, and the tests don't check
 that you've implemented the algorithm, only that you've come up with the
-correct list of primes.
+correct list of primes. A good first test is to check that you do not use
+division or remainder operations (div, /, mod or % depending on the
+language).
 
 # Running the tests
 

exercises/sublist/.meta/version

-1.0.0
+1.1.0

exercises/tournament/.meta/version

-1.3.0
+1.4.0

exercises/variable-length-quantity/.meta/src/reference/java/VariableLengthQuantity.java

+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+class VariableLengthQuantity {
+
+    private long sevenBitsMask = 0x7f;
+    private long eightBitsMask = 0x80;
+
+    List<String> encodeSingleNumber(long number) {
+        List<String> bytes = new ArrayList<String>();
+        bytes.add("0x" + Long.toHexString(number & sevenBitsMask));
+        number >>= 7;
+
+        while (number > 0) {
+            bytes.add("0x" + Long.toHexString(number & sevenBitsMask | eightBitsMask));
+            number >>= 7;
+        }
+
+        Collections.reverse(bytes);
+        return bytes;
+    }
+
+    List<String> encode(List<Long> numbers) {
+        List<String> bytes = new ArrayList<String>();
+        for (long number : numbers) {
+            bytes.addAll(encodeSingleNumber(number));
+        }
+
+        return bytes;
+    }
+
+    List<String> decode(List<Long> bytes) {
+        List<String> numbers = new ArrayList<String>();
+        int i = 0;
+        long number = 0;
+
+        for (long b : bytes) {
+            number <<= 7;
+            number += b & sevenBitsMask;
+
+            if ((b & eightBitsMask) == 0) {
+                numbers.add("0x" + Long.toHexString(number));
+                number = 0;
+                i++;
+            } else if (i == bytes.size() - 1) {
+                throw new IllegalArgumentException("Invalid variable-length quantity encoding");
+            }
+        }
+
+        return numbers;
+    }
+}

exercises/variable-length-quantity/.meta/version

+1.1.0