trackler 2.2.1.107 → 2.2.1.108

data/tracks/groovy/exercises/phone-number/PhoneNumber.groovy

@@ -1,17 +1,5 @@
 class PhoneNumber {
-
-    String areaCode, exchange, subscriber
-
-    public PhoneNumber(String input) {
-        throw new UnsupportedOperationException('Constructor implementation is missing')
+    PhoneNumber(String input) {
+        throw new UnsupportedOperationException('Constructor not implemented')
     }
-
-    String getNumber() {
-        throw new UnsupportedOperationException('Method implementation is missing')
-    }
-
-    String toString() {
-        throw new UnsupportedOperationException('Method implementation is missing')
-    }
-
 }

data/tracks/groovy/exercises/phone-number/PhoneNumberSpec.groovy

@@ -2,74 +2,87 @@
 import spock.lang.*
 
 class PhoneNumberSpec extends Specification {
+    def 'cleans the number'() {
+        expect: new PhoneNumber('(223) 456-7890').number == '2234567890'
+    }
 
-    def 'a phone number is valid'() {
-        expect: new PhoneNumber('(123) 456-7890').number == '1234567890'
+    @Ignore
+    def 'cleans numbers with dots'() {
+        expect: new PhoneNumber('223.456.7890').number == '2234567890'
     }
 
     @Ignore
-    def 'a different phone number is valid'() {
-        expect: new PhoneNumber('(987) 654-3210').number == '9876543210'
+    def 'cleans numbers with multiple spaces'() {
+        expect: new PhoneNumber('223 456   7890   ').number == '2234567890'
     }
 
     @Ignore
-    def 'a phone nubmer separated by dots is valid'() {
-        expect: new PhoneNumber('456.123.7890').number == '4561237890'
+    def 'invalid when 9 digits'() {
+        expect: new PhoneNumber('123456789').number == '0000000000'
     }
 
     @Ignore
-    def 'a letter-containing phone number is invalid'() {
-        expect: new PhoneNumber('123-abc-1234').number == '0000000000'
+    def 'invalid when 11 digits does not start with a 1'() {
+        expect: new PhoneNumber('22234567890').number == '0000000000'
     }
 
     @Ignore
-    def 'a 9-digit number is invalid'() {
-        expect: new PhoneNumber('123456789').number == '0000000000'
+    def 'valid when 11 digits and starting with 1'() {
+        expect: new PhoneNumber('12234567890').number == '2234567890'
     }
 
     @Ignore
-    def 'an 11-digit number starting with a 1 is valid'() {
-        expect: new PhoneNumber('19876543210').number == '9876543210'
+    def 'valid when 11 digits and starting with 1 even with punctuation'() {
+        expect: new PhoneNumber('+1 (223) 456-7890').number == '2234567890'
     }
 
     @Ignore
-    def 'a 10-digit number, with an area code starting with 1, is valid'() {
-        expect: new PhoneNumber('1234567890').number == '1234567890'
+    def 'invalid when more than 11 digits'() {
+        expect: new PhoneNumber('321234567890').number == '0000000000'
     }
 
     @Ignore
-    def 'an 11-digit number, not beginning with a 1, is invalid'(){
-        expect: new PhoneNumber('21234567890').number == '0000000000'
+    def 'invalid with letters'() {
+        expect: new PhoneNumber('123-abc-7890').number == '0000000000'
     }
 
     @Ignore
-    def 'a 12-digit number, even one beginning with a 1, is invalid'(){
-        expect: new PhoneNumber('112345678901').number == '0000000000'
+    def 'invalid with punctuations'() {
+        expect: new PhoneNumber('123-@:!-7890').number == '0000000000'
     }
 
     @Ignore
-    def 'a 10-digit number containing letters is inavlid'() {
-        expect: new PhoneNumber('1a2a3a4a5a6a7a8a9a0a').number == '0000000000'
+    def 'invalid if area code starts with 0'() {
+        expect: new PhoneNumber('(023) 456-7890').number == '0000000000'
     }
 
     @Ignore
-    def 'can extract area code from a phone number'() {
-        expect: new PhoneNumber('1234567890').areaCode == '123'
+    def 'invalid if area code starts with 1'() {
+        expect: new PhoneNumber('(123) 456-7890').number == '0000000000'
     }
 
     @Ignore
-    def 'can extract an area code from a different phone number'() {
+    def 'invalid if exchange code starts with 0'() {
+        expect: new PhoneNumber('(223) 056-7890').number == '0000000000'
+    }
+
+    @Ignore
+    def 'invalid if exchange code starts with 1'() {
+        expect: new PhoneNumber('(223) 156-7890').number == '0000000000'
+    }
+
+    @Ignore
+    def 'can extract an area code from a phone number'() {
         expect: new PhoneNumber('9876543210').areaCode == '987'
     }
 
     @Ignore
     def 'can pretty print a phone number'() {
-        expect: new PhoneNumber('5551234567').toString() == '(555) 123-4567'
+        expect: new PhoneNumber('5552234567').toString() == '(555) 223-4567'
     }
 
     @Ignore
     def 'can pretty print a full U.S. phone number'() {
-        expect: new PhoneNumber('11234567890').toString() == '(123) 456-7890'
+        expect: new PhoneNumber('12234567890').toString() == '(223) 456-7890'
     }
-
 }

data/tracks/groovy/exercises/phone-number/README.md

@@ -13,7 +13,7 @@ The format is usually represented as
 ```
 where `N` is any digit from 2 through 9 and `X` is any digit from 0 through 9.
 
-Your task is to clean up differently formated telephone numbers by removing punctuation and the country code (1) if present.
+Your task is to clean up differently formatted telephone numbers by removing punctuation and the country code (1) if present.
 
 For example, the inputs
 - `+1 (613)-995-0253`

data/tracks/java/config.json

@@ -1050,6 +1050,19 @@
       "unlocked_by": "saddle-points",
       "uuid": "97c8fcd4-85b6-41cb-9de2-b4e1b4951222"
     },
+    {
+      "core": false,
+      "difficulty": 7,
+      "slug": "zipper",
+      "topics": [
+        "integer",
+        "nodes",
+        "tree",
+        "links"
+      ],
+      "unlocked_by": "linked-list",
+      "uuid": "25d2c7a5-1ec8-464a-b3de-ad1b27464ef1"
+    },
     {
       "core": false,
       "difficulty": 8,

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

@@ -25,6 +25,16 @@ enough.)
 
 Words are case-insensitive.
 
+# Running the tests
+
+You can run all the tests for an exercise by entering
+
+```sh
+$ gradle test
+```
+
+in your terminal.
+
 ## Submitting Incomplete Solutions
 
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/java/exercises/rna-transcription/.meta/version

@@ -1 +1 @@
-1.1.0
+1.2.0

data/tracks/java/exercises/settings.gradle

@@ -95,3 +95,4 @@ include 'two-fer'
 include 'word-count'
 include 'word-search'
 include 'wordy'
+include 'zipper'

data/tracks/java/exercises/sieve/.meta/version

@@ -1 +1 @@
-1.0.0
+1.1.0

data/tracks/java/exercises/spiral-matrix/.meta/version

@@ -1 +1 @@
-1.0.0
+1.1.0

data/tracks/java/exercises/triangle/.meta/version

@@ -1 +1 @@
-1.0.0
+1.1.0

data/tracks/java/exercises/two-bucket/README.md

@@ -27,7 +27,7 @@ To conclude, the only valid moves are:
 - emptying one bucket and doing nothing to the other
 - filling one bucket and doing nothing to the other
 
-Written with <3 at [Fullstack Academy](http://www.fullstackacademy.com/) by [Lindsay](http://lindsaylevine.com).
+Written with <3 at [Fullstack Academy](http://www.fullstackacademy.com/) by Lindsay Levine.
 
 # Running the tests
 

data/tracks/java/exercises/zipper/.meta/src/reference/java/Zipper.java

@@ -0,0 +1,199 @@
+class Zipper {
+
+    private int value;
+    BinaryTree tree; // Only the root node will bind to the BinaryTree
+    Zipper up;
+    Zipper left;
+    Zipper right;
+
+    Zipper(int val) {
+        value = val;
+        tree = null;
+        up = null;
+        left = null;
+        right = null;
+    }
+
+    /**
+     * Get a zipper out of a rose tree, the focus is on the root node
+     */
+    Zipper fromTree() {
+        Zipper current = this;
+        while (current.up != null) {
+            current = current.up;
+        }
+        return current;
+    }
+
+    BinaryTree toTree() {
+        Zipper current = this;
+        while (current.up != null) {
+            current = current.up;
+        }
+        return current.tree;
+    }
+
+    int getValue() {
+        return value;
+    }
+
+    Zipper setLeft(Zipper leftChild) {
+        left = leftChild;
+        if (leftChild != null) {
+            leftChild.up = this;
+            leftChild.tree = null;
+        }
+        return this;
+    }
+
+    Zipper setRight(Zipper rightChild) {
+        right = rightChild;
+        if (rightChild != null) {
+            rightChild.up = this;
+            rightChild.tree = null;
+        }
+        return this;
+    }
+
+    /**
+     * Move the focus to the previous child of the same parent
+     * @return a new Zipper
+     * Conditions: 1. The current Zipper must have a parent, i.e. it is not the root node.
+     * 2. The current Zipper must be the right child of its parent
+     */
+    Zipper getPrev() {
+        Zipper current = this;
+        try {
+            current = this.up;
+            current = current.left;
+            return current;
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        return null;
+    }
+
+    /**
+     * Move the focus to the next child of the same parent
+     * @return a new Zipper
+     * Conditions: 1. The current Zipper must have a parent, i.e. it is not the root node.
+     * 2. The current Zipper must be the left child of its parent
+     */
+    Zipper getNext() {
+        Zipper current = this;
+        try {
+            current = this.up;
+            current = current.right;
+            return current;
+        } catch (Exception e) {
+            System.out.println(e);
+        }
+        return null;
+    }
+
+    /**
+     * Move the focus to the parent
+     * @return a new Zipper
+     */
+    Zipper getUp() {
+        return up;
+    }
+
+    /**
+     * Set the value of the focus node, returns a new zipper
+     * @param val
+     */
+    void setValue(int val) {
+        this.value = val;
+    }
+
+    /**
+     * Insert a new subtree before the focus node, it becomes the prev of the focus node
+     * @return a new Zipper
+     */
+    Zipper insertBefore(Zipper toTheLeft) {
+        this.left = toTheLeft;
+        return this.left;
+    }
+
+    /**
+     * Insert a new subtree after the focus node, it becomes the next of the focus node
+     * @return a new Zipper
+     */
+    Zipper insertAfter(Zipper toTheRight) {
+        this.right = toTheRight;
+        return this.right;
+    }
+
+    /**
+     * Removes the focus node and all subtrees
+     * Focus moves to the next node if possible otherwise to the prev node if possible, otherwise to the parent node
+     * @return a new zipper
+     */
+    Zipper delete() {
+        Zipper current = this;
+        if (current.up == null) {
+            current = null;
+        } else {
+            if (current.up.left == current) {
+                current = current.up;
+                current.left = null;
+                if (current.right != null) {
+                    current = current.right;
+                }
+            } else {
+                current = current.up;
+                current.right = null;
+                if (current.left != null) {
+                    current = current.left;
+                }
+            }
+        }
+        return current;
+    }
+
+}
+
+class BinaryTree {
+
+    private Zipper root;
+
+    BinaryTree(int value) {
+        root = new Zipper(value);
+        root.tree = this;
+    }
+
+    BinaryTree(Zipper root) {
+        this.root = root;
+        this.root.tree = this;
+    }
+
+    Zipper getRoot() {
+        return root;
+    }
+
+    void setRoot(Zipper zipper) {
+        root = zipper;
+        root.tree = this;
+    }
+
+    String printTree(Zipper zipper) {
+        String str = "";
+        if (zipper.left == null && zipper.right == null) {
+            str += "value: " + zipper.getValue() + ", left: " + null + ", right: " + null;
+        } else if (zipper.left == null) {
+            str += "value: " + zipper.getValue() + ", left: " + null + ", right: { " + printTree(zipper.right) + " }";
+        } else if (zipper.right == null) {
+            str += "value: " + zipper.getValue() + ", left: { " + printTree(zipper.left) + " }, right: " + null;
+        } else {
+            str += "value: " + zipper.getValue() +
+                    ", left: { " + printTree(zipper.left) + " }, right: { " + printTree(zipper.right) + " }";
+        }
+        return str;
+    }
+
+    String printTree() {
+        return printTree(root);
+    }
+
+}

data/tracks/java/exercises/zipper/.meta/version

@@ -0,0 +1 @@
+1.1.0

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

@@ -0,0 +1,42 @@
+# Zipper
+
+Creating a zipper for a binary tree.
+
+[Zippers](https://en.wikipedia.org/wiki/Zipper_%28data_structure%29) are
+a purely functional way of navigating within a data structure and
+manipulating it.  They essentially contain a data structure and a
+pointer into that data structure (called the focus).
+
+For example given a rose tree (where each node contains a value and a
+list of child nodes) a zipper might support these operations:
+
+- `from_tree` (get a zipper out of a rose tree, the focus is on the root node)
+- `to_tree` (get the rose tree out of the zipper)
+- `value` (get the value of the focus node)
+- `prev` (move the focus to the previous child of the same parent,
+  returns a new zipper)
+- `next` (move the focus to the next child of the same parent, returns a
+  new zipper)
+- `up` (move the focus to the parent, returns a new zipper)
+- `set_value` (set the value of the focus node, returns a new zipper)
+- `insert_before` (insert a new subtree before the focus node, it
+  becomes the `prev` of the focus node, returns a new zipper)
+- `insert_after` (insert a new subtree after the focus node, it becomes
+  the `next` of the focus node, returns a new zipper)
+- `delete` (removes the focus node and all subtrees, focus moves to the
+  `next` node if possible otherwise to the `prev` node if possible,
+  otherwise to the parent node, returns a new zipper)
+
+# Running the tests
+
+You can run all the tests for an exercise by entering
+
+```sh
+$ gradle test
+```
+
+in your terminal.
+
+## Submitting Incomplete Solutions
+
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.