Merge branch 'master' into BinarySearchUseGenerics

CONTRIBUTING.md

   * [The Problem Submodules](#the-problem-submodules)
 * [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)
 
 ## Overview
 
 
 If, at any point, you're having any trouble, pop in the [Gitter exercism/java room](https://gitter.im/exercism/java) or the [Gitter exercism/dev room](https://gitter.im/exercism/dev) for help.
 
+For general guidelines about contributing to Exercism see the [Exercism contributing guide](https://github.com/exercism/docs/tree/master/contributing-to-language-tracks).
 
 ## Before Making Your Pull Request
 
 cd ~/workspace/exercism/exercises
 exercism fetch java bob
 ```
+
+## Adding a New Exercise
+
+The easiest way to add a new exercise to the Java track is to port an exercise from another track.
+That means that you take an exercise that has already been implemented in another language and you implement it in this track.
+
+To add a completely new exercise you need to open a pull request to the [problem specifications repository](https://github.com/exercism/problem-specifications/tree/master/exercises).
+Any completely new exercise needs to be added and accepted there before it can be added to the Java track.
+
+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.
+
+The Java specific details you need to know about adding an exercise are:
+
+1. Please add an entry to the `exercises` array in `config.json`. You can find details about what should be in that entry [here](https://github.com/exercism/docs/blob/master/language-tracks/configuration/exercises.md).
+You can also look at other entries in `config.json` as examples and try to mimic them.
+
+2. Please add an entry for your exercise to `settings.gradle`.
+This should just be `include 'exercise-name'`.
+This list is in alphabetical order so please add your exercise so that it maintains this order.
+
+3. Please add an exercise submodule for your exercise.
+See [The Problem Submodules](#the-problem-submodules) section for what needs to be in this.
+The `build.gradle` file can just be copied from any other exercise submodule.
+See the [POLICIES doc](https://github.com/exercism/java/blob/master/POLICIES.md#starter-implementations) for an explanation of when you need to add a starter implementation.
+
+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.

config.json

       "core": true,
       "difficulty": 4,
       "slug": "matrix",
-      "topics": null,
+      "topics": [
+        "loops",
+        "arrays",
+        "pattern_matching",
+        "integers",
+        "strings",
+        "type_conversion"
+      ],
       "unlocked_by": null,
       "uuid": "c1d4e0b4-6a0f-4be9-8222-345966621f53"
     },
       "core": false,
       "difficulty": 4,
       "slug": "sieve",
-      "topics": null,
+      "topics": [
+        "loops",
+        "lists",
+        "integers",
+        "algorithms",
+        "mathematics"
+      ],
       "unlocked_by": "difference-of-squares",
       "uuid": "6791d01f-bae4-4b63-ae76-86529ac49e36"
     },
       "core": true,
       "difficulty": 4,
       "slug": "rotational-cipher",
-      "topics": null,
+      "topics": [
+        "integers",
+        "strings",
+        "cryptography"
+      ],
       "unlocked_by": null,
       "uuid": "9eb41883-55ef-4681-b5ac-5c2259302772"
     },
       "core": false,
       "difficulty": 4,
       "slug": "kindergarten-garden",
-      "topics": null,
+      "topics": [
+        "loops",
+        "arrays",
+        "strings",
+        "logic",
+        "pattern_recognition",
+        "enumerations",
+        "lists"
+      ],
       "unlocked_by": "matrix",
       "uuid": "0b92ffee-c092-4ab1-ad78-76c8cf80e1b5"
     },
       "core": false,
       "difficulty": 4,
       "slug": "collatz-conjecture",
-      "topics": null,
+      "topics": [
+        "exception_handling",
+        "recursion",
+        "conditionals",
+        "integers",
+        "mathematics"
+      ],
       "unlocked_by": "triangle",
       "uuid": "1500d39a-c9d9-4d3a-9e77-fdc1837fc6ad"
     },
       "core": false,
       "difficulty": 4,
       "slug": "nth-prime",
-      "topics": null,
+      "topics": [
+        "arrays",
+        "exception_handling",
+        "lists",
+        "loops",
+        "integers"
+      ],
       "unlocked_by": "triangle",
       "uuid": "2c69db99-648d-4bd7-8012-1fbdeff6ca0a"
     },
       "core": true,
       "difficulty": 4,
       "slug": "saddle-points",
-      "topics": null,
+      "topics": [
+        "arrays",
+        "conditionals",
+        "integers",
+        "lists",
+        "loops",
+        "mathematics",
+        "matrices",
+        "sets"
+      ],
       "unlocked_by": null,
       "uuid": "8dfc2f0d-1141-46e9-95e2-6f35ccf6f160"
     },
       "difficulty": 4,
       "slug": "diamond",
       "topics": [
-		"strings",
-		"loops",
-		"arrays",
-		"lists",
-		"text_formatting"
-		],
+        "strings",
+        "loops",
+        "arrays",
+        "lists",
+        "text_formatting"
+      ],
       "unlocked_by": "two-fer",
       "uuid": "ecbd997b-86f4-4e11-9ff0-706ac2899415"
     },
       "core": true,
       "difficulty": 5,
       "slug": "flatten-array",
-      "topics": null,
+      "topics": [
+        "arrays",
+        "lists",
+        "loops",
+        "recursion"
+      ],
       "unlocked_by": null,
       "uuid": "a732a838-8170-458a-a85e-d6b4c46f97a1"
     },
       "core": true,
       "difficulty": 5,
       "slug": "word-count",
-      "topics": null,
+      "topics": [
+        "strings",
+        "maps",
+        "loops",
+        "conditionals",
+        "integers"
+      ],
       "unlocked_by": null,
       "uuid": "3603b770-87a5-4758-91f3-b4d1f9075bc1"
     },
       "core": true,
       "difficulty": 5,
       "slug": "robot-name",
-      "topics": null,
+      "topics": [
+        "regular_expressions",
+        "strings",
+        "randomness",
+        "text_formatting",
+        "pattern_matching"
+      ],
       "unlocked_by": null,
       "uuid": "d7c2eed9-64c7-4c4a-b45d-c787d460337f"
     },
       "core": false,
       "difficulty": 5,
       "slug": "prime-factors",
-      "topics": null,
+      "topics": [
+        "arrays",
+        "conditionals",
+        "integers",
+        "lists",
+        "loops",
+        "mathematics"
+      ],
       "unlocked_by": "triangle",
       "uuid": "599c08ec-7338-46ed-99f8-a76f78f724e6"
     },
       "core": false,
       "difficulty": 5,
       "slug": "bracket-push",
-      "topics": null,
+      "topics": [
+        "stacks",
+        "strings"
+      ],
       "unlocked_by": "flatten-array",
       "uuid": "85aa50ac-0141-49eb-bc6f-62f3f7a97647"
     },
       "core": false,
       "difficulty": 5,
       "slug": "atbash-cipher",
-      "topics": null,
+      "topics": [
+        "strings",
+        "cryptography",
+        "security"
+      ],
       "unlocked_by": "rotational-cipher",
       "uuid": "d36ce010-210f-4e9a-9d6c-cb933e0a59af"
     },
       "difficulty": 6,
       "slug": "food-chain",
       "topics": [
-       	"arrays",
-       	"lists",
-       	"strings"
-       ],
+        "arrays",
+        "lists",
+        "strings"
+      ],
       "unlocked_by": "two-fer",
       "uuid": "dd3e6fd6-5359-4978-acd7-c39374cead4d"
     },
       "core": false,
       "difficulty": 6,
       "slug": "grade-school",
-      "topics": null,
+      "topics": [
+        "conditionals",
+        "strings",
+        "lists",
+        "maps",
+        "sorting"
+      ],
       "unlocked_by": "word-count",
       "uuid": "b4af5da1-601f-4b0f-bfb8-4a381851090c"
     },
       "core": false,
       "difficulty": 6,
       "slug": "robot-simulator",
-      "topics": null,
+      "topics": [
+        "classes",
+        "logic",
+        "loops",
+        "enumerations"
+      ],
       "unlocked_by": "secret-handshake",
       "uuid": "993bde9d-7774-4e7a-a381-9eee75f28ecb"
     },
       "core": false,
       "difficulty": 6,
       "slug": "all-your-base",
-      "topics": null,
+      "topics": [
+        "loops",
+        "mathematics",
+        "integers",
+        "arrays",
+        "conditionals",
+        "exception_handling"
+      ],
       "unlocked_by": "saddle-points",
       "uuid": "f7c2e4b5-1995-4dfe-b827-c9aff8ac5332"
     },
       "core": true,
       "difficulty": 6,
       "slug": "linked-list",
-      "topics": null,
+      "topics": [
+        "algorithms",
+        "lists",
+        "generics"
+      ],
       "unlocked_by": null,
       "uuid": "7ba5084d-3b75-4406-a0d7-87c26387f9c0"
     },
     {
       "core": false,
+      "difficulty": 6,
+      "slug": "tournament",
+      "topics": [
+        "loops",
+        "maps",
+        "sorting",
+        "parsing",
+        "text_formatting"
+      ],
+      "unlocked_by": "matrix",
+      "uuid": "99191d53-0fed-f680-de7a-55cfb872de17bc58629"
+    },
+    {
+      "core": false,
       "difficulty": 7,
       "slug": "anagram",
       "topics": [
       "core": false,
       "difficulty": 7,
       "slug": "sublist",
-      "topics": null,
+      "topics": [
+        "lists",
+        "searching",
+        "loops",
+        "generics",
+        "enumeration"
+      ],
       "unlocked_by": "linked-list",
       "uuid": "d2aedbd7-092a-43d0-8a5e-ae3ebd5b9c7f"
     },
       "core": false,
       "difficulty": 7,
       "slug": "meetup",
-      "topics": null,
+      "topics": [
+        "conditionals",
+        "dates",
+        "loops",
+        "enumerations"
+      ],
       "unlocked_by": "gigasecond",
       "uuid": "602511d5-7e89-4def-b072-4dd311816810"
     },
       "core": false,
       "difficulty": 7,
       "slug": "crypto-square",
-      "topics": null,
+      "topics": [
+        "strings",
+        "text_formatting",
+        "mathematics",
+        "cryptography",
+        "security",
+        "lists"
+      ],
       "unlocked_by": "rotational-cipher",
       "uuid": "162bebdc-9bf2-43c0-8460-a91f5fc16147"
     },
       "core": false,
       "difficulty": 7,
       "slug": "clock",
-      "topics": null,
+      "topics": [
+        "equality",
+        "integers",
+        "logic",
+        "object_oriented_programming",
+        "strings",
+        "time"
+      ],
       "unlocked_by": "saddle-points",
       "uuid": "97c8fcd4-85b6-41cb-9de2-b4e1b4951222"
     },
       "core": false,
       "difficulty": 8,
       "slug": "book-store",
-      "topics": null,
+      "topics": [
+        "integers",
+        "lists",
+        "algorithms",
+        "mathematics",
+        "floating_point_numbers"
+      ],
       "unlocked_by": "flatten-array",
       "uuid": "e5f05d00-fe5b-4d78-b2fa-934c1c9afb32"
     },
       "core": false,
       "difficulty": 8,
       "slug": "simple-cipher",
-      "topics": null,
+      "topics": [
+        "strings",
+        "cryptography",
+        "security",
+        "mathematics",
+        "randomness",
+        "exception_handling"
+      ],
       "unlocked_by": "rotational-cipher",
       "uuid": "f654831f-c34b-44f5-9dd5-054efbb486f2"
     },
       "core": false,
       "difficulty": 8,
       "slug": "complex-numbers",
-      "topics": null,
+      "topics": [
+        "mathematics",
+        "floating_point_numbers",
+        "classes"
+      ],
       "unlocked_by": "triangle",
       "uuid": "52d11278-0d65-4b5b-b387-1374fced3243"
     },
       "core": false,
       "difficulty": 8,
       "slug": "change",
-      "topics": null,
+      "topics": [
+        "algorithms",
+        "integers",
+        "exception_handling",
+        "lists"
+      ],
       "unlocked_by": "flatten-array",
       "uuid": "bac1f4bc-eea9-43c1-8e95-097347f5925e"
     },
       "core": false,
       "difficulty": 8,
       "slug": "palindrome-products",
-      "topics": null,
+      "topics": [
+        "conditionals",
+        "integers",
+        "lists",
+        "loops",
+        "maps",
+        "mathematics"
+      ],
       "unlocked_by": "saddle-points",
       "uuid": "873c05de-b5f5-4c5b-97f0-d1ede8a82832"
     },

config/maintainers.json

     },
     {
       "alumnus": false,
-      "avatar_url": null,
-      "bio": null,
+      "bio": "I'm a software developer working for Softwire, a UK based software company. I love programming in pretty much any language (possibly with the exception of C++) but Java is probably the language I have the most experience with.",
       "github_username": "FridaTveit",
-      "link_text": null,
-      "link_url": null,
-      "name": null,
-      "show_on_website": false
+      "name": "Frida Johanne Tveit",
+      "show_on_website": true
     }
   ]
-}
+}

exercises/binary-search-tree/.meta/src/reference/java/BST.java → exercises/binary-search-tree/.meta/src/reference/java/BinarySearchTree.java

 import java.util.List;
 import java.util.Queue;
 
-public class BST<T extends Comparable<T>> {
+public class BinarySearchTree<T extends Comparable<T>> {
 
     public static class Node<T> {
 

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

 import static org.junit.Assert.assertNotNull;
 import org.junit.Ignore;
 import org.junit.Test;
+import org.junit.Before;
 
-public class BSTTest {
+public class BinarySearchTreeTest {
+    private BinarySearchTree<Integer> binarySearchTree;
+
+    @Before
+    public void setUp() {
+        binarySearchTree = new BinarySearchTree<>();
+    }
 
     @Test
     public void dataIsRetained() {
-        BST<Integer> bst = new BST<>();
         final int actual = 4;
-        bst.insert(actual);
-        final BST.Node<Integer> root = bst.getRoot();
+        binarySearchTree.insert(actual);
+        final BinarySearchTree.Node<Integer> root = binarySearchTree.getRoot();
         assertNotNull(root);
         final int expected = root.getData();
         assertEquals(expected, actual);
     @Ignore("Remove to run test")
     @Test
     public void insertsLess() {
-        BST<Integer> bst = new BST<>();
         final int expectedRoot = 4;
         final int expectedLeft = 2;
 
-        bst.insert(expectedRoot);
-        bst.insert(expectedLeft);
+        binarySearchTree.insert(expectedRoot);
+        binarySearchTree.insert(expectedLeft);
 
-        final BST.Node<Integer> root = bst.getRoot();
+        final BinarySearchTree.Node<Integer> root = binarySearchTree.getRoot();
         assertNotNull(root);
-        final BST.Node<Integer> left = root.getLeft();
+        final BinarySearchTree.Node<Integer> left = root.getLeft();
         assertNotNull(left);
 
         final int actualRoot = root.getData();
     @Ignore("Remove to run test")
     @Test
     public void insertsSame() {
-        BST<Integer> bst = new BST<>();
         final int expectedRoot = 4;
         final int expectedLeft = 4;
 
-        bst.insert(expectedRoot);
-        bst.insert(expectedLeft);
+        binarySearchTree.insert(expectedRoot);
+        binarySearchTree.insert(expectedLeft);
 
-        final BST.Node<Integer> root = bst.getRoot();
+        final BinarySearchTree.Node<Integer> root = binarySearchTree.getRoot();
         assertNotNull(root);
-        final BST.Node<Integer> left = root.getLeft();
+        final BinarySearchTree.Node<Integer> left = root.getLeft();
         assertNotNull(left);
 
         final int actualRoot = root.getData();
     @Ignore("Remove to run test")
     @Test
     public void insertsRight() {
-        BST<Integer> bst = new BST<>();
         final int expectedRoot = 4;
         final int expectedRight = 5;
 
-        bst.insert(expectedRoot);
-        bst.insert(expectedRight);
+        binarySearchTree.insert(expectedRoot);
+        binarySearchTree.insert(expectedRight);
 
-        final BST.Node<Integer> root = bst.getRoot();
+        final BinarySearchTree.Node<Integer> root = binarySearchTree.getRoot();
         assertNotNull(root);
-        final BST.Node<Integer> right = root.getRight();
+        final BinarySearchTree.Node<Integer> right = root.getRight();
         assertNotNull(right);
 
         final int actualRoot = root.getData();
     @Ignore("Remove to run test")
     @Test
     public void createsComplexTree() {
-        BST<Integer> bst = new BST<>();
         List<Integer> expected = Collections.unmodifiableList(
                 Arrays.asList(4, 2, 6, 1, 3, 5, 7)
         );
         List<Integer> treeData = Collections.unmodifiableList(
                 Arrays.asList(4, 2, 6, 1, 3, 7, 5)
         );
-        treeData.forEach(bst::insert);
+        treeData.forEach(binarySearchTree::insert);
 
-        List<Integer> actual = bst.getAsLevelOrderList();
+        List<Integer> actual = binarySearchTree.getAsLevelOrderList();
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void sortsSingleElement() {
-        BST<Integer> bst = new BST<>();
         List<Integer> expected = Collections.unmodifiableList(
                 Collections.singletonList(4)
         );
 
-        bst.insert(4);
+        binarySearchTree.insert(4);
 
-        List<Integer> actual = bst.getAsSortedList();
+        List<Integer> actual = binarySearchTree.getAsSortedList();
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void sortsCollectionOfTwoIfSecondInsertedIsSmallerThanFirst() {
-        BST<Integer> bst = new BST<>();
         List<Integer> expected = Collections.unmodifiableList(
                 Arrays.asList(2, 4)
         );
 
-        bst.insert(4);
-        bst.insert(2);
+        binarySearchTree.insert(4);
+        binarySearchTree.insert(2);
 
-        List<Integer> actual = bst.getAsSortedList();
+        List<Integer> actual = binarySearchTree.getAsSortedList();
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void sortsCollectionOfTwoIfSecondInsertedIsBiggerThanFirst() {
-        BST<Integer> bst = new BST<>();
         List<Integer> expected = Collections.unmodifiableList(
                 Arrays.asList(4, 5)
         );
 
-        bst.insert(4);
-        bst.insert(5);
+        binarySearchTree.insert(4);
+        binarySearchTree.insert(5);
 
-        List<Integer> actual = bst.getAsSortedList();
+        List<Integer> actual = binarySearchTree.getAsSortedList();
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void iteratesOverComplexTree() {
-        BST<Integer> bst = new BST<>();
         List<Integer> expected = Collections.unmodifiableList(
                 Arrays.asList(1, 2, 3, 4, 5, 6, 7)
         );
         List<Integer> treeData = Collections.unmodifiableList(
                 Arrays.asList(4, 2, 1, 3, 6, 7, 5)
         );
-        treeData.forEach(bst::insert);
+        treeData.forEach(binarySearchTree::insert);
 
-        List<Integer> actual = bst.getAsSortedList();
+        List<Integer> actual = binarySearchTree.getAsSortedList();
         assertEquals(expected, actual);
     }
 }

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

-public class LargestSeriesProductCalculator {
-
-
+class LargestSeriesProductCalculator {
+    LargestSeriesProductCalculator(String inputNumber) {
+        throw new UnsupportedOperationException ("Delete this statement and write your own implementation.");
+    }
 
+    long calculateLargestProductForSeriesLength(int numberOfDigits) {
+        throw new UnsupportedOperationException ("Delete this statement and write your own implementation.");
+    }
 }

exercises/matrix/src/main/java/Matrix.java

+
+class Matrix {
+
+    Matrix(String matrixAsString) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    int[] getRow(int rowNumber) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    int[] getColumn(int columnNumber) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    int getRowsCount() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    int getColumnsCount() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+}

exercises/robot-simulator/src/main/java/GridPosition.java

         this.y = y;
     }
 
-    /*
-     * This equals method is of deliberately narrow scope (only allows comparison with another GridPosition) to increase
-     * readability. In general, one should provide a full implementation of Object.equals(Object obj) and a
-     * corresponding implementation of Object.hashCode(). See
-     *
-     * https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html#equals(java.lang.Object)
-     *
-     * and
-     *
-     * https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html#hashCode()
-     *
-     * for more information.
-     */
-    boolean equals(final GridPosition gridPosition) {
-        return this.x == gridPosition.x && this.y == gridPosition.y;
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + x;
+        result = prime * result + y;
+        return result;
     }
 
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        } else if (obj == null || getClass() != obj.getClass()) {
+            return false;
+        } else if (x != ((GridPosition) obj).x || y != ((GridPosition)obj).y) {
+            return false;
+        } else {
+            return true;
+        }
+    }
 }

exercises/saddle-points/.meta/src/reference/java/MatrixCoordinate.java

-class MatrixCoordinate {
+class MatrixCoordinate implements Comparable<MatrixCoordinate> {
     private final int row;
     private final int col;
 
         result = 31 * result + col;
         return result;
     }
+
+    @Override
+    public int compareTo(MatrixCoordinate o) {
+        int rowComparison = Integer.compare(row, o.row);
+        return (rowComparison == 0) ? Integer.compare(col, o.col) : rowComparison;
+    }
 }

exercises/saddle-points/src/main/java/MatrixCoordinate.java

-class MatrixCoordinate {
+class MatrixCoordinate implements Comparable<MatrixCoordinate> {
     private final int row;
     private final int col;
 
         result = 31 * result + col;
         return result;
     }
+
+    @Override
+    public int compareTo(MatrixCoordinate o) {
+        int rowComparison = Integer.compare(row, o.row);
+        return (rowComparison == 0) ? Integer.compare(col, o.col) : rowComparison;
+    }
 }

exercises/settings.gradle

 include 'strain'
 include 'sublist'
 include 'sum-of-multiples'
+include 'tournament'
 include 'transpose'
 include 'triangle'
 include 'trinary'

exercises/simple-linked-list/src/test/java/SimpleLinkedListTest.java

 
     @Test
     public void aNewListIsEmpty() {
-        SimpleLinkedList list = new SimpleLinkedList();
+        SimpleLinkedList<Integer> list = new SimpleLinkedList<>();
         assertThat(list.size(), is(0));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void canCreateFromArray() {
-        Integer[] values = new Integer[]{1, 2, 3};
-        SimpleLinkedList list = new SimpleLinkedList(values);
+        Character[] values = new Character[]{'1', '2', '3'};
+        SimpleLinkedList<Character> list = new SimpleLinkedList<Character>(values);
         assertThat(list.size(), is(3));
     }
 
     @Test
     public void popOnEmptyListWillThrow() {
         expectedException.expect(NoSuchElementException.class);
-        SimpleLinkedList list = new SimpleLinkedList();
+        SimpleLinkedList<String> list = new SimpleLinkedList<String>();
         list.pop();
     }
 
     @Ignore("Remove to run test")
     @Test
     public void popReturnsLastAddedElement() {
-        SimpleLinkedList list = new SimpleLinkedList();
+        SimpleLinkedList<Integer> list = new SimpleLinkedList<Integer>();
         list.push(9);
         list.push(8);
         assertThat(list.size(), is(2));
     @Ignore("Remove to run test")
     @Test
     public void reverseReversesList() {
-        SimpleLinkedList list = new SimpleLinkedList();
-        list.push(9);
-        list.push(8);
-        list.push(7);
-        list.push(6);
-        list.push(5);
+        SimpleLinkedList<String> list = new SimpleLinkedList<String>();
+        list.push("9");
+        list.push("8");
+        list.push("7");
+        list.push("6");
+        list.push("5");
         list.reverse();
-        assertThat(list.pop(), is(9));
-        assertThat(list.pop(), is(8));
-        assertThat(list.pop(), is(7));
-        assertThat(list.pop(), is(6));
-        assertThat(list.pop(), is(5));
+        assertThat(list.pop(), is("9"));
+        assertThat(list.pop(), is("8"));
+        assertThat(list.pop(), is("7"));
+        assertThat(list.pop(), is("6"));
+        assertThat(list.pop(), is("5"));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void canReturnListAsArray() {
-        SimpleLinkedList list = new SimpleLinkedList();
-        list.push(9);
-        list.push(8);
-        list.push(7);
-        list.push(6);
-        list.push(5);
-        Integer[] expected = {5, 6, 7, 8, 9};
-        assertArrayEquals(expected, list.asArray(Integer.class));
+        SimpleLinkedList<Character> list = new SimpleLinkedList<Character>();
+        list.push('9');
+        list.push('8');
+        list.push('7');
+        list.push('6');
+        list.push('5');
+        Character[] expected = {'5', '6', '7', '8', '9'};
+        assertArrayEquals(expected, list.asArray(Character.class));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void canReturnEmptyListAsEmptyArray() {
-        SimpleLinkedList list = new SimpleLinkedList();
+        SimpleLinkedList<Object> list = new SimpleLinkedList<Object>();
         Object[] expected = {};
         assertArrayEquals(expected, list.asArray(Object.class));
     }

exercises/tournament/.meta/src/reference/java/Result.java

+enum Result {
+    WIN,
+    DRAW,
+    LOSS
+}

exercises/tournament/.meta/src/reference/java/TeamResult.java

+class TeamResult {
+
+    private int wins;
+    private int losses;
+    private int draws;
+
+    TeamResult() {
+        wins = 0;
+        losses = 0;
+        draws = 0;
+    }
+
+    int getPlayed() {
+        return wins + losses + draws;
+    }
+
+    int getPoints() {
+        return wins * 3 + draws;
+    }
+
+    int getWins() {
+        return wins;
+    }
+
+    int getLosses() {
+        return losses;
+    }
+
+    int getDraws() {
+        return draws;
+    }
+
+    void applyResult(final Result result) {
+        switch (result) {
+            case WIN: wins++; break;
+            case DRAW: draws++; break;
+            case LOSS: losses++; break;
+        }
+    }
+
+}

exercises/tournament/.meta/src/reference/java/Tournament.java

+import java.util.HashMap;
+import java.util.Map;
+import java.util.regex.Pattern;
+
+class Tournament {
+
+    private static Pattern separatorPattern = Pattern.compile(";");
+    private static Pattern newlinePattern = Pattern.compile("\\n");
+
+    private Map<String, TeamResult> results;
+
+    Tournament() {
+        results = new HashMap<>();
+    }
+
+    String printTable() {
+        StringBuilder sb = new StringBuilder();
+        sb.append(String.format("%-30s | %2s | %2s | %2s | %2s | %2s\n",
+                "Team", "MP", "W", "D", "L", "P"));
+        results.entrySet()
+                .stream()
+                .sorted(Tournament::comparator)
+                .forEach(e -> sb.append(
+                        String.format("%-30s | %2d | %2d | %2d | %2d | %2d\n",
+                                e.getKey(), e.getValue().getPlayed(), e.getValue().getWins(), e.getValue().getDraws(),
+                                e.getValue().getLosses(), e.getValue().getPoints())));
+        return sb.toString();
+    }
+
+    private static int comparator(Map.Entry<String, TeamResult> teamA, Map.Entry<String, TeamResult> teamB) {
+        int compareByPoints = Integer.compare(teamB.getValue().getPoints(), teamA.getValue().getPoints());
+        return compareByPoints == 0 ? teamA.getKey().compareTo(teamB.getKey()) : compareByPoints;
+    }
+
+    void applyResults(final String resultString) {
+        String[] matches = newlinePattern.split(resultString);
+        for (String matchString: matches) {
+            String[] column = separatorPattern.split(matchString);
+            final TeamResult home = results.getOrDefault(column[0], new TeamResult());
+            final TeamResult away = results.getOrDefault(column[1], new TeamResult());
+            final Result result = Result.valueOf(column[2].toUpperCase());
+            switch (result) {
+                case WIN:
+                    home.applyResult(Result.WIN);
+                    away.applyResult(Result.LOSS);
+                    break;
+                case LOSS:
+                    home.applyResult(Result.LOSS);
+                    away.applyResult(Result.WIN);
+                    break;
+                case DRAW:
+                    home.applyResult(Result.DRAW);
+                    away.applyResult(Result.DRAW);
+                    break;
+            }
+            results.put(column[0], home);
+            results.put(column[1], away);
+        }
+    }
+
+
+}

exercises/tournament/README.md

+# Tournament
+
+Tally the results of a small football competition.
+
+Based on an input file containing which team played against which and what the
+outcome was, create a file with a table like this:
+
+```
+Team                           | MP |  W |  D |  L |  P
+Devastating Donkeys            |  3 |  2 |  1 |  0 |  7
+Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6
+Blithering Badgers             |  3 |  1 |  0 |  2 |  3
+Courageous Californians        |  3 |  0 |  1 |  2 |  1
+```
+
+What do those abbreviations mean?
+
+- MP: Matches Played
+- W: Matches Won
+- D: Matches Drawn (Tied)
+- L: Matches Lost
+- P: Points
+
+A win earns a team 3 points. A draw earns 1. A loss earns 0.
+
+The outcome should be ordered by points, descending. In case of a tie, teams are ordered alphabetically.
+
+###
+
+Input
+
+Your tallying program will receive input that looks like:
+
+```
+Allegoric Alaskans;Blithering Badgers;win
+Devastating Donkeys;Courageous Californians;draw
+Devastating Donkeys;Allegoric Alaskans;win
+Courageous Californians;Blithering Badgers;loss
+Blithering Badgers;Devastating Donkeys;loss
+Allegoric Alaskans;Courageous Californians;win
+```
+
+The result of the match refers to the first team listed. So this line
+
+```
+Allegoric Alaskans;Blithering Badgers;win
+```
+
+Means that the Allegoric Alaskans beat the Blithering Badgers.
+
+This line:
+
+```
+Courageous Californians;Blithering Badgers;loss
+```
+
+Means that the Blithering Badgers beat the Courageous Californians.
+
+And this line:
+
+```
+Devastating Donkeys;Courageous Californians;draw
+```
+
+Means that the Devastating Donkeys and Courageous Californians tied.
+
+
+To run the tests:
+
+```sh
+$ gradle test
+```
+
+For more detailed info about the Java track see the [help page](http://exercism.io/languages/java).
+
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

exercises/tournament/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/tournament/src/test/java/TournamentTest.java

+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class TournamentTest {
+
+    private Tournament tournament;
+
+    @Before
+    public void setUp() {
+        tournament = new Tournament();
+    }
+
+    @Test
+    public void justTheHeaderIfNoInput() {
+        assertEquals("Team                           | MP |  W |  D |  L |  P\n", tournament.printTable());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void aWinIsThreePointsALossIsZeroPoints() {
+        tournament.applyResults("Allegoric Alaskans;Blithering Badgers;win");
+        assertEquals(
+                "Team                           | MP |  W |  D |  L |  P\n" +
+                "Allegoric Alaskans             |  1 |  1 |  0 |  0 |  3\n" +
+                "Blithering Badgers             |  1 |  0 |  0 |  1 |  0\n",
+                tournament.printTable());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void aWinCanAlsoBeExpressedAsALoss() {
+        tournament.applyResults("Blithering Badgers;Allegoric Alaskans;loss");
+        assertEquals(
+                "Team                           | MP |  W |  D |  L |  P\n" +
+                "Allegoric Alaskans             |  1 |  1 |  0 |  0 |  3\n" +
+                "Blithering Badgers             |  1 |  0 |  0 |  1 |  0\n",
+                tournament.printTable());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void aDifferentTeamCanWin() {
+        tournament.applyResults("Blithering Badgers;Allegoric Alaskans;win");
+        assertEquals(
+                "Team                           | MP |  W |  D |  L |  P\n" +
+                "Blithering Badgers             |  1 |  1 |  0 |  0 |  3\n" +
+                "Allegoric Alaskans             |  1 |  0 |  0 |  1 |  0\n",
+                tournament.printTable());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void aDrawIsOnePointEach() {
+        tournament.applyResults( "Allegoric Alaskans;Blithering Badgers;draw");
+        assertEquals(
+                "Team                           | MP |  W |  D |  L |  P\n" +
+                "Allegoric Alaskans             |  1 |  0 |  1 |  0 |  1\n" +
+                "Blithering Badgers             |  1 |  0 |  1 |  0 |  1\n",
+                tournament.printTable());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void thereCanBeMoreThanOneMatch() {
+        tournament.applyResults(
+                "Allegoric Alaskans;Blithering Badgers;win\n" +
+                "Allegoric Alaskans;Blithering Badgers;win");
+        assertEquals(
+                "Team                           | MP |  W |  D |  L |  P\n" +
+                "Allegoric Alaskans             |  2 |  2 |  0 |  0 |  6\n" +
+                "Blithering Badgers             |  2 |  0 |  0 |  2 |  0\n",
+                tournament.printTable());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void thereCanBeMoreThanOneWinner() {
+        tournament.applyResults(
+                "Allegoric Alaskans;Blithering Badgers;loss\n" +
+                "Allegoric Alaskans;Blithering Badgers;win");
+        assertEquals(
+                "Team                           | MP |  W |  D |  L |  P\n" +
+                "Allegoric Alaskans             |  2 |  1 |  0 |  1 |  3\n" +
+                "Blithering Badgers             |  2 |  1 |  0 |  1 |  3\n",
+                tournament.printTable());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void thereCanBeMoreThanTwoTeams() {
+        tournament.applyResults(
+                "Allegoric Alaskans;Blithering Badgers;win\n" +
+                "Blithering Badgers;Courageous Californians;win\n" +
+                "Courageous Californians;Allegoric Alaskans;loss");
+        assertEquals(
+                "Team                           | MP |  W |  D |  L |  P\n" +
+                "Allegoric Alaskans             |  2 |  2 |  0 |  0 |  6\n" +
+                "Blithering Badgers             |  2 |  1 |  0 |  1 |  3\n" +
+                "Courageous Californians        |  2 |  0 |  0 |  2 |  0\n",
+                tournament.printTable());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void typicalInput() {
+        tournament.applyResults(
+                "Allegoric Alaskans;Blithering Badgers;win\n" +
+                "Devastating Donkeys;Courageous Californians;draw\n" +
+                "Devastating Donkeys;Allegoric Alaskans;win\n" +
+                "Courageous Californians;Blithering Badgers;loss\n" +
+                "Blithering Badgers;Devastating Donkeys;loss\n" +
+                "Allegoric Alaskans;Courageous Californians;win");
+        assertEquals(
+                "Team                           | MP |  W |  D |  L |  P\n" +
+                "Devastating Donkeys            |  3 |  2 |  1 |  0 |  7\n" +
+                "Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6\n" +
+                "Blithering Badgers             |  3 |  1 |  0 |  2 |  3\n" +
+                "Courageous Californians        |  3 |  0 |  1 |  2 |  1\n",
+                tournament.printTable());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void incompleteCompetition() {
+        tournament.applyResults(
+                "Allegoric Alaskans;Blithering Badgers;loss\n" +
+                "Devastating Donkeys;Allegoric Alaskans;loss\n" +
+                "Courageous Californians;Blithering Badgers;draw\n" +
+                "Allegoric Alaskans;Courageous Californians;win");
+        assertEquals(
+                "Team                           | MP |  W |  D |  L |  P\n" +
+                "Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6\n" +
+                "Blithering Badgers             |  2 |  1 |  1 |  0 |  4\n" +
+                "Courageous Californians        |  2 |  0 |  1 |  1 |  1\n" +
+                "Devastating Donkeys            |  1 |  0 |  0 |  1 |  0\n",
+                tournament.printTable());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void tiesBrokenAlphabetically() {
+        tournament.applyResults(
+                "Courageous Californians;Devastating Donkeys;win\n" +
+                "Allegoric Alaskans;Blithering Badgers;win\n" +
+                "Devastating Donkeys;Allegoric Alaskans;loss\n" +
+                "Courageous Californians;Blithering Badgers;win\n" +
+                "Blithering Badgers;Devastating Donkeys;draw\n" +
+                "Allegoric Alaskans;Courageous Californians;draw");
+        assertEquals(
+                "Team                           | MP |  W |  D |  L |  P\n" +
+                "Allegoric Alaskans             |  3 |  2 |  1 |  0 |  7\n" +
+                "Courageous Californians        |  3 |  2 |  1 |  0 |  7\n" +
+                "Blithering Badgers             |  3 |  0 |  1 |  2 |  1\n" +
+                "Devastating Donkeys            |  3 |  0 |  1 |  2 |  1\n",
+                tournament.printTable());
+    }
+}