trackler 2.2.1.44 → 2.2.1.45

data/tracks/haskell/exercises/lens-person/README.md

@@ -5,7 +5,7 @@ Use lenses to update nested records (specific to languages with immutable data).
 Updating fields of nested records is kind of annoying in Haskell. One solution
 is to use [lenses](https://wiki.haskell.org/Lens).  Implement several record
 accessing functions using lenses, you may use any library you want. The test
-suite also allows you to avoid lenses alltogether so you can experiment with
+suite also allows you to avoid lenses altogether so you can experiment with
 different approaches.
 
 

data/tracks/haskell/exercises/palindrome-products/README.md

@@ -5,19 +5,12 @@ Detect palindrome products in a given range.
 A palindromic number is a number that remains the same when its digits are
 reversed. For example, `121` is a palindromic number but `112` is not.
 
-Given the definition of a palindromic number, we define a palindrome _product_
-to be the product `c`, such that `a * b = c`, where `c` is a palindromic number and
- `a` and `b` are integers (possibly, but _not_ necessarily palindromic numbers).
+Given a range of numbers, find the largest and smallest palindromes which
+are products of numbers within that range.
 
-For example, the palindromic number 9009 can be written as the palindrome
-product: `91 * 99 = 9009`.
-
-It's possible (and indeed common) for a palindrome product to be the product
-of multiple combinations of numbers. For example, the palindrome product `9` has
-the factors `(1, 9)` and `(3, 3)`.
-
-Write a program that given a range of integers, returns the smallest and largest
-palindromic product of factors within that range, along with all the factors in the range for that product.
+Your solution should return the largest and smallest palindromes, along with the
+factors of each within the range. If the largest or smallest palindrome has more 
+than one pair of factors within the range, then return all the pairs.
 
 ## Example 1
 

data/tracks/haskell/exercises/sum-of-multiples/README.md

@@ -8,9 +8,6 @@ multiples of either 3 or 5, we get 3, 5, 6 and 9, 10, 12, 15, and 18.
 
 The sum of these multiples is 78.
 
-Given a number, find the sum of the multiples of a given set of numbers,
-up to but not including that number.
-
 
 ## Getting Started
 

data/tracks/idris/config.json

@@ -43,6 +43,18 @@
         "Export Modifiers",
         "Vectors"
       ]
+    },
+    {
+      "uuid": "612f5f98-09a6-9d80-5820-edeec5ce1e1544073ed",
+      "slug": "accumulate",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 1,
+      "topics": [
+        "Functions",
+        "Lists",
+        "Map"
+      ]
     }
   ]
 }

data/tracks/idris/exercises/accumulate/Accumulate.ipkg

@@ -0,0 +1,5 @@
+package accumulate
+
+sourcedir = src
+modules = Accumulate, Test.Accumulate
+tests = Test.Accumulate.runTests

data/tracks/idris/exercises/accumulate/Makefile

@@ -0,0 +1,23 @@
+idris ?= idris
+pkg   := Accumulate
+
+.PHONY: build clean clobber install rebuild test
+
+all: test
+
+build:
+	@ ${idris} --build ${pkg}.ipkg
+
+clean:
+	@ ${idris} --clean ${pkg}.ipkg
+
+clobber: clean
+	@ find . -name '*.ibc' -delete
+
+install:
+	@ ${idris} --install ${pkg}.ipkg
+
+rebuild: clean build
+
+test:
+	@ ${idris} --testpkg ${pkg}.ipkg

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

@@ -0,0 +1,32 @@
+# Accumulate
+
+Implement the `accumulate` operation, which, given a collection and an
+operation to perform on each element of the collection, returns a new
+collection containing the result of applying that operation to each element of
+the input collection.
+
+Given the collection of numbers:
+
+- 1, 2, 3, 4, 5
+
+And the operation:
+
+- square a number (`x => x * x`)
+
+Your code should be able to produce the collection of squares:
+
+- 1, 4, 9, 16, 25
+
+Check out the test suite to see the expected function signature.
+
+## Restrictions
+
+Keep your hands off that collect/map/fmap/whatchamacallit functionality
+provided by your standard library!
+Solve this one yourself using other basic tools instead.
+## 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/idris/exercises/accumulate/src/Example.idr

