Implement new exercise: Zipper (#1327)

* Implement Zipper

* Update config

* Update readme

* Minor changes

* Update all methods to package private

config.json

     },
     {
       "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,
       "slug": "ocr-numbers",
       "topics": [

exercises/settings.gradle

 include 'word-count'
 include 'word-search'
 include 'wordy'
+include 'zipper'

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

+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);
+    }
+
+}

exercises/zipper/.meta/version

+1.1.0

exercises/zipper/README.md

+# Zipper
+
+Creating a zipper for a binary tree.
+
+Zippers 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).
+
+Find out more about Zipper: https://en.wikipedia.org/wiki/Zipper_%28data_structure%29
+
+A zipper should be able to perform 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)
+* `left` (move the focus to the left child, returns a new zipper)
+* `right` (move the focus to the right child, returns a new zipper)
+* `set_value` (set the value of the focus node, returns a new zipper)
+* `set_left` (set the left child of the focus node, returns a new zipper)
+* `set_right` (set the right child 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)
+
+Together with zippers, implement binary tree objects that contains a zipper as the root.
+Trees are encoded as nested objects. Each node in the tree has three members: 'value', 'left', and 'right'. Each value is a number (for simplicity). Left and right are trees. An empty node is encoded as null.
+Implement `toString` method to print the tree as a single string.
+
+An example of a tree is as follow: tree: value: 1, left: { value: 2, left: null, right: { value: 3, left: null, right: null } }, right: { value: 4, left: null, right: null }
+
+# 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.

exercises/zipper/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/zipper/src/test/java/ZipperTest.java

+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);
+    }
+}