trackler 2.0.6.14 → 2.0.6.15

data/tracks/csharp/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>>());
+}

data/tracks/csharp/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()));
+    }
+}

data/tracks/go/config.json

@@ -302,6 +302,15 @@
       "slug": "prime-factors",
       "topics": []
     },
+    {
+      "difficulty": 5,
+      "slug": "transpose",
+      "topics": [
+        "Control-flow (loops)",
+        "Strings",
+        "Transforming"
+      ]
+    },
     {
       "difficulty": 1,
       "slug": "nth-prime",

data/tracks/go/exercises/transpose/cases_test.go

@@ -0,0 +1,247 @@
+package transpose
+
+// Source: exercism/x-common
+// Commit: cda8f98 Create new exercises structure
+
+var testCases = []struct {
+	description string
+	input       []string
+	expected    []string
+}{
+	{
+		"empty string",
+		[]string{},
+		[]string{},
+	},
+	{
+		"two characters in a row",
+		[]string{
+			"A1",
+		},
+		[]string{
+			"A",
+			"1",
+		},
+	},
+	{
+		"two characters in a column",
+		[]string{
+			"A",
+			"1",
+		},
+		[]string{
+			"A1",
+		},
+	},
+	{
+		"simple",
+		[]string{
+			"ABC",
+			"123",
+		},
+		[]string{
+			"A1",
+			"B2",
+			"C3",
+		},
+	},
+	{
+		"single line",
+		[]string{
+			"Single line.",
+		},
+		[]string{
+			"S",
+			"i",
+			"n",
+			"g",
+			"l",
+			"e",
+			" ",
+			"l",
+			"i",
+			"n",
+			"e",
+			".",
+		},
+	},
+	{
+		"first line longer than second line",
+		[]string{
+			"The fourth line.",
+			"The fifth line.",
+		},
+		[]string{
+			"TT",
+			"hh",
+			"ee",
+			"  ",
+			"ff",
+			"oi",
+			"uf",
+			"rt",
+			"th",
+			"h ",
+			" l",
+			"li",
+			"in",
+			"ne",
+			"e.",
+			".",
+		},
+	},
+	{
+		"second line longer than first line",
+		[]string{
+			"The first line.",
+			"The second line.",
+		},
+		[]string{
+			"TT",
+			"hh",
+			"ee",
+			"  ",
+			"fs",
+			"ie",
+			"rc",
+			"so",
+			"tn",
+			" d",
+			"l ",
+			"il",
+			"ni",
+			"en",
+			".e",
+			" .",
+		},
+	},
+	{
+		"square",
+		[]string{
+			"HEART",
+			"EMBER",
+			"ABUSE",
+			"RESIN",
+			"TREND",
+		},
+		[]string{
+			"HEART",
+			"EMBER",
+			"ABUSE",
+			"RESIN",
+			"TREND",
+		},
+	},
+	{
+		"rectangle",
+		[]string{
+			"FRACTURE",
+			"OUTLINED",
+			"BLOOMING",
+			"SEPTETTE",
+		},
+		[]string{
+			"FOBS",
+			"RULE",
+			"ATOP",
+			"CLOT",
+			"TIME",
+			"UNIT",
+			"RENT",
+			"EDGE",
+		},
+	},
+	{
+		"triangle",
+		[]string{
+			"T",
+			"EE",
+			"AAA",
+			"SSSS",
+			"EEEEE",
+			"RRRRRR",
+		},
+		[]string{
+			"TEASER",
+			" EASER",
+			"  ASER",
+			"   SER",
+			"    ER",
+			"     R",
+		},
+	},
+	{
+		"many lines",
+		[]string{
+			"Chor. Two households, both alike in dignity,",
+			"In fair Verona, where we lay our scene,",
+			"From ancient grudge break to new mutiny,",
+			"Where civil blood makes civil hands unclean.",
+			"From forth the fatal loins of these two foes",
+			"A pair of star-cross'd lovers take their life;",
+			"Whose misadventur'd piteous overthrows",
+			"Doth with their death bury their parents' strife.",
+			"The fearful passage of their death-mark'd love,",
+			"And the continuance of their parents' rage,",
+			"Which, but their children's end, naught could remove,",
+			"Is now the two hours' traffic of our stage;",
+			"The which if you with patient ears attend,",
+			"What here shall miss, our toil shall strive to mend.",
+		},
+		[]string{
+			"CIFWFAWDTAWITW",
+			"hnrhr hohnhshh",
+			"o oeopotedi ea",
+			"rfmrmash  cn t",
+			".a e ie fthow ",
+			" ia fr weh,whh",
+			"Trnco miae  ie",
+			"w ciroitr btcr",
+			"oVivtfshfcuhhe",
+			" eeih a uote  ",
+			"hrnl sdtln  is",
+			"oot ttvh tttfh",
+			"un bhaeepihw a",
+			"saglernianeoyl",
+			"e,ro -trsui ol",
+			"h uofcu sarhu ",
+			"owddarrdan o m",
+			"lhg to'egccuwi",
+			"deemasdaeehris",
+			"sr als t  ists",
+			",ebk 'phool'h,",
+			"  reldi ffd   ",
+			"bweso tb  rtpo",
+			"oea ileutterau",
+			"t kcnoorhhnatr",
+			"hl isvuyee'fi ",
+			" atv es iisfet",
+			"ayoior trr ino",
+			"l  lfsoh  ecti",
+			"ion   vedpn  l",
+			"kuehtteieadoe ",
+			"erwaharrar,fas",
+			"   nekt te  rh",
+			"ismdsehphnnosa",
+			"ncuse ra-tau l",
+			" et  tormsural",
+			"dniuthwea'g t ",
+			"iennwesnr hsts",
+			"g,ycoi tkrttet",
+			"n ,l r s'a anr",
+			"i  ef  'dgcgdi",
+			"t  aol   eoe,v",
+			"y  nei sl,u; e",
+			",  .sf to l   ",
+			"     e rv d  t",
+			"     ; ie    o",
+			"       f, r   ",
+			"       e  e  m",
+			"       .  m  e",
+			"          o  n",
+			"          v  d",
+			"          e  .",
+			"          ,",
+		},
+	},
+}