@@ -0,0 +1,6 @@
+module Accumulate
+
+export
+accumulate : (Int -> Int) -> List Int -> List Int
+accumulate f [] = []
+accumulate f (x::xs) = f x :: accumulate f xs

data/tracks/idris/exercises/accumulate/src/Test/Accumulate.idr

@@ -0,0 +1,35 @@
+module Test.Accumulate
+
+import Accumulate
+
+%access export
+
+assertEq : Eq a => String -> (given : a) -> (expected : a) -> IO ()
+assertEq label g e = putStrLn $ if g == e then label ++ ": Test Passed" else label ++ ": Test Failed"
+
+testEmptyListDoesNothing : IO ()
+testEmptyListDoesNothing = assertEq "empty list does nothing" (accumulate (\x => x) []) []
+
+testIdentityFunctionDoesNothing : IO ()
+testIdentityFunctionDoesNothing = assertEq "identity function does nothing" (accumulate (\x => x) [1,2,3]) [1,2,3]
+
+testSquareFunctionDoublesInput : IO ()
+testSquareFunctionDoublesInput = assertEq "square function doubles input" (accumulate (\x => x * x) [1,2,3]) [1,4,9]
+
+testCubeFunctionTriplesInput : IO ()
+testCubeFunctionTriplesInput = assertEq "cube function triples input" (accumulate (\x => x * x * x) [1,2,3]) [1,8,27]
+
+testIncrementFunctionAddsOneToAllInput : IO ()
+testIncrementFunctionAddsOneToAllInput = assertEq "increment function adds 1 to input" (accumulate (\x => x + 1) [1,2,3]) [2,3,4]
+
+testDecrementFunctionAddsOneToAllInput : IO ()
+testDecrementFunctionAddsOneToAllInput = assertEq "decrement function subtracts 1 from input" (accumulate (\x => x - 1) [1,2,3]) [0,1,2]
+
+runTests : IO ()
+runTests = do
+  testEmptyListDoesNothing
+  testIdentityFunctionDoesNothing
+  testSquareFunctionDoublesInput
+  testCubeFunctionTriplesInput
+  testIncrementFunctionAddsOneToAllInput
+  testDecrementFunctionAddsOneToAllInput

data/tracks/java/config/maintainers.json

@@ -49,13 +49,10 @@
     },
     {
       "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
     }
   ]
-}
+}

data/tracks/java/config.json

@@ -263,7 +263,11 @@
       "core": true,
       "difficulty": 4,
       "slug": "rotational-cipher",
-      "topics": null,
+      "topics": [
+        "integers",
+        "strings",
+        "cryptography"
+      ],
       "unlocked_by": null,
       "uuid": "9eb41883-55ef-4681-b5ac-5c2259302772"
     },
@@ -307,7 +311,7 @@
         "lists",
         "loops",
         "integers"
-       ],
+      ],
       "unlocked_by": "triangle",
       "uuid": "2c69db99-648d-4bd7-8012-1fbdeff6ca0a"
     },
@@ -315,7 +319,16 @@
       "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"
     },
@@ -324,12 +337,12 @@
       "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"
     },
@@ -350,7 +363,12 @@
       "core": true,
       "difficulty": 5,
       "slug": "flatten-array",
-      "topics": null,
+      "topics": [
+        "arrays",
+        "lists",
+        "loops",
+        "recursion"
+      ],
       "unlocked_by": null,
       "uuid": "a732a838-8170-458a-a85e-d6b4c46f97a1"
     },
