trackler 2.2.1.107 → 2.2.1.108

data/tracks/java/exercises/zipper/build.gradle

@@ -0,0 +1,18 @@
+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"]
+  }
+}

data/tracks/java/exercises/zipper/src/test/java/ZipperTest.java

@@ -0,0 +1,204 @@
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.Before;
+
+import static org.junit.Assert.assertEquals;
+
+public class ZipperTest {
+
+    Zipper zipper;
+    BinaryTree binaryTree;
+
+    @Before
+    public void setup() {
+        zipper = new Zipper(1);
+        binaryTree = new BinaryTree(zipper);
+
+        zipper.setLeft(new Zipper(2));
+        zipper.left.setRight(new Zipper(3));
+
+        zipper.setRight(new Zipper(4));
+    }
+
+    @Test
+    public void testToTree() {
+        assertEquals(binaryTree, zipper.toTree());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testLeftRightAndValue() {
+        zipper = binaryTree.getRoot();
+        assertEquals(3, zipper.left.right.getValue());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testDeadEnd() {
+        zipper = binaryTree.getRoot();
+        assertEquals(null, zipper.left.left);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testToTreeFromDeepFocus() {
+        zipper = binaryTree.getRoot();
+        assertEquals(binaryTree, zipper.left.right.toTree());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testTraversingUpFromTop() {
+        zipper = binaryTree.getRoot();
+        assertEquals(null, zipper.up);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testLeftRightAndUp() {
+        zipper = binaryTree.getRoot();
+        assertEquals(3, zipper.left.up.right.up.left.right.getValue());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testSetValue() {
+        zipper = binaryTree.getRoot();
+        zipper = zipper.left;
+        zipper.setValue(5);
+        String expected =
+                "value: 1, " +
+                "left: { " +
+                    "value: 5, " +
+                    "left: null, " +
+                    "right: { " +
+                        "value: 3, " +
+                        "left: null, " +
+                        "right: null } }, " +
+                "right: { " +
+                    "value: 4, " +
+                    "left: null, " +
+                    "right: null }";
+        assertEquals(expected, zipper.toTree().printTree());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testSetValueAfterTraversingUp() {
+        zipper = binaryTree.getRoot();
+        zipper = zipper.left.right.up;
+        zipper.setValue(5);
+        String expected =
+                "value: 1, " +
+                "left: { " +
+                    "value: 5, " +
+                    "left: null, " +
+                    "right: { " +
+                        "value: 3, " +
+                        "left: null, " +
+                        "right: null } }, " +
+                "right: { " +
+                    "value: 4, " +
+                    "left: null, " +
+                    "right: null }";
+        assertEquals(expected, zipper.toTree().printTree());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testSetLeftWithLeaf() {
+        zipper = binaryTree.getRoot();
+        zipper = zipper.left;
+        zipper.setLeft(new Zipper(5));
+        String expected =
+                "value: 1, " +
+                "left: { " +
+                    "value: 2, " +
+                    "left: { " +
+                        "value: 5, " +
+                        "left: null, " +
+                        "right: null }, " +
+                    "right: { " +
+                        "value: 3, " +
+                        "left: null, " +
+                        "right: null } }, " +
+                "right: { " +
+                    "value: 4, " +
+                    "left: null, " +
+                    "right: null }";
+        assertEquals(expected, zipper.toTree().printTree());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testSetRightWithNull() {
+        zipper = binaryTree.getRoot();
+        zipper = zipper.left;
+        zipper.setRight(null);
+        String expected =
+                "value: 1, " +
+                "left: { value: 2, left: null, right: null }, " +
+                "right: { value: 4, left: null, right: null }";
+        assertEquals(expected, zipper.toTree().printTree());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testSetRightWithSubtree() {
+        BinaryTree subtree = new BinaryTree(6);
+        subtree.getRoot().setLeft(new Zipper(7));
+        subtree.getRoot().setRight(new Zipper(8));
+        zipper = binaryTree.getRoot();
+        zipper.setRight(subtree.getRoot());
+        String expected =
+                "value: 1, " +
+                "left: { " +
+                    "value: 2, " +
+                    "left: null, " +
+                    "right: { " +
+                        "value: 3, " +
+                        "left: null, " +
+                        "right: null } }, " +
+                "right: { " +
+                    "value: 6, " +
+                    "left: { " +
+                        "value: 7, " +
+                        "left: null, " +
+                        "right: null }, " +
+                    "right: { " +
+                        "value: 8, " +
+                        "left: null, " +
+                        "right: null } }";
+        assertEquals(expected, zipper.toTree().printTree());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testSetValueOnDeepFocus() {
+        zipper = binaryTree.getRoot();
+        zipper = zipper.left.right;
+        zipper.setValue(5);
+        String expected =
+                "value: 1, " +
+                "left: { " +
+                    "value: 2, " +
+                    "left: null, " +
+                    "right: { " +
+                        "value: 5, " +
+                        "left: null, " +
+                        "right: null } }, " +
+                "right: { " +
+                    "value: 4, " +
+                    "left: null, " +
+                    "right: null }";
+        assertEquals(expected, zipper.toTree().printTree());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void differentPathToSameZipper() {
+        Zipper zipper1 = binaryTree.getRoot().left.up.right;
+        Zipper zipper2 = binaryTree.getRoot().right;
+        assertEquals(zipper2, zipper1);
+    }
+}

data/tracks/javascript/package.json

@@ -19,5 +19,15 @@
   "scripts": {
     "lint": "eslint .",
     "lint-fix": "eslint . --fix"
+  },
+  "eslintConfig": {
+    "plugins": ["jasmine"],
+    "env": {
+      "jasmine": true 
+    },
+    "extends": "eslint-config-airbnb-es5",
+    "rules": {
+      "func-names": "off"
+    }
   }
 }

data/tracks/ocaml/.travis-ci.sh

@@ -2,7 +2,7 @@
 OPAM_DEPENDS="ocamlfind core ounit react ppx_deriving"
 
 case "$OCAML_VERSION,$OPAM_VERSION" in
-    4.06.0,1.2.2) ppa=avsm/ocaml42+opam12 ;;
+    4.06.1,1.2.2) ppa=avsm/ocaml42+opam12 ;;
     *) echo Unknown $OCAML_VERSION,$OPAM_VERSION; exit 1 ;;
 esac
 

data/tracks/ocaml/.travis.yml

@@ -6,4 +6,4 @@ script:
   - bin/configlet lint .
 
 env:
-  - OCAML_VERSION=4.06.0 OPAM_VERSION=1.2.2
+  - OCAML_VERSION=4.06.1 OPAM_VERSION=1.2.2

data/tracks/ocaml/README.md

@@ -11,7 +11,7 @@ notes contain a few details specific to Ocaml.
 
 ## Prerequisites
 
-The OCaml track assumes installation of OCaml version 4.06.0, and installation of Core, OUnit, and React (for the Hangman exercise).
+The OCaml track assumes installation of OCaml version 4.06.1, and installation of Core, OUnit, and React (for the Hangman exercise).
 Assuming you have opam, these can be installed with
 ```bash
 opam install core ounit react

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

@@ -15,6 +15,8 @@ To work on the exercises, you will need `Opam` and `Core`. Consult [opam](https:
 opam install core
 ```
 
+Documentation for Core can be found [here](https://ocaml.janestreet.com/ocaml-core/latest/doc/core/)
+
 To run the tests you will need `OUnit`. Install it using `opam`:
 
 ```bash

data/tracks/python/config.json

@@ -944,6 +944,19 @@
         "conditionals"
       ]
     },
+    {
+      "uuid": "1d21cd68-10ac-427d-be6d-77152bceacc4",
+      "slug": "rational-numbers",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 2,
+      "topics": [
+        "equality",
+        "classes",
+        "floating_point_numbers",
+        "mathematics"
+      ]
+    },
     {
       "uuid": "a7bc6837-59e4-46a1-89a2-a5aa44f5e66e",
       "slug": "diamond",

data/tracks/python/exercises/all-your-base/all_your_base.py

@@ -1,2 +1,2 @@
-def rebase(from_base, digits, to_base):
+def rebase(input_base, digits, output_base):
     pass

data/tracks/python/exercises/all-your-base/all_your_base_test.py

@@ -3,7 +3,7 @@ import unittest
 from all_your_base import rebase
 
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v2.3.0
 
 class AllYourBaseTests(unittest.TestCase):
 
@@ -43,15 +43,15 @@ class AllYourBaseTests(unittest.TestCase):
     def test_leading_zeros(self):
         self.assertEqual(rebase(7, [0, 6, 0], 10), [4, 2])
 
-    def test_first_base_is_one(self):
+    def test_input_base_is_one(self):
         with self.assertRaisesWithMessage(ValueError):
-            rebase(1, [], 10)
+            rebase(1, [0], 10)
 
-    def test_first_base_is_zero(self):
+    def test_input_base_is_zero(self):
         with self.assertRaisesWithMessage(ValueError):
             rebase(0, [], 10)
 
-    def test_first_base_is_negative(self):
+    def test_input_base_is_negative(self):
         with self.assertRaisesWithMessage(ValueError):
             rebase(-2, [1], 10)
 
@@ -63,15 +63,15 @@ class AllYourBaseTests(unittest.TestCase):
         with self.assertRaisesWithMessage(ValueError):
             rebase(2, [1, 2, 1, 0, 1, 0], 10)
 
-    def test_second_base_is_one(self):
+    def test_output_base_is_one(self):
         with self.assertRaisesWithMessage(ValueError):
             rebase(2, [1, 0, 1, 0, 1, 0], 1)
 
-    def test_second_base_is_zero(self):
+    def test_output_base_is_zero(self):
         with self.assertRaisesWithMessage(ValueError):
             rebase(10, [7], 0)
 
-    def test_second_base_is_negative(self):
+    def test_output_base_is_negative(self):
         with self.assertRaisesWithMessage(ValueError):
             rebase(2, [1], -7)
 

data/tracks/python/exercises/alphametics/alphametics_test.py

@@ -3,23 +3,23 @@ import unittest
 from alphametics import solve
 
 
-# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.2.0
 
 class TestAlphametics(unittest.TestCase):
-    def test_puzzle_with_03_letters(self):
+    def test_puzzle_with_three_letters(self):
         self.assertEqual(solve("I + BB == ILL"), {"I": 1, "B": 9, "L": 0})
 
-    def test_invalid_solution_must_have_unique_value_for_each_letter(self):
+    def test_solution_must_have_unique_value_for_each_letter(self):
         self.assertEqual(solve("A == B"), {})
 
-    def test_invalid_leading_zero_solution(self):
+    def test_leading_zero_solution_is_invalid(self):
         self.assertEqual(solve("ACA + DD == BD"), {})
 
-    def test_puzzle_with_04_letters(self):
+    def test_puzzle_with_four_letters(self):
         self.assertEqual(
             solve("AS + A == MOM"), {"A": 9, "S": 2, "M": 1, "O": 0})
 
-    def test_puzzle_with_06_letters(self):
+    def test_puzzle_with_six_letters(self):
         self.assertEqual(
             solve("NO + NO + TOO == LATE"),
             {"N": 7,
@@ -29,7 +29,7 @@ class TestAlphametics(unittest.TestCase):
              "A": 0,
              "E": 2})
 
-    def test_puzzle_with_07_letters(self):
+    def test_puzzle_with_seven_letters(self):
         self.assertEqual(
             solve("HE + SEES + THE == LIGHT"),
             {"E": 4,
@@ -40,7 +40,7 @@ class TestAlphametics(unittest.TestCase):
              "S": 9,
              "T": 7})
 
-    def test_puzzle_with_08_letters(self):
+    def test_puzzle_with_eight_letters(self):
         self.assertEqual(
             solve("SEND + MORE == MONEY"),
             {"S": 9,
@@ -52,7 +52,7 @@ class TestAlphametics(unittest.TestCase):
              "R": 8,
              "Y": 2})
 
-    def test_puzzle_with_10_letters(self):
+    def test_puzzle_with_ten_letters(self):
         self.assertEqual(
             solve("AND + A + STRONG + OFFENSE + AS + A + GOOD == DEFENSE"),
             {"A": 5,
@@ -66,6 +66,46 @@ class TestAlphametics(unittest.TestCase):
              "S": 6,
              "T": 9})
 
+    def test_puzzle_with_ten_letters_and_199_addends(self):
+        self.assertEqual(
+            solve(
+                "THIS + A + FIRE + THEREFORE + FOR + ALL + HISTORIES + I + "
+                "TELL + A + TALE + THAT + FALSIFIES + ITS + TITLE + TIS + "
+                "A + LIE + THE + TALE + OF + THE + LAST + FIRE + HORSES + "
+                "LATE + AFTER + THE + FIRST + FATHERS + FORESEE + THE + "
+                "HORRORS + THE + LAST + FREE + TROLL + TERRIFIES + THE + "
+                "HORSES + OF + FIRE + THE + TROLL + RESTS + AT + THE + "
+                "HOLE + OF + LOSSES + IT + IS + THERE + THAT + SHE + STORES + "
+                "ROLES + OF + LEATHERS + AFTER + SHE + SATISFIES + HER + "
+                "HATE + OFF + THOSE + FEARS + A + TASTE + RISES + AS + SHE + "
+                "HEARS + THE + LEAST + FAR + HORSE + THOSE + FAST + HORSES + "
+                "THAT + FIRST + HEAR + THE + TROLL + FLEE + OFF + TO + THE + "
+                "FOREST + THE + HORSES + THAT + ALERTS + RAISE + THE + STARES "
+                "+ OF + THE + OTHERS + AS + THE + TROLL + ASSAILS + AT + THE "
+                "+ TOTAL + SHIFT + HER + TEETH + TEAR + HOOF + OFF + TORSO + "
+                "AS + THE + LAST + HORSE + FORFEITS + ITS + LIFE + THE + "
+                "FIRST + FATHERS + HEAR + OF + THE + HORRORS + THEIR + FEARS "
+                "+ THAT + THE + FIRES + FOR + THEIR + FEASTS + ARREST + AS + "
+                "THE + FIRST + FATHERS + RESETTLE + THE + LAST + OF + THE + "
+                "FIRE + HORSES + THE + LAST + TROLL + HARASSES + THE + FOREST "
+                "+ HEART + FREE + AT + LAST + OF + THE + LAST + TROLL + ALL + "
+                "OFFER + THEIR + FIRE + HEAT + TO + THE + ASSISTERS + FAR + "
+                "OFF + THE + TROLL + FASTS + ITS + LIFE + SHORTER + AS + "
+                "STARS + RISE + THE + HORSES + REST + SAFE + AFTER + ALL + "
+                "SHARE + HOT + FISH + AS + THEIR + AFFILIATES + TAILOR + A + "
+                "ROOFS + FOR + THEIR + SAFE == FORTRESSES"
+            ),
+            {"A": 1,
+             "E": 0,
+             "F": 5,
+             "H": 8,
+             "I": 7,
+             "L": 2,
+             "O": 6,
+             "R": 3,
+             "S": 4,
+             "T": 9})
+
 
 if __name__ == '__main__':
     unittest.main()