trackler 2.2.1.155 → 2.2.1.156

data/tracks/csharp/exercises/zipper/Example.cs

@@ -2,24 +2,24 @@
 using System.Collections.Generic;
 using System.Linq;
 
-public class BinTree<T> : IEquatable<BinTree<T>>
+public class BinTree : IEquatable<BinTree>
 {
-    public BinTree(T value, BinTree<T> left, BinTree<T> right)
+    public BinTree(int value, BinTree left, BinTree right)
     {
         Value = value;
         Left = left;
         Right = right;
     }
 
-    public BinTree(BinTree<T> tree) : this(tree.Value, tree.Left, tree.Right)
+    public BinTree(BinTree tree) : this(tree.Value, tree.Left, tree.Right)
     {
     }
 
-    public T Value { get; }
-    public BinTree<T> Left { get; }
-    public BinTree<T> Right { get; }
+    public int Value { get; }
+    public BinTree Left { get; }
+    public BinTree Right { get; }
 
-    public bool Equals(BinTree<T> other)
+    public bool Equals(BinTree other)
     {
         if (other == null || !Equals(Value, other.Value))
             return false;
@@ -34,40 +34,40 @@ public bool Equals(BinTree<T> other)
     }
 }
 
-public abstract class BinTreeCrumb<T>
+public abstract class BinTreeCrumb
 {
-    public BinTreeCrumb(T value, BinTree<T> tree)
+    public BinTreeCrumb(int value, BinTree tree)
     {
         Value = value;
         Tree = tree;
     }
 
-    public T Value { get; }
-    public BinTree<T> Tree { get; }
+    public int Value { get; }
+    public BinTree Tree { get; }
 }
 
-public class BinTreeLeftCrumb<T> : BinTreeCrumb<T>
+public class BinTreeLeftCrumb : BinTreeCrumb
 {
-    public BinTreeLeftCrumb(T value, BinTree<T> tree) : base(value, tree)
+    public BinTreeLeftCrumb(int value, BinTree tree) : base(value, tree)
     {
     }
 }
 
-public class BinTreeRightCrumb<T> : BinTreeCrumb<T>
+public class BinTreeRightCrumb : BinTreeCrumb
 {
-    public BinTreeRightCrumb(T value, BinTree<T> tree) : base(value, tree)
+    public BinTreeRightCrumb(int value, BinTree tree) : base(value, tree)
     {
     }
 }
 
-public class Zipper<T>
+public class Zipper : IEquatable<Zipper>
 {
-    private readonly T value;
-    private readonly BinTree<T> left;
-    private readonly BinTree<T> right;
-    private readonly List<BinTreeCrumb<T>> crumbs;
+    private readonly int value;
+    private readonly BinTree left;
+    private readonly BinTree right;
+    private readonly List<BinTreeCrumb> crumbs;
 
-    public Zipper(T value, BinTree<T> left, BinTree<T> right, List<BinTreeCrumb<T>> crumbs)
+    public Zipper(int value, BinTree left, BinTree right, List<BinTreeCrumb> crumbs)
     {
         this.value = value;
         this.left = left;
@@ -75,33 +75,33 @@ public Zipper(T value, BinTree<T> left, BinTree<T> right, List<BinTreeCrumb<T>>
         this.crumbs = crumbs;
     }
     
-    public T Value => value;
+    public int Value() => value;
 
-    public Zipper<T> SetValue(T newValue) => new Zipper<T>(newValue, left, right, crumbs);
+    public Zipper SetValue(int newValue) => new Zipper(newValue, left, right, crumbs);
 
-    public Zipper<T> SetLeft(BinTree<T> binTree) => new Zipper<T>(value, binTree, right, crumbs);
+    public Zipper SetLeft(BinTree binTree) => new Zipper(value, binTree, right, crumbs);
 
-    public Zipper<T> SetRight(BinTree<T> binTree) => new Zipper<T>(value, left, binTree, crumbs);
+    public Zipper SetRight(BinTree binTree) => new Zipper(value, left, binTree, crumbs);
 
-    public Zipper<T> Left()
+    public Zipper 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);
+        var newCrumbs = new[] { new BinTreeLeftCrumb(value, right) }.Concat(crumbs).ToList();
+        return new Zipper(left.Value, left.Left, left.Right, newCrumbs);
     }
 