@@ -481,7 +499,10 @@
       "core": false,
       "difficulty": 5,
       "slug": "bracket-push",
-      "topics": null,
+      "topics": [
+        "stacks",
+        "strings"
+      ],
       "unlocked_by": "flatten-array",
       "uuid": "85aa50ac-0141-49eb-bc6f-62f3f7a97647"
     },
@@ -503,7 +524,11 @@
       "core": false,
       "difficulty": 5,
       "slug": "atbash-cipher",
-      "topics": null,
+      "topics": [
+        "strings",
+        "cryptography",
+        "security"
+      ],
       "unlocked_by": "rotational-cipher",
       "uuid": "d36ce010-210f-4e9a-9d6c-cb933e0a59af"
     },
@@ -558,10 +583,10 @@
       "difficulty": 6,
       "slug": "food-chain",
       "topics": [
-       	"arrays",
-       	"lists",
-       	"strings"
-       ],
+        "arrays",
+        "lists",
+        "strings"
+      ],
       "unlocked_by": "two-fer",
       "uuid": "dd3e6fd6-5359-4978-acd7-c39374cead4d"
     },
@@ -622,7 +647,12 @@
       "core": false,
       "difficulty": 6,
       "slug": "robot-simulator",
-      "topics": null,
+      "topics": [
+        "classes",
+        "logic",
+        "loops",
+        "enumerations"
+      ],
       "unlocked_by": "secret-handshake",
       "uuid": "993bde9d-7774-4e7a-a381-9eee75f28ecb"
     },
@@ -690,6 +720,20 @@
       "unlocked_by": "scrabble-score",
       "uuid": "4b3f7771-c642-4278-a3d9-2fb958f26361"
     },
+    {
+      "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,
@@ -748,7 +792,12 @@
       "core": false,
       "difficulty": 7,
       "slug": "meetup",
-      "topics": null,
+      "topics": [
+        "conditionals",
+        "dates",
+        "loops",
+        "enumerations"
+      ],
       "unlocked_by": "gigasecond",
       "uuid": "602511d5-7e89-4def-b072-4dd311816810"
     },
@@ -756,7 +805,14 @@
       "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"
     },
@@ -776,7 +832,14 @@
       "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"
     },
@@ -820,7 +883,14 @@
       "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"
     },
@@ -856,7 +926,14 @@
       "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"
     },

data/tracks/java/exercises/binary-search-tree/.meta/src/reference/java/{BST.java → BinarySearchTree.java}

@@ -5,7 +5,7 @@ import java.util.LinkedList;
 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> {
 

data/tracks/java/exercises/binary-search-tree/src/test/java/{BSTTest.java → BinarySearchTreeTest.java}

@@ -6,15 +6,21 @@ import static org.junit.Assert.assertEquals;
 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);
@@ -23,16 +29,15 @@ public class BSTTest {
     @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();
@@ -44,16 +49,15 @@ public class BSTTest {
     @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();
@@ -65,16 +69,15 @@ public class BSTTest {
     @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();
@@ -86,7 +89,6 @@ public class BSTTest {
     @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)
         );
@@ -94,60 +96,56 @@ public class BSTTest {
         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)
         );
@@ -155,9 +153,9 @@ public class BSTTest {
         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);
     }
 }

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

@@ -9,21 +9,25 @@ class GridPosition {
         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;
+        }
+    }
 }

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

@@ -1,4 +1,4 @@
-class MatrixCoordinate {
+class MatrixCoordinate implements Comparable<MatrixCoordinate> {
     private final int row;
     private final int col;
 
@@ -30,4 +30,10 @@ class MatrixCoordinate {
         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;
+    }
 }

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

@@ -1,4 +1,4 @@
-class MatrixCoordinate {
+class MatrixCoordinate implements Comparable<MatrixCoordinate> {
     private final int row;
     private final int col;
 
@@ -30,4 +30,10 @@ class MatrixCoordinate {
         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;
+    }
 }