trackler 2.0.5.5 → 2.0.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8d5432bf225e49f96fd078ad1c2e11e82d291780
-  data.tar.gz: 9ebb6ec88ed0bb64313051385c09b16e3a313f21
+  metadata.gz: 838fe7957432a1754b9feb3301d62ea08e130958
+  data.tar.gz: 3e4a657d880d96c9d725777036fb135e8cc41024
 SHA512:
-  metadata.gz: faf9bf3ac196a3c1f3cd6ee3ba48e31e182eb6176fea567ef641b4e2b941a671f77d6df6433a3393735c450a41a17236ba3d83ff20701db3aaa140963d32b967
-  data.tar.gz: ced5a0f1c865bb6322d2c2efd31720a545f9551630732ee6e5bf2bfc1a7a2660a860eab9ad2804600b7e7795c1eaabc2ad2de55fe3c7e07a618797249e9d5dc4
+  metadata.gz: 3ee120f448ed1307b7ed74945776f1e4e9d771bbbc435e6de07f08e253b30595ba534bbac2e483bb80e9539aba1d0d7085c22c125c0313e6f6e9539e9864d7ca
+  data.tar.gz: 459c7b9d7a799eafe0dab3f210000160346fb953ea6bff098148581788d1c3ceac4842710086b8b1700840b46c2d9437e132e267ffa064d15401ca7a9e7ec129

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.5.5"
+  VERSION = "2.0.5.6"
 end

data/tracks/csharp/config.json

@@ -403,6 +403,14 @@
         "Mathematics"
       ]
     },
+    {
+      "slug": "list-ops",
+      "difficulty": 5,
+      "topics": [
+        "Lists",
+        "Recursion"
+      ]
+    },
     {
       "slug": "simple-cipher",
       "difficulty": 5,
@@ -691,6 +699,13 @@
         "Algorithms"
       ]
     },
