Add zipper exercise

config.json

@@ -814,6 +814,15 @@
         "Transforming"
       ]
     },
+    {
+      "slug": "zipper",
+      "difficulty": 10,
+      "topics": [
+        "Trees",
+        "Recursion",
+        "Searching"
+      ]
+    },
     {
       "slug": "alphametics",
       "difficulty": 10,

exercises/pov/Example.cs

@@ -17,9 +17,9 @@ public bool Equals(Graph<T> other) =>
         Value.Equals(other.Value) && Children.SequenceEqual(other.Children);
 }
 
-public class Crumb<T>
+public class GraphCrumb<T>
 {
-    public Crumb(T value, IEnumerable<Graph<T>> left, IEnumerable<Graph<T>> right)
+    public GraphCrumb(T value, IEnumerable<Graph<T>> left, IEnumerable<Graph<T>> right)
     {
         Value = value;
         Left = left;
@@ -31,16 +31,16 @@ public Crumb(T value, IEnumerable<Graph<T>> left, IEnumerable<Graph<T>> right)
     public IEnumerable<Graph<T>> Right { get; }
 }
 
-public class Zipper<T>
+public class GraphZipper<T>
 {
-    public Zipper(Graph<T> focus, IEnumerable<Crumb<T>> crumbs)
+    public GraphZipper(Graph<T> focus, IEnumerable<GraphCrumb<T>> crumbs)
     {
         Focus = focus;
         Crumbs = crumbs;
     }
 
     public Graph<T> Focus { get; }
-    public IEnumerable<Crumb<T>> Crumbs { get; }
+    public IEnumerable<GraphCrumb<T>> Crumbs { get; }
 }
 
 public static class Pov
@@ -54,49 +54,49 @@ public static Graph<T> FromPOV<T>(T value, Graph<T> graph) where T : IComparable
     public static IEnumerable<T> TracePathBetween<T>(T value1, T value2, Graph<T> graph) where T : IComparable
         => ZipperToPath(FindNode(value2, GraphToZipper(FromPOV(value1, graph))));
 
-    private static Zipper<T> GraphToZipper<T>(Graph<T> graph)
+    private static GraphZipper<T> GraphToZipper<T>(Graph<T> graph)
     {
         if (graph == null)
             return null;
 
-        return new Zipper<T>(graph, Enumerable.Empty<Crumb<T>>());
+        return new GraphZipper<T>(graph, Enumerable.Empty<GraphCrumb<T>>());
     }
 
-    private static IEnumerable<T> ZipperToPath<T>(Zipper<T> zipper)
+    private static IEnumerable<T> ZipperToPath<T>(GraphZipper<T> zipper)
     {
         if (zipper == null)
             return null;
 
         return zipper.Crumbs.Select(c => c.Value).Reverse().Concat(new[] { zipper.Focus.Value });
     }
 
-    private static Zipper<T> GoDown<T>(Zipper<T> zipper)
+    private static GraphZipper<T> GoDown<T>(GraphZipper<T> zipper)
     {        
         if (zipper == null || !zipper.Focus.Children.Any())
             return null;
 
         var focus = zipper.Focus;
         var children = focus.Children;
 
-        var newCrumb = new Crumb<T>(focus.Value, Enumerable.Empty<Graph<T>>(), children.Skip(1));
+        var newCrumb = new GraphCrumb<T>(focus.Value, Enumerable.Empty<Graph<T>>(), children.Skip(1));
 
-        return new Zipper<T>(children.First(), new[] { newCrumb }.Concat(zipper.Crumbs));
+        return new GraphZipper<T>(children.First(), new[] { newCrumb }.Concat(zipper.Crumbs));
     }
 
-    private static Zipper<T> GoRight<T>(Zipper<T> zipper)
+    private static GraphZipper<T> GoRight<T>(GraphZipper<T> zipper)
     {        
         if (zipper == null || !zipper.Crumbs.Any() || !zipper.Crumbs.First().Right.Any())
             return null;
 
         var crumbs = zipper.Crumbs;
         var firstCrumb = crumbs.First();
 
-        var newCrumb = new Crumb<T>(firstCrumb.Value, firstCrumb.Left.Concat(new[] { zipper.Focus }), firstCrumb.Right.Skip(1));
+        var newCrumb = new GraphCrumb<T>(firstCrumb.Value, firstCrumb.Left.Concat(new[] { zipper.Focus }), firstCrumb.Right.Skip(1));
 
-        return new Zipper<T>(firstCrumb.Right.First(), new[] { newCrumb }.Concat(crumbs.Skip(1)));
+        return new GraphZipper<T>(firstCrumb.Right.First(), new[] { newCrumb }.Concat(crumbs.Skip(1)));
     }
 
-    private static Zipper<T> FindNode<T>(T value, Zipper<T> zipper)
+    private static GraphZipper<T> FindNode<T>(T value, GraphZipper<T> zipper)
         where T : IComparable
     {
         if (zipper == null || zipper.Focus.Value.CompareTo(value) == 0)
@@ -105,7 +105,7 @@ private static Zipper<T> FindNode<T>(T value, Zipper<T> zipper)
         return FindNode(value, GoDown(zipper)) ?? FindNode(value, GoRight(zipper));
     }
 
-    private static Graph<T> ChangeParent<T>(Zipper<T> zipper)
+    private static Graph<T> ChangeParent<T>(GraphZipper<T> zipper)
     {
         if (zipper == null)
             return null;
@@ -116,7 +116,7 @@ private static Graph<T> ChangeParent<T>(Zipper<T> zipper)
         var firstCrumb = zipper.Crumbs.First();
         var focus = zipper.Focus;
 
-        var newZipper = new Zipper<T>(CreateGraph(firstCrumb.Value, firstCrumb.Left.Concat(firstCrumb.Right)), zipper.Crumbs.Skip(1));
+        var newZipper = new GraphZipper<T>(CreateGraph(firstCrumb.Value, firstCrumb.Left.Concat(firstCrumb.Right)), zipper.Crumbs.Skip(1));
         var parentGraph = ChangeParent(newZipper);
 
         var ys = focus.Children.Concat(new[] { parentGraph });

exercises/zipper/Example.cs

@@ -0,0 +1,137 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+public class BinTree<T> : IEquatable<BinTree<T>>
+{
+    public BinTree(T value, BinTree<T> left, BinTree<T> right)
+    {
+        Value = value;
+        Left = left;
+        Right = right;
+    }
+
+    public BinTree(BinTree<T> tree) : this(tree.Value, tree.Left, tree.Right)
+    {
+    }
+
+    public T Value { get; }
+    public BinTree<T> Left { get; }
+    public BinTree<T> Right { get; }
+
+    public bool Equals(BinTree<T> other)
+    {
+        if (other == null || !Equals(Value, other.Value))
+            return false;
+
+        if (!ReferenceEquals(Left, other.Left) && (!Left?.Equals(other.Left) ?? false))
+            return false;
+
+        if (!ReferenceEquals(Right, other.Right) && (!Right?.Equals(other.Right) ?? false))
+            return false;
+
+        return true;
+    }
+}
+
+public abstract class BinTreeCrumb<T>
+{
+    public BinTreeCrumb(T value, BinTree<T> tree)
+    {
+        Value = value;
+        Tree = tree;
+    }
+
+    public T Value { get; }
+    public BinTree<T> Tree { get; }
+}
+
+public class BinTreeLeftCrumb<T> : BinTreeCrumb<T>
+{
+    public BinTreeLeftCrumb(T value, BinTree<T> tree) : base(value, tree)
+    {
+    }
+}
+
+public class BinTreeRightCrumb<T> : BinTreeCrumb<T>
+{
+    public BinTreeRightCrumb(T value, BinTree<T> tree) : base(value, tree)
+    {
+    }
+}
+
+public class Zipper<T>
+{
+    private readonly T value;
+    private readonly BinTree<T> left;
+    private readonly BinTree<T> right;
+    private readonly List<BinTreeCrumb<T>> crumbs;
+
+    public Zipper(T value, BinTree<T> left, BinTree<T> right, List<BinTreeCrumb<T>> crumbs)
+    {
+        this.value = value;
+        this.left = left;
+        this.right = right;
+        this.crumbs = crumbs;
+    }
+
+    public T Value => value;
+
+    public Zipper<T> SetValue(T newValue) => new Zipper<T>(newValue, left, right, crumbs);
+
+    public Zipper<T> SetLeft(BinTree<T> binTree) => new Zipper<T>(value, binTree, right, crumbs);
+
+    public Zipper<T> SetRight(BinTree<T> binTree) => new Zipper<T>(value, left, binTree, crumbs);
+
+    public Zipper<T> Left()
+    {
+        if (left == null)
+            return null;
+
+        var newCrumbs = new[] { new BinTreeLeftCrumb<T>(value, right) }.Concat(crumbs).ToList();
+        return new Zipper<T>(left.Value, left.Left, left.Right, newCrumbs);
+    }
+
+    public Zipper<T> Right()
+    {
+        if (right == null)
+            return null;
+
+        var newCrumbs = new[] { new BinTreeRightCrumb<T>(value, left) }.Concat(crumbs).ToList();
+        return new Zipper<T>(right.Value, right.Left, right.Right, newCrumbs);
+    }
+
+    public Zipper<T> Up()
+    {
+        if (crumbs.Count == 0)
+            return null;
+
+        var firstCrumb = crumbs[0];
+        var remainingCrumbs = crumbs.Skip(1).ToList();
+
+        if (firstCrumb is BinTreeLeftCrumb<T>)
+            return new Zipper<T>(firstCrumb.Value, new BinTree<T>(value, left, right), firstCrumb.Tree, remainingCrumbs);
+
+        if (firstCrumb is BinTreeRightCrumb<T>)
+            return new Zipper<T>(firstCrumb.Value, firstCrumb.Tree, new BinTree<T>(value, left, right), remainingCrumbs);
+
+        return null;
+    }
+
+    public BinTree<T> ToTree()
+    {
+        var tree = new BinTree<T>(value, left, right);
+
+        foreach (var crumb in crumbs)
+        {
+            if (crumb is BinTreeLeftCrumb<T>)
+                tree = new BinTree<T>(crumb.Value, new BinTree<T>(tree), crumb.Tree);
+            if (crumb is BinTreeRightCrumb<T>)
+                tree = new BinTree<T>(crumb.Value, crumb.Tree, new BinTree<T>(tree));
+        }
+
+        return tree;
+    }
+
+    public static Zipper<T> FromTree(BinTree<T> tree) => new Zipper<T>(tree.Value, tree.Left, tree.Right, new List<BinTreeCrumb<T>>());
+}

exercises/zipper/ZipperTest.cs

@@ -0,0 +1,83 @@
+using NUnit.Framework;
+
+public class ZipperTest
+{
+    private static BinTree<int> bt(int v, BinTree<int> l, BinTree<int> r) => new BinTree<int>(v, l, r);
+    private static BinTree<int> leaf(int v) => bt(v, null, null);
+
+    private static readonly BinTree<int> empty = null;
+    private static readonly BinTree<int> t1 = new BinTree<int>(1, bt(2, empty, leaf(3)), leaf(4));
+    private static readonly BinTree<int> t2 = new BinTree<int>(1, bt(5, empty, leaf(3)), leaf(4));
+    private static readonly BinTree<int> t3 = new BinTree<int>(1, bt(2, leaf(5), leaf(3)), leaf(4));
+    private static readonly BinTree<int> t4 = new BinTree<int>(1, leaf(2), leaf(4));
+
+    [Test]
+    public void Data_is_retained()
+    {
+        var zipper = Zipper<int>.FromTree(t1);
+        var tree = zipper.ToTree();
+        Assert.That(tree, Is.EqualTo(t1));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Left_right_and_value()
+    {
+        var zipper = Zipper<int>.FromTree(t1);
+        Assert.That(zipper.Left().Right().Value, Is.EqualTo(3));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Dead_end()
+    {
+        var zipper = Zipper<int>.FromTree(t1);
+        Assert.That(zipper.Left().Left(), Is.Null);
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Tree_from_deep_focus()
+    {
+        var zipper = Zipper<int>.FromTree(t1);
+        Assert.That(zipper.Left().Right().ToTree(), Is.EqualTo(t1));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Set_value()
+    {
+        var zipper = Zipper<int>.FromTree(t1);
+        var updatedZipper = zipper.Left().SetValue(5);
+        var tree = updatedZipper.ToTree();
+        Assert.That(tree, Is.EqualTo(t2));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Set_left_with_value()
+    {
+        var zipper = Zipper<int>.FromTree(t1);
+        var updatedZipper = zipper.Left().SetLeft(new BinTree<int>(5, null, null));
+        var tree = updatedZipper.ToTree();
+        Assert.That(tree, Is.EqualTo(t3));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Set_right_to_null()
+    {
+        var zipper = Zipper<int>.FromTree(t1);
+        var updatedZipper = zipper.Left().SetRight(null);
+        var tree = updatedZipper.ToTree();
+        Assert.That(tree, Is.EqualTo(t4));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Different_paths_to_same_zipper()
+    {
+        var zipper = Zipper<int>.FromTree(t1);
+        Assert.That(zipper.Left().Up().Right().ToTree(), Is.EqualTo(zipper.Right().ToTree()));
+    }
+}