-    public Zipper<T> Right()
+    public Zipper 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);
+        var newCrumbs = new[] { new BinTreeRightCrumb(value, left) }.Concat(crumbs).ToList();
+        return new Zipper(right.Value, right.Left, right.Right, newCrumbs);
     }
 
-    public Zipper<T> Up()
+    public Zipper Up()
     {
         if (crumbs.Count == 0)
             return null;
@@ -109,29 +109,37 @@ public Zipper<T> Up()
         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 BinTreeLeftCrumb)
+            return new Zipper(firstCrumb.Value, new BinTree(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);
+        if (firstCrumb is BinTreeRightCrumb)
+            return new Zipper(firstCrumb.Value, firstCrumb.Tree, new BinTree(value, left, right), remainingCrumbs);
         
         return null;
     }
 
-    public BinTree<T> ToTree()
+    public BinTree ToTree()
     {
-        var tree = new BinTree<T>(value, left, right);
+        var tree = new BinTree(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));
+            if (crumb is BinTreeLeftCrumb)
+                tree = new BinTree(crumb.Value, new BinTree(tree), crumb.Tree);
+            if (crumb is BinTreeRightCrumb)
+                tree = new BinTree(crumb.Value, crumb.Tree, new BinTree(tree));
         }
 
         return tree;
     }
 
-    public static Zipper<T> FromTree(BinTree<T> tree) => new Zipper<T>(tree.Value, tree.Left, tree.Right, new List<BinTreeCrumb<T>>());
+    public bool Equals(Zipper other)
+    {
+        if (other == null)
+            return false;
+
+        return ToTree().Equals(other.ToTree());
+    }
+
+    public static Zipper FromTree(BinTree tree) => new Zipper(tree.Value, tree.Left, tree.Right, new List<BinTreeCrumb>());
 }

data/tracks/csharp/exercises/zipper/Zipper.cs

@@ -1,63 +1,60 @@
 using System;
 