+    {
+      "slug": "two-bucket",
+      "difficulty": 8,
+      "topics": [
+        "Logic"
+      ]
+    },
     {
       "slug": "say",
       "difficulty": 8,

data/tracks/csharp/exercises/list-ops/Example.cs

@@ -0,0 +1,77 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+public static class ListOps
+{
+    private static List<T> Cons<T>(T x, List<T> input)
+    {
+        var list = new List<T>(input);
+        list.Insert(0, x);
+
+        return list;
+    }
+
+    public static int Length<T>(List<T> input)
+    {
+        return Foldl((acc, x) => acc + 1, 0, input);
+    }
+
+    public static List<T> Reverse<T>(List<T> input)
+    {
+        return Foldl((acc, x) => Cons(x, acc), new List<T>(), input);
+    }
+
+    public static List<TOut> Map<TIn, TOut>(Func<TIn, TOut> map, List<TIn> input)
+    {
+        return Foldr((x, acc) => Cons(map(x), acc), new List<TOut>(), input);
+    }
+
+    public static List<T> Filter<T>(Func<T, bool> predicate, List<T> input)
+    {
+        return Foldr((x, acc) => predicate(x) ? Cons(x, acc) : acc, new List<T>(), input);
+    }
+
+    public static TOut Foldl<TIn, TOut>(Func<TOut, TIn, TOut> func, TOut start, List<TIn> input)
+    {
+        var acc = start;
+
+        foreach (var item in input)
+            acc = func(acc, item);
+
+        return acc;
+    }
+
+    public static TOut Foldr<TIn, TOut>(Func<TIn, TOut, TOut> func, TOut start, List<TIn> input)
+    {
+        var acc = start;
+
+        for (var i = input.Count - 1; i >= 0; i--)
+            acc = func(input[i], acc);
+
+        return acc;
+    }
+
+    public static List<T> Concat<T>(List<List<T>> input)
+    {
+        var concatenated = new List<T>();
+
+        foreach (var list in input)
+            concatenated = Append(concatenated, list);
+
+        return concatenated;
+    }
+
+    public static List<T> Append<T>(List<T> left, List<T> right)
+    {
+        var appended = new T[left.Count + right.Count];
+
+        for (var i = 0; i < left.Count; i++)
+            appended[i] = left[i];
+
+        for (var j = 0; j < right.Count; j++)
+            appended[left.Count + j] = right[j];
+
+        return appended.ToList();
+    }
+}

data/tracks/csharp/exercises/list-ops/HINTS.md

@@ -0,0 +1,2 @@
+## Hints
+The `Foldl` andf `Foldr` methods are "fold" functions, which is a concept well-known in the functional programming world, but less so in the object-oriented one. If you'd like more background information, check out this[fold](https://en.wikipedia.org/wiki/Fold_(higher-order_function)) page.

data/tracks/csharp/exercises/list-ops/ListOpsTest.cs

@@ -0,0 +1,195 @@
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+
+public class ListOpsTest
+{
+    private const int Big = 10000;
+    private static readonly List<int> BigList = Range(1, Big);
+    private static readonly List<int> EmptyList = new List<int>();
+
+    private static List<int> Range(int from, int until) => new List<int>(Enumerable.Range(from, (until - from) + 1));
+    private static bool Odd(int x) => x % 2 == 1;
+
+    private static List<T> Cons<T>(T x, List<T> input)
+    {
+        var list = new List<T>(input);
+        list.Insert(0, x);
+
+        return list;
+    }
+
+    [Test]
+    public void LengthOfEmptyList()
+    {
+        Assert.That(ListOps.Length(EmptyList), Is.EqualTo(0));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void LengthOfNonEmptyList()
+    {
+        Assert.That(ListOps.Length(Range(1, 4)), Is.EqualTo(4));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void LengthOfLargeList()
+    {
+        Assert.That(ListOps.Length(Range(1, Big)), Is.EqualTo(Big));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void ReverseOfEmptylist()
+    {
+        Assert.That(ListOps.Reverse(EmptyList), Is.EquivalentTo(EmptyList));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void ReverseOfNonEmptyList()
+    {
+        Assert.That(ListOps.Reverse(Range(1, 100)), Is.EquivalentTo(Range(1, 100).OrderByDescending(x => x).ToList()));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void MapOfEmptylist()
+    {
+        Assert.That(ListOps.Map(x => x + 1, EmptyList), Is.EquivalentTo(EmptyList));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void MapOfNonEmptyList()
+    {
+        Assert.That(ListOps.Map(x => x + 1, new List<int> {1, 3, 5, 7}), Is.EquivalentTo(new List<int> {2, 4, 6, 8}));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void FilterOfEmptylist()
+    {
+        Assert.That(ListOps.Filter(x => true, EmptyList), Is.EquivalentTo(EmptyList));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void FilterOfNormalList()
+    {
+        Assert.That(ListOps.Filter(Odd, Range(1, 4)), Is.EquivalentTo(new List<int> {1, 3}));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void FoldlOfEmptylist()
+    {
+        Assert.That(ListOps.Foldl((acc, x) => acc + x, 0, EmptyList), Is.EqualTo(0));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void FoldlOfNonEmptyList()
+    {
+        Assert.That(ListOps.Foldl((acc, x) => acc + x, -3, Range(1, 4)), Is.EqualTo(7));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void FoldlOfHugeList()
+    {
+        Assert.That(ListOps.Foldl((acc, x) => acc + x, 0L, Range(1, Big)), Is.EqualTo(Big * (Big + 1L) / 2L));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void FoldlWithNonCommutativeFunction()
+    {
+        Assert.That(ListOps.Foldl((acc, x) => acc - x, 10, Range(1, 4)), Is.EqualTo(0));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void FoldlIsNotJustFoldrFlip()
+    {
+        Assert.That(ListOps.Foldl((acc, x) => Cons(x, acc), EmptyList, "asdf".ToList()), Is.EqualTo("fdsa".ToList()));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void FoldrAsId()
+    {
+        Assert.That(ListOps.Foldr((x, acc) => Cons(x, acc), EmptyList, Range(1, Big)), Is.EquivalentTo(BigList));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void FoldrAsAppend()
+    {
+        Assert.That(ListOps.Foldr((x, acc) => Cons(x, acc), Range(100, Big), Range(1, 99)), Is.EquivalentTo(BigList));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void AppendOfEmptylists()
+    {
+        Assert.That(ListOps.Append(EmptyList, EmptyList), Is.EqualTo(EmptyList));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void AppendOfEmptyAndNonEmptyLists()
+    {
+        Assert.That(ListOps.Append(EmptyList, Range(1, 4)), Is.EqualTo(Range(1, 4)));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void AppendOfNonEmptyAndEmptyLists()
+    {
+        Assert.That(ListOps.Append(Range(1, 4), EmptyList), Is.EqualTo(Range(1, 4)));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void AppendOfNonEmptylists()
+    {
+        Assert.That(ListOps.Append(Range(1, 3), new List<int> {4, 5}), Is.EqualTo(Range(1, 5)));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void AppendOfLargeLists()
+    {
+        Assert.That(ListOps.Append(Range(1, Big / 2), Range(1 + Big / 2, Big)), Is.EquivalentTo(BigList));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void ConcatOfNoLists()
+    {
+        Assert.That(ListOps.Concat(new List<List<int>>()), Is.EqualTo(EmptyList));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void ConcatOfListOfLists()
+    {
+        Assert.That(
+            ListOps.Concat(new List<List<int>>
+            {
+                new List<int> {1, 2},
+                new List<int> {3},
+                EmptyList,
+                new List<int> {4, 5, 6}
+            }), Is.EqualTo(Range(1, 6)));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void ConcatOfLargeListOfSmallLists()
+    {
+        Assert.That(ListOps.Concat(ListOps.Map(x => new List<int> {x}, Range(1, Big))), Is.EquivalentTo(BigList));
+    }
+}

data/tracks/csharp/exercises/two-bucket/Example.cs

@@ -0,0 +1,109 @@
+using System;
+
+public enum Bucket
+{
+    One,
+    Two
+}
+
+public class TwoBucketResult
+{
+    public int Moves { get; set; }
+    public Bucket GoalBucket { get; set; }
+    public int OtherBucketContents { get; set; }
+}
+
+public class BucketContainer
+{
+    public BucketContainer(int contents, int capacity)
+    {
+        Contents = contents;
+        Capacity = capacity;
+    }
+
+    public int Contents { get; set; }
+
+    public int Capacity { get; }
+
+    public bool IsEmpty => Contents == 0;
+
+    public bool IsFull => Contents == Capacity;
+
+    public void Fill()
+    {
+        Contents = Capacity;
+    }
+
+    public void Empty()
+    {
+        Contents = 0;
+    }
+
+    public void PourTo(BucketContainer other)
+    {
+        var amount = Math.Min(other.Capacity - other.Contents, Contents);
+        Contents -= amount;
+        other.Contents += amount;
+    }
+
+    public bool CanPourTo(BucketContainer other) => !IsEmpty && !other.IsFull;
+}
+
+public class TwoBuckets
+{
+    private readonly BucketContainer bucketOne;
+    private readonly BucketContainer bucketTwo;
+    private readonly Action strategy;
+
+    public TwoBuckets(int bucketOneSize, int bucketTwoSize, Bucket startBucket)
+    {
+        bucketOne = new BucketContainer(startBucket == Bucket.One ? bucketOneSize : 0, bucketOneSize);
+        bucketTwo = new BucketContainer(startBucket == Bucket.Two ? bucketTwoSize : 0, bucketTwoSize);
+        strategy = startBucket == Bucket.One ? (Action)StartFromFirstBucket : StartFromSecondBucket;
+
+    }
+
+    public TwoBucketResult Solve(int goal)
+    {
+        var moves = 0;
+
+        while (true)
+        {
+            moves++;
+
+            if (bucketOne.Contents == goal)
+                return new TwoBucketResult { Moves = moves, GoalBucket = Bucket.One, OtherBucketContents = bucketTwo.Contents };
+
+            if (bucketTwo.Contents == goal)
+                return new TwoBucketResult { Moves = moves, GoalBucket = Bucket.Two, OtherBucketContents = bucketOne.Contents };
+
+            strategy();
+        }
+
+        throw new NotImplementedException();
+    }
+
+    public void StartFromFirstBucket()
+    {
+        if (bucketOne.IsEmpty)
+            bucketOne.Fill();
+        else if (bucketTwo.IsFull)
+            bucketTwo.Empty();
+        else if (bucketOne.CanPourTo(bucketTwo))
+            bucketOne.PourTo(bucketTwo);
+        else
+            throw new InvalidOperationException("Cannot transition from current state.");
+    }
+    
+    public void StartFromSecondBucket()
+    {
+        if (bucketOne.IsFull)
+            bucketOne.Empty();
+        else if (bucketTwo.IsEmpty)
+            bucketTwo.Fill();
+        else if (bucketTwo.CanPourTo(bucketOne))
+            bucketTwo.PourTo(bucketOne);
+        else
+            throw new InvalidOperationException("Cannot transition from current state.");
+    }
+}

data/tracks/csharp/exercises/two-bucket/TwoBucketTest.cs

@@ -0,0 +1,71 @@
+using NUnit.Framework;
+
+public class TwoBucketTest
+{
+    [Test]
+    public void First_example()
+    {
+        var bucketOneSize = 3;
+        var bucketTwoSize = 5;
+        var goal = 1;
+        var startBucket = Bucket.One;
+        var twoBuckets = new TwoBuckets(bucketOneSize, bucketTwoSize, startBucket);
+
+        var actual = twoBuckets.Solve(goal);
+
+        Assert.That(actual.Moves, Is.EqualTo(4));
+        Assert.That(actual.GoalBucket, Is.EqualTo(Bucket.One));
+        Assert.That(actual.OtherBucketContents, Is.EqualTo(5));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Second_example()
+    {
+        var bucketOneSize = 3;
+        var bucketTwoSize = 5;
+        var goal = 1;
+        var startBucket = Bucket.Two;
+        var twoBuckets = new TwoBuckets(bucketOneSize, bucketTwoSize, startBucket);
+
+        var actual = twoBuckets.Solve(goal);
+
+        Assert.That(actual.Moves, Is.EqualTo(8));
+        Assert.That(actual.GoalBucket, Is.EqualTo(Bucket.Two));
+        Assert.That(actual.OtherBucketContents, Is.EqualTo(3));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Third_example()
+    {
+        var bucketOneSize = 7;
+        var bucketTwoSize = 11;
+        var goal = 2;
+        var startBucket = Bucket.One;
+        var twoBuckets = new TwoBuckets(bucketOneSize, bucketTwoSize, startBucket);
+
+        var actual = twoBuckets.Solve(goal);
+
+        Assert.That(actual.Moves, Is.EqualTo(14));
+        Assert.That(actual.GoalBucket, Is.EqualTo(Bucket.One));
+        Assert.That(actual.OtherBucketContents, Is.EqualTo(11));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Fourth_example()
+    {
+        var bucketOneSize = 7;
+        var bucketTwoSize = 11;
+        var goal = 2;
+        var startBucket = Bucket.Two;
+        var twoBuckets = new TwoBuckets(bucketOneSize, bucketTwoSize, startBucket);
+
+        var actual = twoBuckets.Solve(goal);
+
+        Assert.That(actual.Moves, Is.EqualTo(18));
+        Assert.That(actual.GoalBucket, Is.EqualTo(Bucket.Two));
+        Assert.That(actual.OtherBucketContents, Is.EqualTo(7));
+    }
+}