trackler 2.2.1.47 → 2.2.1.48

data/tracks/java/config/exercise-readme-insert.md

@@ -1,9 +1,9 @@
+# Running the tests
 
-To run the tests:
+You can run all the tests for an exercise by entering
 
 ```sh
 $ gradle test
 ```
 
-For more detailed info about the Java track see the [help page](http://exercism.io/languages/java).
-
+in your terminal.

data/tracks/java/config/exercise_readme.go.tmpl

@@ -2,6 +2,8 @@
 
 {{ .Spec.Description -}}
 {{- with .Hints }}
+# Java Tips
+
 {{ . }}
 {{ end }}
 {{- with .TrackInsert }}
@@ -13,4 +15,5 @@
 {{ . }}
 {{ end }}
 ## Submitting Incomplete Solutions
+
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

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

@@ -25,19 +25,20 @@ Keep your hands off that collect/map/fmap/whatchamacallit functionality
 provided by your standard library!
 Solve this one yourself using other basic tools instead.
 
+# Running the tests
 
-To run the tests:
+You can run all the tests for an exercise by entering
 
 ```sh
 $ gradle test
 ```
 
-For more detailed info about the Java track see the [help page](http://exercism.io/languages/java).
-
+in your terminal.
 
 ## Source
 
 Conversation with James Edward Gray II [https://twitter.com/jeg2](https://twitter.com/jeg2)
 
 ## Submitting Incomplete Solutions
+
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

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

@@ -7,19 +7,20 @@ Techies love their TLA (Three Letter Acronyms)!
 Help generate some jargon by writing a program that converts a long name
 like Portable Network Graphics to its acronym (PNG).
 
+# Running the tests
 
-To run the tests:
+You can run all the tests for an exercise by entering
 
 ```sh
 $ gradle test
 ```
 
-For more detailed info about the Java track see the [help page](http://exercism.io/languages/java).
-
+in your terminal.
 
 ## Source
 
 Julien Vanier [https://github.com/monkbroc](https://github.com/monkbroc)
 
 ## Submitting Incomplete Solutions
+
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/java/exercises/all-your-base/README.md

@@ -31,16 +31,17 @@ I think you got the idea!
 
 *Yes. Those three numbers above are exactly the same. Congratulations!*
 
+# Running the tests
 
-To run the tests:
+You can run all the tests for an exercise by entering
 
 ```sh
 $ gradle test
 ```
 
-For more detailed info about the Java track see the [help page](http://exercism.io/languages/java).
-
+in your terminal.
 
 
 ## Submitting Incomplete Solutions
+
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

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

@@ -29,19 +29,20 @@ allergens that score 256, 512, 1024, etc.).  Your program should
 ignore those components of the score.  For example, if the allergy
 score is 257, your program should only report the eggs (1) allergy.
 
+# Running the tests
 
-To run the tests:
+You can run all the tests for an exercise by entering
 
 ```sh
 $ gradle test
 ```
 
-For more detailed info about the Java track see the [help page](http://exercism.io/languages/java).
-
+in your terminal.
 
 ## Source
 
 Jumpstart Lab Warm-up [http://jumpstartlab.com](http://jumpstartlab.com)
 
 ## Submitting Incomplete Solutions
+
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

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

@@ -6,19 +6,20 @@ Given `"listen"` and a list of candidates like `"enlists" "google"
 "inlets" "banana"` the program should return a list containing
 `"inlets"`.
 
+# Running the tests
 
-To run the tests:
+You can run all the tests for an exercise by entering
 
 ```sh
 $ gradle test
 ```
 
-For more detailed info about the Java track see the [help page](http://exercism.io/languages/java).
-
+in your terminal.
 
 ## Source
 
 Inspired by the Extreme Startup game [https://github.com/rchatley/extreme_startup](https://github.com/rchatley/extreme_startup)
 
 ## Submitting Incomplete Solutions
+
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/java/exercises/atbash-cipher/README.md

@@ -28,19 +28,20 @@ things based on word boundaries.
 - Decoding `gvhg` gives `test`
 - Decoding `gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt` gives `thequickbrownfoxjumpsoverthelazydog`
 
+# Running the tests
 
-To run the tests:
+You can run all the tests for an exercise by entering
 
 ```sh
 $ gradle test
 ```
 
-For more detailed info about the Java track see the [help page](http://exercism.io/languages/java).
-
+in your terminal.
 
 ## Source
 
 Wikipedia [http://en.wikipedia.org/wiki/Atbash](http://en.wikipedia.org/wiki/Atbash)
 
 ## Submitting Incomplete Solutions
+
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/java/exercises/bank-account/README.md

@@ -26,6 +26,8 @@ it.
 
 Have fun!
 
+# Java Tips
+
 This exercise introduces [concurrency](https://docs.oracle.com/javase/tutorial/essential/concurrency/index.html). 
 To pass the last test you might find the 
 [`synchronized` keyword or locks](https://docs.oracle.com/javase/tutorial/essential/concurrency/locksync.html) useful.
@@ -38,16 +40,17 @@ no concurrent modification attempt. It is unlikely that this will occur several
 in a row since the order the code is executed should vary every time you run the test. So if you run the last test a 
 couple of times and it passes every time then you can be reasonably sure that your implementation is correct.
 
+# Running the tests
 
-To run the tests:
+You can run all the tests for an exercise by entering
 
 ```sh
 $ gradle test
 ```
 
-For more detailed info about the Java track see the [help page](http://exercism.io/languages/java).
-
+in your terminal.
 
 
 ## Submitting Incomplete Solutions
+
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/java/exercises/beer-song/README.md

@@ -320,19 +320,20 @@ are some additional things you could try:
 Then please share your thoughts in a comment on the submission. Did this
 experiment make the code better? Worse? Did you learn anything from it?
 
+# Running the tests
 
-To run the tests:
+You can run all the tests for an exercise by entering
 
 ```sh
 $ gradle test
 ```
 
-For more detailed info about the Java track see the [help page](http://exercism.io/languages/java).
-
+in your terminal.
 
 ## Source
 
 Learn to Program by Chris Pine [http://pine.fm/LearnToProgram/?Chapter=06](http://pine.fm/LearnToProgram/?Chapter=06)
 
 ## Submitting Incomplete Solutions
+
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/java/exercises/binary-search-tree/.meta/src/reference/java/BinarySearchTree.java

@@ -1,49 +1,11 @@
+import java.util.*;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Queue;
-
-public class BinarySearchTree<T extends Comparable<T>> {
-
-    public static class Node<T> {
-
-        private T data;
-        private Node<T> left = null;
-        private Node<T> right = null;
-
-        public Node(T data) {
-            this.data = data;
-        }
-
-        public Node<T> getLeft() {
-            return left;
-        }
-
-        public void setLeft(Node<T> left) {
-            this.left = left;
-        }
-
-        public Node<T> getRight() {
-            return right;
-        }
-
-        public void setRight(Node<T> right) {
-            this.right = right;
-        }
-
-        public T getData() {
-            return data;
-        }
-
-    }
+class BinarySearchTree<T extends Comparable<T>> {
 
     private Node<T> root;
-
     private int nodeCount = 0;
 
-    public void insert(T value) {
+    void insert(T value) {
         if (root == null) {
             root = new Node<>(value);
         } else {
@@ -52,19 +14,19 @@ public class BinarySearchTree<T extends Comparable<T>> {
         this.nodeCount++;
     }
 
-    public List<T> getAsSortedList() {
+    List<T> getAsSortedList() {
         List<T> result = new ArrayList<>(this.nodeCount);
         this.putInSortedOrderToList(this.root, result);
         return Collections.unmodifiableList(result);
     }
 
-    public List<T> getAsLevelOrderList() {
+    List<T> getAsLevelOrderList() {
         List<T> result = new ArrayList<>(this.nodeCount);
         this.putInLevelOrderToList(this.root, result);
         return Collections.unmodifiableList(result);
     }
 
-    public Node<T> getRoot() {
+    Node<T> getRoot() {
         return root;
     }
 
@@ -119,4 +81,36 @@ public class BinarySearchTree<T extends Comparable<T>> {
             }
         }
     }
+
+    static class Node<T> {
+
+        private T data;
+        private Node<T> left = null;
+        private Node<T> right = null;
+
+        Node(T data) {
+            this.data = data;
+        }
+
+        Node<T> getLeft() {
+            return left;
+        }
+
+        void setLeft(Node<T> left) {
+            this.left = left;
+        }
+
+        Node<T> getRight() {
+            return right;
+        }
+
+        void setRight(Node<T> right) {
+            this.right = right;
+        }
+
+        T getData() {
+            return data;
+        }
+
+    }
 }

data/tracks/java/exercises/binary-search-tree/README.md

@@ -53,19 +53,20 @@ And if we then added 1, 5, and 7, it would look like this
      / \     / \
     1   3   5   7
 
+# Running the tests
 
-To run the tests:
+You can run all the tests for an exercise by entering
 
 ```sh
 $ gradle test
 ```
 
-For more detailed info about the Java track see the [help page](http://exercism.io/languages/java).
-
+in your terminal.
 
 ## Source
 
 Josh Cheek [https://twitter.com/josh_cheek](https://twitter.com/josh_cheek)
 
 ## Submitting Incomplete Solutions
+
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/java/exercises/binary-search-tree/src/main/java/BinarySearchTree.java

@@ -0,0 +1,35 @@
+import java.util.List;
+
+class BinarySearchTree<T extends Comparable<T>> {
+    void insert(T value) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    List<T> getAsSortedList() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    List<T> getAsLevelOrderList() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    Node<T> getRoot() {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    static class Node<T> {
+
+        Node<T> getLeft() {
+            throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+        }
+
+        Node<T> getRight() {
+            throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+        }
+
+        T getData() {
+            throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+        }
+
+    }
+}

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

@@ -9,39 +9,38 @@ import org.junit.Test;
 import org.junit.Before;
 
 public class BinarySearchTreeTest {
-    private BinarySearchTree<Integer> binarySearchTree;
-
-    @Before
-    public void setUp() {
-        binarySearchTree = new BinarySearchTree<>();
-    }
 
     @Test
     public void dataIsRetained() {
-        final int actual = 4;
-        binarySearchTree.insert(actual);
+        BinarySearchTree<Integer> binarySearchTree = new BinarySearchTree<>();
+
+        final int expected = 4;
+        binarySearchTree.insert(expected);
+
         final BinarySearchTree.Node<Integer> root = binarySearchTree.getRoot();
         assertNotNull(root);
-        final int expected = root.getData();
+
+        final int actual = root.getData();
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void insertsLess() {
-        final int expectedRoot = 4;
-        final int expectedLeft = 2;
+        BinarySearchTree<Character> binarySearchTree = new BinarySearchTree<>();
+        final char expectedRoot = '4';
+        final char expectedLeft = '2';
 
         binarySearchTree.insert(expectedRoot);
         binarySearchTree.insert(expectedLeft);
 
-        final BinarySearchTree.Node<Integer> root = binarySearchTree.getRoot();
+        final BinarySearchTree.Node<Character> root = binarySearchTree.getRoot();
         assertNotNull(root);
-        final BinarySearchTree.Node<Integer> left = root.getLeft();
+        final BinarySearchTree.Node<Character> left = root.getLeft();
         assertNotNull(left);
 
-        final int actualRoot = root.getData();
-        final int actualLeft = left.getData();
+        final char actualRoot = root.getData();
+        final char actualLeft = left.getData();
         assertEquals(expectedLeft, actualLeft);
         assertEquals(expectedRoot, actualRoot);
     }
@@ -49,19 +48,20 @@ public class BinarySearchTreeTest {
     @Ignore("Remove to run test")
     @Test
     public void insertsSame() {
-        final int expectedRoot = 4;
-        final int expectedLeft = 4;
+        BinarySearchTree<String> binarySearchTree = new BinarySearchTree<>();
+        final String expectedRoot = "4";
+        final String expectedLeft = "4";
 
         binarySearchTree.insert(expectedRoot);
         binarySearchTree.insert(expectedLeft);
 
-        final BinarySearchTree.Node<Integer> root = binarySearchTree.getRoot();
+        final BinarySearchTree.Node<String> root = binarySearchTree.getRoot();
         assertNotNull(root);
-        final BinarySearchTree.Node<Integer> left = root.getLeft();
+        final BinarySearchTree.Node<String> left = root.getLeft();
         assertNotNull(left);
 
-        final int actualRoot = root.getData();
-        final int actualLeft = left.getData();
+        final String actualRoot = root.getData();
+        final String actualLeft = left.getData();
         assertEquals(expectedLeft, actualLeft);
         assertEquals(expectedRoot, actualRoot);
     }
@@ -69,6 +69,7 @@ public class BinarySearchTreeTest {
     @Ignore("Remove to run test")
     @Test
     public void insertsRight() {
+        BinarySearchTree<Integer> binarySearchTree = new BinarySearchTree<>();
         final int expectedRoot = 4;
         final int expectedRight = 5;
 
@@ -89,35 +90,38 @@ public class BinarySearchTreeTest {
     @Ignore("Remove to run test")
     @Test
     public void createsComplexTree() {
-        List<Integer> expected = Collections.unmodifiableList(
-                Arrays.asList(4, 2, 6, 1, 3, 5, 7)
+        BinarySearchTree<Character> binarySearchTree = new BinarySearchTree<>();
+        List<Character> 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)
+        List<Character> treeData = Collections.unmodifiableList(
+                Arrays.asList('4', '2', '6', '1', '3', '7', '5')
         );
         treeData.forEach(binarySearchTree::insert);
 
-        List<Integer> actual = binarySearchTree.getAsLevelOrderList();
+        List<Character> actual = binarySearchTree.getAsLevelOrderList();
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void sortsSingleElement() {
-        List<Integer> expected = Collections.unmodifiableList(
-                Collections.singletonList(4)
+        BinarySearchTree<String> binarySearchTree = new BinarySearchTree<>();
+        List<String> expected = Collections.unmodifiableList(
+                Collections.singletonList("4")
         );
 
-        binarySearchTree.insert(4);
+        binarySearchTree.insert("4");
 
-        List<Integer> actual = binarySearchTree.getAsSortedList();
+        List<String> actual = binarySearchTree.getAsSortedList();
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void sortsCollectionOfTwoIfSecondInsertedIsSmallerThanFirst() {
+        BinarySearchTree<Integer> binarySearchTree = new BinarySearchTree<>();
         List<Integer> expected = Collections.unmodifiableList(
                 Arrays.asList(2, 4)
         );
@@ -132,30 +136,32 @@ public class BinarySearchTreeTest {
     @Ignore("Remove to run test")
     @Test
     public void sortsCollectionOfTwoIfSecondInsertedIsBiggerThanFirst() {
-        List<Integer> expected = Collections.unmodifiableList(
-                Arrays.asList(4, 5)
+        BinarySearchTree<Character> binarySearchTree = new BinarySearchTree<>();
+        List<Character> expected = Collections.unmodifiableList(
+                Arrays.asList('4', '5')
         );
 
-        binarySearchTree.insert(4);
-        binarySearchTree.insert(5);
+        binarySearchTree.insert('4');
+        binarySearchTree.insert('5');
 
-        List<Integer> actual = binarySearchTree.getAsSortedList();
+        List<Character> actual = binarySearchTree.getAsSortedList();
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void iteratesOverComplexTree() {
-        List<Integer> expected = Collections.unmodifiableList(
-                Arrays.asList(1, 2, 3, 4, 5, 6, 7)
+        BinarySearchTree<String> binarySearchTree = new BinarySearchTree<>();
+        List<String> 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)
+        List<String> treeData = Collections.unmodifiableList(
+                Arrays.asList("4", "2", "1", "3", "6", "7", "5")
         );
         treeData.forEach(binarySearchTree::insert);
 
-        List<Integer> actual = binarySearchTree.getAsSortedList();
+        List<String> actual = binarySearchTree.getAsSortedList();
         assertEquals(expected, actual);
     }
 }