-public class BinTree<T>
+public class BinTree
 {
-    public BinTree(T value, BinTree<T> left, BinTree<T> right)
+    public BinTree(int value, BinTree left, BinTree right)
     {
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    public T Value { get; }
-    public BinTree<T> Left { get; }
-    public BinTree<T> Right { get; }
+    public int Value { get; }
+    public BinTree Left { get; }
+    public BinTree Right { get; }
 }
 
-public class Zipper<T>
+public class Zipper
 {   
-    public T Value
+    public int Value()
     {
-        get
-        {
-            throw new NotImplementedException("You need to implement this function.");
-        }
+        throw new NotImplementedException("You need to implement this function.");
     }
 
-    public Zipper<T> SetValue(T newValue)
+    public Zipper SetValue(int newValue)
     {
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    public Zipper<T> SetLeft(BinTree<T> binTree)
+    public Zipper SetLeft(BinTree binTree)
     {
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    public Zipper<T> SetRight(BinTree<T> binTree) 
+    public Zipper SetRight(BinTree binTree) 
     {
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    public Zipper<T> Left()
+    public Zipper Left()
     {
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    public Zipper<T> Right()
+    public Zipper Right()
     {
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    public Zipper<T> Up()
+    public Zipper Up()
     {
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    public BinTree<T> ToTree()
+    public BinTree ToTree()
     {
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    public static Zipper<T> FromTree(BinTree<T> tree)
+    public static Zipper FromTree(BinTree tree)
     {
         throw new NotImplementedException("You need to implement this function.");
     }

data/tracks/csharp/exercises/zipper/ZipperTest.cs

@@ -1,85 +1,134 @@
-using Xunit;
+// This file was auto-generated based on version 1.1.0 of the canonical data.
+
+using Xunit;
 
 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 readonly BinTree<int> empty;
-    private readonly BinTree<int> t1;
-    private readonly BinTree<int> t2;
-    private readonly BinTree<int> t3;
-    private readonly BinTree<int> t4;
-
-    public ZipperTest()
-    {
-        empty = null;
-        t1 = new BinTree<int>(1, bt(2, empty, leaf(3)), leaf(4));
-        t2 = new BinTree<int>(1, bt(5, empty, leaf(3)), leaf(4));
-        t3 = new BinTree<int>(1, bt(2, leaf(5), leaf(3)), leaf(4));
-        t4 = new BinTree<int>(1, leaf(2), leaf(4));
-    }
-
     [Fact]
     public void Data_is_retained()
     {
-        var zipper = Zipper<int>.FromTree(t1);
-        var tree = zipper.ToTree();
-        Assert.Equal(t1, tree);
+        var tree = new BinTree(1, new BinTree(2, null, new BinTree(3, null, null)), new BinTree(4, null, null));
+        var sut = Zipper.FromTree(tree);
+        var actual = sut.ToTree();
+        var expected = new BinTree(1, new BinTree(2, null, new BinTree(3, null, null)), new BinTree(4, null, null));
+        Assert.Equal(expected, actual);
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Left_right_and_value()
     {
-        var zipper = Zipper<int>.FromTree(t1);
-        Assert.Equal(3, zipper.Left().Right().Value);
+        var tree = new BinTree(1, new BinTree(2, null, new BinTree(3, null, null)), new BinTree(4, null, null));
+        var sut = Zipper.FromTree(tree);
+        var actual = sut.Left().Right().Value();
+        var expected = 3;
+        Assert.Equal(expected, actual);
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Dead_end()
     {
-        var zipper = Zipper<int>.FromTree(t1);
-        Assert.Null(zipper.Left().Left());
+        var tree = new BinTree(1, new BinTree(2, null, new BinTree(3, null, null)), new BinTree(4, null, null));
+        var sut = Zipper.FromTree(tree);
+        var actual = sut.Left().Left();
+        Assert.Null(actual);
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Tree_from_deep_focus()
     {
-        var zipper = Zipper<int>.FromTree(t1);
-        Assert.Equal(t1, zipper.Left().Right().ToTree());
+        var tree = new BinTree(1, new BinTree(2, null, new BinTree(3, null, null)), new BinTree(4, null, null));
+        var sut = Zipper.FromTree(tree);
+        var actual = sut.Left().Right().ToTree();
+        var expected = new BinTree(1, new BinTree(2, null, new BinTree(3, null, null)), new BinTree(4, null, null));
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Traversing_up_from_top()
+    {
+        var tree = new BinTree(1, new BinTree(2, null, new BinTree(3, null, null)), new BinTree(4, null, null));
+        var sut = Zipper.FromTree(tree);
+        var actual = sut.Up();
+        Assert.Null(actual);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Left_right_and_up()
+    {
+        var tree = new BinTree(1, new BinTree(2, null, new BinTree(3, null, null)), new BinTree(4, null, null));
+        var sut = Zipper.FromTree(tree);
+        var actual = sut.Left().Up().Right().Up().Left().Right().Value();
+        var expected = 3;
+        Assert.Equal(expected, actual);
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Set_value()
     {
-        var zipper = Zipper<int>.FromTree(t1);
-        var updatedZipper = zipper.Left().SetValue(5);
-        var tree = updatedZipper.ToTree();
-        Assert.Equal(t2, tree);
+        var tree = new BinTree(1, new BinTree(2, null, new BinTree(3, null, null)), new BinTree(4, null, null));
+        var sut = Zipper.FromTree(tree);
+        var actual = sut.Left().SetValue(5).ToTree();
+        var expected = new BinTree(1, new BinTree(5, null, new BinTree(3, null, null)), new BinTree(4, null, null));
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Set_value_after_traversing_up()
+    {
+        var tree = new BinTree(1, new BinTree(2, null, new BinTree(3, null, null)), new BinTree(4, null, null));
+        var sut = Zipper.FromTree(tree);
+        var actual = sut.Left().Right().Up().SetValue(5).ToTree();
+        var expected = new BinTree(1, new BinTree(5, null, new BinTree(3, null, null)), new BinTree(4, null, null));
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Set_left_with_leaf()
+    {
+        var tree = new BinTree(1, new BinTree(2, null, new BinTree(3, null, null)), new BinTree(4, null, null));
+        var sut = Zipper.FromTree(tree);
+        var actual = sut.Left().SetLeft(new BinTree(5, null, null)).ToTree();
+        var expected = new BinTree(1, new BinTree(2, new BinTree(5, null, null), new BinTree(3, null, null)), new BinTree(4, null, null));
+        Assert.Equal(expected, actual);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Set_right_with_null()
+    {
+        var tree = new BinTree(1, new BinTree(2, null, new BinTree(3, null, null)), new BinTree(4, null, null));
+        var sut = Zipper.FromTree(tree);
+        var actual = sut.Left().SetRight(null).ToTree();
+        var expected = new BinTree(1, new BinTree(2, null, null), new BinTree(4, null, null));
+        Assert.Equal(expected, actual);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Set_left_with_value()
+    public void Set_right_with_subtree()
     {
-        var zipper = Zipper<int>.FromTree(t1);
-        var updatedZipper = zipper.Left().SetLeft(new BinTree<int>(5, null, null));
-        var tree = updatedZipper.ToTree();
-        Assert.Equal(t3, tree);
+        var tree = new BinTree(1, new BinTree(2, null, new BinTree(3, null, null)), new BinTree(4, null, null));
+        var sut = Zipper.FromTree(tree);
+        var actual = sut.SetRight(new BinTree(6, new BinTree(7, null, null), new BinTree(8, null, null))).ToTree();
+        var expected = new BinTree(1, new BinTree(2, null, new BinTree(3, null, null)), new BinTree(6, new BinTree(7, null, null), new BinTree(8, null, null)));
+        Assert.Equal(expected, actual);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Set_right_to_null()
+    public void Set_value_on_deep_focus()
     {
-        var zipper = Zipper<int>.FromTree(t1);
-        var updatedZipper = zipper.Left().SetRight(null);
-        var tree = updatedZipper.ToTree();
-        Assert.Equal(t4, tree);
+        var tree = new BinTree(1, new BinTree(2, null, new BinTree(3, null, null)), new BinTree(4, null, null));
+        var sut = Zipper.FromTree(tree);
+        var actual = sut.Left().Right().SetValue(5).ToTree();
+        var expected = new BinTree(1, new BinTree(2, null, new BinTree(5, null, null)), new BinTree(4, null, null));
+        Assert.Equal(expected, actual);
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Different_paths_to_same_zipper()
     {
-        var zipper = Zipper<int>.FromTree(t1);
-        Assert.Equal(zipper.Right().ToTree(), zipper.Left().Up().Right().ToTree());
+        var tree = new BinTree(1, new BinTree(2, null, new BinTree(3, null, null)), new BinTree(4, null, null));
+        var sut = Zipper.FromTree(tree);
+        var actual = sut.Left().Up().Right();
+        var expected = Zipper.FromTree(new BinTree(1, new BinTree(2, null, new BinTree(3, null, null)), new BinTree(4, null, null))).Right();
+        Assert.Equal(expected, actual);
     }
-}
+}

data/tracks/csharp/generators/Exercises/ListOps.cs

@@ -0,0 +1,123 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using Generators.Input;
+using Generators.Output;
+using Newtonsoft.Json.Linq;
+
+namespace Generators.Exercises
+{
+    public class ListOps : GeneratorExercise
+    {
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+            foreach (var canonicalDataCase in canonicalData.Cases)
+            {
+                canonicalDataCase.UseFullDescriptionPath = true;
+                canonicalDataCase.UseVariablesForInput = true;
+                canonicalDataCase.UseVariableForExpected = !(canonicalDataCase.Expected is int);
+
+                if (canonicalDataCase.Input.TryGetValue("list", out var list))
+                    canonicalDataCase.Input["list"] = ConvertToList(list);
+
+                if (canonicalDataCase.Input.TryGetValue("list1", out var list1))
+                    canonicalDataCase.Input["list1"] = ConvertToList(list1);
+
+                if (canonicalDataCase.Input.TryGetValue("list2", out var list2))
+                    canonicalDataCase.Input["list2"] = ConvertToList(list2);
+
+                if (canonicalDataCase.Input.TryGetValue("lists", out var lists))
+                    canonicalDataCase.Input["lists"] = ConvertToNestedList(lists, true);
+
+                if (canonicalDataCase.Input.TryGetValue("function", out var function))
+                    canonicalDataCase.Input["function"] = ConvertToFunction(canonicalDataCase.Property, function);
+
+                if (canonicalDataCase.Expected is IEnumerable)
+                {
+                    if (canonicalDataCase.Input.ContainsKey("lists"))
+                        canonicalDataCase.Expected = ConvertToNestedList(canonicalDataCase.Expected, false);
+                    else
+                        canonicalDataCase.Expected = ConvertToList(canonicalDataCase.Expected);
+                }
+            }
+        }
+
+        private static UnescapedValue ConvertToFunction(string property, dynamic function)
+        {
+            var signature =
+                property == "filter" ? "<int, bool>" :
+                property == "map" ? "<int, int>" :
+                "<int, int, int>";
+
+            var body = function
+                .Replace("modulo", "%")
+                .Replace("->", "=>");
+
+            return new UnescapedValue($"new Func{signature}({body})");
+        }
+
+        private static dynamic ConvertToList(dynamic value)
+        {
+            if (value is JArray jArray)
+            {
+                if (jArray.Count == 0)
+                    return new List<int>();
+
+                if (jArray.Any(jToken => jToken.Type == JTokenType.Array))
+                    return jArray.Select(ConvertToList).ToList();
+
+                return jArray.ToObject<int[]>().ToList();
+            }
+
+            if (value is IEnumerable<int> ints)
+            {
+                return ints.ToList();
+            }
+
+            return value;
+        }
+
+        private static dynamic ConvertToNestedList(dynamic value, bool unescapeEmpty)
+        {
+            if (value is JArray jArray)
+            {
+                if (jArray.Count == 0)
+                {
+                    if (unescapeEmpty)
+                    {
+                        return new UnescapedValue("new List<List<int>>()");
+                    }
+
+                    return new List<int>();
+                }
+
+                var nestedList = jArray
+                    .Children<JArray>()
+                    .Select(ConvertToList)
+                    .Select(ValueFormatter.Format)
+                    .Select(formattedValue => new UnescapedValue(formattedValue))
+                    .ToList();
+
+                return new UnescapedValue(ValueFormatter.Format(nestedList)
+                    .Replace("<object>", "<int>")
+                    .Replace("new List<int> { new List<int>", "new List<List<int>> { new List<int>")
+                    .Replace("new[] { new List<List<int>>", "new List<List<List<int>>> { new List<List<int>>")
+                    .Replace("new[] { new List<int>", "new List<List<int>> { new List<int>"));
+            }
+
+            if (value is IEnumerable<int> ints)
+            {
+                return new UnescapedValue(ValueFormatter.Format(ints.ToList()));
+            }
+
+            return value;
+        }
+
+        protected override HashSet<string> AddAdditionalNamespaces() => new HashSet<string>
+        {
+            typeof(Func<int,int>).Namespace,
+            typeof(List<int>).Namespace
+        };
+    }
+}