trackler 2.2.1.151 → 2.2.1.152

data/tracks/csharp/exercises/change/Change.cs

@@ -2,7 +2,7 @@
 
 public static class Change
 {
-    public static int[] Calculate(int target, int[] coins)
+    public static int[] FindFewestCoins(int[] coins, int target)
     {
         throw new NotImplementedException("You need to implement this function.");
     }

data/tracks/csharp/exercises/change/ChangeTest.cs

@@ -1,75 +1,102 @@
-using System;
+// This file was auto-generated based on version 1.2.0 of the canonical data.
+
 using Xunit;
+using System;
 
 public class ChangeTest
 {
     [Fact]
     public void Single_coin_change()
     {
-        var actual = new[] { 1, 5, 10, 25, 100 };
+        var coins = new[] { 1, 5, 10, 25, 100 };
         var target = 25;
         var expected = new[] { 25 };
-        Assert.Equal(expected, Change.Calculate(target, actual));
+        Assert.Equal(expected, Change.FindFewestCoins(coins, target));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Multiple_coin_change()
     {
-        var actual = new[] { 1, 5, 10, 25, 100 };
+        var coins = new[] { 1, 5, 10, 25, 100 };
         var target = 15;
         var expected = new[] { 5, 10 };
-        Assert.Equal(expected, Change.Calculate(target, actual));
+        Assert.Equal(expected, Change.FindFewestCoins(coins, target));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Change_with_Lilliputian_Coins()
+    public void Change_with_lilliputian_coins()
     {
-        var actual = new[] { 1, 4, 15, 20, 50 };
+        var coins = new[] { 1, 4, 15, 20, 50 };
         var target = 23;
         var expected = new[] { 4, 4, 15 };
-        Assert.Equal(expected, Change.Calculate(target, actual));
+        Assert.Equal(expected, Change.FindFewestCoins(coins, target));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Change_with_Lower_Elbonia_Coins()
+    public void Change_with_lower_elbonia_coins()
     {
-        var actual = new[] { 1, 5, 10, 21, 25 };
+        var coins = new[] { 1, 5, 10, 21, 25 };
         var target = 63;
         var expected = new[] { 21, 21, 21 };
-        Assert.Equal(expected, Change.Calculate(target, actual));
+        Assert.Equal(expected, Change.FindFewestCoins(coins, target));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Large_target_values()
     {
-        var actual = new[] { 1, 2, 5, 10, 20, 50, 100 };
+        var coins = new[] { 1, 2, 5, 10, 20, 50, 100 };
         var target = 999;
         var expected = new[] { 2, 2, 5, 20, 20, 50, 100, 100, 100, 100, 100, 100, 100, 100, 100 };
-        Assert.Equal(expected, Change.Calculate(target, actual));
+        Assert.Equal(expected, Change.FindFewestCoins(coins, target));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Possible_change_without_unit_coins_available()
+    {
+        var coins = new[] { 2, 5, 10, 20, 50 };
+        var target = 21;
+        var expected = new[] { 2, 2, 2, 5, 10 };
+        Assert.Equal(expected, Change.FindFewestCoins(coins, target));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Another_possible_change_without_unit_coins_available()
+    {
+        var coins = new[] { 4, 5 };
+        var target = 27;
+        var expected = new[] { 4, 4, 4, 5, 5, 5 };
+        Assert.Equal(expected, Change.FindFewestCoins(coins, target));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void No_coins_make_0_change()
     {
-        var actual = new[] { 1, 5, 10, 21, 25 };
+        var coins = new[] { 1, 5, 10, 21, 25 };
         var target = 0;
-        var expected = new int[0];
-        Assert.Equal(expected, Change.Calculate(target, actual));
+        Assert.Empty(Change.FindFewestCoins(coins, target));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Error_testing_for_change_smaller_than_the_smallest_of_coins()
     {
-        var actual = new[] { 5, 10 };
+        var coins = new[] { 5, 10 };
         var target = 3;
-        Assert.Throws<ArgumentException>(() => Change.Calculate(target, actual));
+        Assert.Throws<ArgumentException>(() => Change.FindFewestCoins(coins, target));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Error_if_no_combination_can_add_up_to_target()
+    {
+        var coins = new[] { 5, 10 };
+        var target = 94;
+        Assert.Throws<ArgumentException>(() => Change.FindFewestCoins(coins, target));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Cannot_find_negative_change_values()
     {
-        var actual = new[] { 1, 2, 5 };
+        var coins = new[] { 1, 2, 5 };
         var target = -5;
-        Assert.Throws<ArgumentException>(() => Change.Calculate(target, actual));
+        Assert.Throws<ArgumentException>(() => Change.FindFewestCoins(coins, target));
     }
-}
+}

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

@@ -1,9 +1,10 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 
 public static class Change
 {
-    public static int[] Calculate(int target, int[] coins)
+    public static int[] FindFewestCoins(int[] coins, int target)
     {
         if (target < 0)
         {
@@ -14,26 +15,38 @@ public static int[] Calculate(int target, int[] coins)
             throw new ArgumentException("Target amount cannot be less than minimal coin value.");
         }
 
-        var minimalCoins = new int[target + 1][];
-        minimalCoins[0] = new int[0];
-
-        for (var amount = 1; amount <= target; amount++)
+        var minimalCoinsMapSeed = new Dictionary<int, List<int>>
         {
-            minimalCoins[amount] = coins.Where(c => c <= amount)
-                                       .Select(c => Prepend(c, minimalCoins[amount - c]))
-                                       .OrderBy(c => c.Length)
-                                       .FirstOrDefault() ?? new int[0];
-        }
+            [0] = new List<int>(0)
+        };
 
-        return minimalCoins[target];
-    }
+        var minimalCoinsMap = Enumerable.Range(1, target)
+            .Aggregate(minimalCoinsMapSeed, UpdateMinimalCoinsMap);
 
-    private static int[] Prepend(int coin, int[] coins)
-    {
-        var newCoins = new int[coins.Length + 1];
-        newCoins[0] = coin;
-        Array.Copy(coins, 0, newCoins, 1, coins.Length);
+        if (minimalCoinsMap.TryGetValue(target, out var minimalCoins))
+            return minimalCoins.OrderBy(x => x).ToArray();
+        
+        throw new ArgumentException();
+
+        Dictionary<int, List<int>> UpdateMinimalCoinsMap(Dictionary<int, List<int>> current, int subTarget)
+        {
+            var subTargetMinimalCoins = MinimalCoins(current, subTarget);
+            if (subTargetMinimalCoins != null)
+                current.Add(subTarget, subTargetMinimalCoins);
+
+            return current;
+        }
 
-        return newCoins;
+        List<int> MinimalCoins(Dictionary<int, List<int>> current, int subTarget)
+        {
+            return coins
+                .Where(coin => coin <= subTarget)
+                .Select(coin => current.TryGetValue(subTarget - coin, out var subTargetMinimalCoins)
+                    ? subTargetMinimalCoins.Append(coin).ToList()
+                    : null)
+                .Where(subTargetMinimalCoins => subTargetMinimalCoins != null)
+                .OrderBy(subTargetMinimalCoins => subTargetMinimalCoins.Count)
+                .FirstOrDefault();
+        }
     }
 }

data/tracks/csharp/exercises/circular-buffer/CircularBuffer.cs

@@ -2,7 +2,7 @@
 
 public class CircularBuffer<T>
 {
-    public CircularBuffer(int size)
+    public CircularBuffer(int capacity)
     {
         throw new NotImplementedException("You need to implement this function.");
     }
@@ -17,7 +17,7 @@ public void Write(T value)
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    public void ForceWrite(T value)
+    public void Overwrite(T value)
     {
         throw new NotImplementedException("You need to implement this function.");
     }

data/tracks/csharp/exercises/circular-buffer/CircularBufferTest.cs

@@ -1,158 +1,135 @@
-using System;
+// This file was auto-generated based on version 1.1.0 of the canonical data.
+
 using Xunit;
+using System;
 
 public class CircularBufferTest
 {
     [Fact]
-    public void Write_and_read_back_one_item()
+    public void Reading_empty_buffer_should_fail()
     {
-        var buffer = new CircularBuffer<char>(1);
-        buffer.Write('1');
-        var val = buffer.Read();
-
-        Assert.Equal('1', val);
+        var buffer = new CircularBuffer<int>(capacity: 1);
         Assert.Throws<InvalidOperationException>(() => buffer.Read());
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Write_and_read_back_multiple_items()
+    public void Can_read_an_item_just_written()
     {
-        var buffer = new CircularBuffer<char>(2);
-        buffer.Write('1');
-        buffer.Write('2');
-
-        var val1 = buffer.Read();
-        var val2 = buffer.Read();
-
-        Assert.Equal('1', val1);
-        Assert.Equal('2', val2);
-        Assert.Throws<InvalidOperationException>(() => buffer.Read());
+        var buffer = new CircularBuffer<int>(capacity: 1);
+        buffer.Write(1);
+        Assert.Equal(1, buffer.Read());
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Clearing_buffer()
+    public void Each_item_may_only_be_read_once()
     {
-        var buffer = new CircularBuffer<char>(3);
-        buffer.Write('1');
-        buffer.Write('2');
-        buffer.Write('3');
-
-        buffer.Clear();
-
+        var buffer = new CircularBuffer<int>(capacity: 1);
+        buffer.Write(1);
+        Assert.Equal(1, buffer.Read());
         Assert.Throws<InvalidOperationException>(() => buffer.Read());
-
-        buffer.Write('1');
-        buffer.Write('2');
-
-        var val1 = buffer.Read();
-        buffer.Write('3');
-        var val2 = buffer.Read();
-
-        Assert.Equal('1', val1);
-        Assert.Equal('2', val2);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Alternate_write_and_read()
+    public void Items_are_read_in_the_order_they_are_written()
     {
-        var buffer = new CircularBuffer<char>(2);
-        buffer.Write('1');
-        var val1 = buffer.Read();
-        buffer.Write('2');
-        var val2 = buffer.Read();
-
-        Assert.Equal('1', val1);
-        Assert.Equal('2', val2);
+        var buffer = new CircularBuffer<int>(capacity: 2);
+        buffer.Write(1);
+        buffer.Write(2);
+        Assert.Equal(1, buffer.Read());
+        Assert.Equal(2, buffer.Read());
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Reads_back_oldest_item()
+    public void Full_buffer_cant_be_written_to()
     {
-        var buffer1 = new CircularBuffer<char>(3);
-        buffer1.Write('1');
-        buffer1.Write('2');
-        var val1 = buffer1.Read();
-
-        buffer1.Write('3');
-        var val2 = buffer1.Read();
-        var val3 = buffer1.Read();
-        Assert.Equal('2', val2);
-        Assert.Equal('3', val3);
+        var buffer = new CircularBuffer<int>(capacity: 1);
+        buffer.Write(1);
+        Assert.Throws<InvalidOperationException>(() => buffer.Write(2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Writing_to_a_full_buffer_throws_an_exception()
+    public void A_read_frees_up_capacity_for_another_write()
     {
-        var buffer = new CircularBuffer<char>(2);
-        buffer.Write('1');
-        buffer.Write('2');
-
-        Assert.Throws<InvalidOperationException>(() => buffer.Write('A'));
+        var buffer = new CircularBuffer<int>(capacity: 1);
+        buffer.Write(1);
+        Assert.Equal(1, buffer.Read());
+        buffer.Write(2);
+        Assert.Equal(2, buffer.Read());
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Overwriting_oldest_item_in_a_full_buffer()
+    public void Read_position_is_maintained_even_across_multiple_writes()
     {
-        var buffer = new CircularBuffer<char>(2);
-        buffer.Write('1');
-        buffer.Write('2');
-        buffer.ForceWrite('A');
-
-        var val1 = buffer.Read();
-        var val2 = buffer.Read();
-
-        Assert.Equal('2', val1);
-        Assert.Equal('A', val2);
-        Assert.Throws<InvalidOperationException>(() => buffer.Read());
+        var buffer = new CircularBuffer<int>(capacity: 3);
+        buffer.Write(1);
+        buffer.Write(2);
+        Assert.Equal(1, buffer.Read());
+        buffer.Write(3);
+        Assert.Equal(2, buffer.Read());
+        Assert.Equal(3, buffer.Read());
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Forced_writes_to_non_full_buffer_should_behave_like_writes()
+    public void Items_cleared_out_of_buffer_cant_be_read()
     {
-        var buffer = new CircularBuffer<char>(2);
-        buffer.Write('1');
-        buffer.ForceWrite('2');
-
-        var val1 = buffer.Read();
-        var val2 = buffer.Read();
-
-        Assert.Equal('1', val1);
-        Assert.Equal('2', val2);
+        var buffer = new CircularBuffer<int>(capacity: 1);
+        buffer.Write(1);
+        buffer.Clear();
         Assert.Throws<InvalidOperationException>(() => buffer.Read());
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Alternate_read_and_write_into_buffer_overflow()
+    public void Clear_frees_up_capacity_for_another_write()
     {
-        var buffer = new CircularBuffer<char>(5);
-        buffer.Write('1');
-        buffer.Write('2');
-        buffer.Write('3');
-
-        var val1 = buffer.Read();
-        var val2 = buffer.Read();
-        buffer.Write('4');
-        var val3 = buffer.Read();
+        var buffer = new CircularBuffer<int>(capacity: 1);
+        buffer.Write(1);
+        buffer.Clear();
+        buffer.Write(2);
+        Assert.Equal(2, buffer.Read());
+    }
 
-        buffer.Write('5');
-        buffer.Write('6');
-        buffer.Write('7');
-        buffer.Write('8');
+    [Fact(Skip = "Remove to run test")]
+    public void Clear_does_nothing_on_empty_buffer()
+    {
+        var buffer = new CircularBuffer<int>(capacity: 1);
+        buffer.Clear();
+        buffer.Write(1);
+        Assert.Equal(1, buffer.Read());
+    }
 
-        buffer.ForceWrite('A');
-        buffer.ForceWrite('B');
+    [Fact(Skip = "Remove to run test")]
+    public void Overwrite_acts_like_write_on_non_full_buffer()
+    {
+        var buffer = new CircularBuffer<int>(capacity: 2);
+        buffer.Write(1);
+        buffer.Overwrite(2);
+        Assert.Equal(1, buffer.Read());
+        Assert.Equal(2, buffer.Read());
+    }
 
-        var val4 = buffer.Read();
-        var val5 = buffer.Read();
-        var val6 = buffer.Read();
-        var val7 = buffer.Read();
-        var val8 = buffer.Read();
+    [Fact(Skip = "Remove to run test")]
+    public void Overwrite_replaces_the_oldest_item_on_full_buffer()
+    {
+        var buffer = new CircularBuffer<int>(capacity: 2);
+        buffer.Write(1);
+        buffer.Write(2);
+        buffer.Overwrite(3);
+        Assert.Equal(2, buffer.Read());
+        Assert.Equal(3, buffer.Read());
+    }
 
-        Assert.Equal('6', val4);
-        Assert.Equal('7', val5);
-        Assert.Equal('8', val6);
-        Assert.Equal('A', val7);
-        Assert.Equal('B', val8);
-        Assert.Throws<InvalidOperationException>(() => buffer.Read());
+    [Fact(Skip = "Remove to run test")]
+    public void Overwrite_replaces_the_oldest_item_remaining_in_buffer_following_a_read()
+    {
+        var buffer = new CircularBuffer<int>(capacity: 3);
+        buffer.Write(1);
+        buffer.Write(2);
+        buffer.Write(3);
+        Assert.Equal(1, buffer.Read());
+        buffer.Write(4);
+        buffer.Overwrite(5);
+        Assert.Equal(3, buffer.Read());
+        Assert.Equal(4, buffer.Read());
+        Assert.Equal(5, buffer.Read());
     }
 }