trackler 2.2.1.151 → 2.2.1.152

data/tracks/csharp/exercises/triangle/TriangleTest.cs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.0.0 of the canonical data.
+// This file was auto-generated based on version 1.1.0 of the canonical data.
 
 using Xunit;
 

data/tracks/csharp/exercises/twelve-days/TwelveDays.cs

@@ -7,7 +7,7 @@ public static string Recite(int verseNumber)
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    public static string Recite(int start, int end)
+    public static string Recite(int startVerse, int endVerse)
     {
         throw new NotImplementedException("You need to implement this function.");
     }

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

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.2.0 of the canonical data.
+// This file was auto-generated based on version 1.4.0 of the canonical data.
 
 using Xunit;
 

data/tracks/csharp/exercises/two-fer/TwoFerTest.cs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.1.0 of the canonical data.
+// This file was auto-generated based on version 1.2.0 of the canonical data.
 
 using Xunit;
 

data/tracks/csharp/exercises/variable-length-quantity/Example.cs

@@ -7,9 +7,9 @@ public static class VariableLengthQuantity
     private const uint SevenBitsMask = 0x7fu;
     private const uint EightBitMask = 0x80u;
 
-    public static uint[] ToBytes(uint[] numbers) => numbers.SelectMany(ToBytesSingle).ToArray();
+    public static uint[] Encode(uint[] numbers) => numbers.SelectMany(EncodeSingle).ToArray();
 
-    private static IEnumerable<uint> ToBytesSingle(uint number)
+    private static IEnumerable<uint> EncodeSingle(uint number)
     {
         if (number == 0)
         {
@@ -35,7 +35,7 @@ private static IEnumerable<uint> ToBytesSingle(uint number)
         return bytes;
     }
 
-    public static uint[] FromBytes(uint[] bytes)
+    public static uint[] Decode(uint[] bytes)
     {
         var numbers = new List<uint>();
         var tmp = 0u;

data/tracks/csharp/exercises/variable-length-quantity/VariableLengthQuantity.cs

@@ -2,12 +2,12 @@
 
 public static class VariableLengthQuantity
 {
-    public static uint[] ToBytes(uint[] numbers)
+    public static uint[] Encode(uint[] numbers)
     {
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    public static uint[] FromBytes(uint[] bytes)
+    public static uint[] Decode(uint[] bytes)
     {
         throw new NotImplementedException("You need to implement this function.");
     }

data/tracks/csharp/exercises/variable-length-quantity/VariableLengthQuantityTest.cs

@@ -1,88 +1,213 @@
-using System;
+// This file was auto-generated based on version 1.1.0 of the canonical data.
+
 using Xunit;
+using System;
 
 public class VariableLengthQuantityTest
 {
     [Fact]
-    public void To_single_byte()
+    public void Zero()
+    {
+        var integers = new[] { 0x0u };
+        var expected = new[] { 0x0u };
+        Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Arbitrary_single_byte()
+    {
+        var integers = new[] { 0x40u };
+        var expected = new[] { 0x40u };
+        Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Largest_single_byte()
+    {
+        var integers = new[] { 0x7Fu };
+        var expected = new[] { 0x7Fu };
+        Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Smallest_double_byte()
+    {
+        var integers = new[] { 0x80u };
+        var expected = new[] { 0x81u, 0x0u };
+        Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Arbitrary_double_byte()
+    {
+        var integers = new[] { 0x2000u };
+        var expected = new[] { 0xC0u, 0x0u };
+        Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Largest_double_byte()
+    {
+        var integers = new[] { 0x3FFFu };
+        var expected = new[] { 0xFFu, 0x7Fu };
+        Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Smallest_triple_byte()
+    {
+        var integers = new[] { 0x4000u };
+        var expected = new[] { 0x81u, 0x80u, 0x0u };
+        Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Arbitrary_triple_byte()
+    {
+        var integers = new[] { 0x100000u };
+        var expected = new[] { 0xC0u, 0x80u, 0x0u };
+        Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Largest_triple_byte()
+    {
+        var integers = new[] { 0x1FFFFFu };
+        var expected = new[] { 0xFFu, 0xFFu, 0x7Fu };
+        Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Smallest_quadruple_byte()
+    {
+        var integers = new[] { 0x200000u };
+        var expected = new[] { 0x81u, 0x80u, 0x80u, 0x0u };
+        Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Arbitrary_quadruple_byte()
+    {
+        var integers = new[] { 0x8000000u };
+        var expected = new[] { 0xC0u, 0x80u, 0x80u, 0x0u };
+        Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Largest_quadruple_byte()
+    {
+        var integers = new[] { 0xFFFFFFFu };
+        var expected = new[] { 0xFFu, 0xFFu, 0xFFu, 0x7Fu };
+        Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Smallest_quintuple_byte()
+    {
+        var integers = new[] { 0x10000000u };
+        var expected = new[] { 0x81u, 0x80u, 0x80u, 0x80u, 0x0u };
+        Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Arbitrary_quintuple_byte()
+    {
+        var integers = new[] { 0xFF000000u };
+        var expected = new[] { 0x8Fu, 0xF8u, 0x80u, 0x80u, 0x0u };
+        Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Maximum_32_bit_integer_input()
+    {
+        var integers = new[] { 0xFFFFFFFFu };
+        var expected = new[] { 0x8Fu, 0xFFu, 0xFFu, 0xFFu, 0x7Fu };
+        Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Two_single_byte_values()
     {
-        Assert.Equal(new[] { 0x00u }, VariableLengthQuantity.ToBytes(new[] { 0x00u }));
-        Assert.Equal(new[] { 0x40u }, VariableLengthQuantity.ToBytes(new[] { 0x40u }));
-        Assert.Equal(new[] { 0x7fu }, VariableLengthQuantity.ToBytes(new[] { 0x7fu }));
+        var integers = new[] { 0x40u, 0x7Fu };
+        var expected = new[] { 0x40u, 0x7Fu };
+        Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void To_double_byte()
+    public void Two_multi_byte_values()
     {
-        Assert.Equal(new[] { 0x81u, 0x00u }, VariableLengthQuantity.ToBytes(new[] { 0x80u }));
-        Assert.Equal(new[] { 0xc0u, 0x00u }, VariableLengthQuantity.ToBytes(new[] { 0x2000u }));
-        Assert.Equal(new[] { 0xffu, 0x7fu }, VariableLengthQuantity.ToBytes(new[] { 0x3fffu }));
+        var integers = new[] { 0x4000u, 0x123456u };
+        var expected = new[] { 0x81u, 0x80u, 0x0u, 0xC8u, 0xE8u, 0x56u };
+        Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void To_triple_byte()
+    public void Many_multi_byte_values()
     {
-        Assert.Equal(new[] { 0x81u, 0x80u, 0x00u }, VariableLengthQuantity.ToBytes(new[] { 0x4000u }));
-        Assert.Equal(new[] { 0xc0u, 0x80u, 0x00u }, VariableLengthQuantity.ToBytes(new[] { 0x100000u }));
-        Assert.Equal(new[] { 0xffu, 0xffu, 0x7fu }, VariableLengthQuantity.ToBytes(new[] { 0x1fffffu }));
+        var integers = new[] { 0x2000u, 0x123456u, 0xFFFFFFFu, 0x0u, 0x3FFFu, 0x4000u };
+        var expected = new[] { 0xC0u, 0x0u, 0xC8u, 0xE8u, 0x56u, 0xFFu, 0xFFu, 0xFFu, 0x7Fu, 0x0u, 0xFFu, 0x7Fu, 0x81u, 0x80u, 0x0u };
+        Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void To_quadruple_byte()
+    public void One_byte()
     {
-        Assert.Equal(new[] { 0x81u, 0x80u, 0x80u, 0x00u }, VariableLengthQuantity.ToBytes(new[] { 0x200000u }));
-        Assert.Equal(new[] { 0xc0u, 0x80u, 0x80u, 0x00u }, VariableLengthQuantity.ToBytes(new[] { 0x08000000u }));
-        Assert.Equal(new[] { 0xffu, 0xffu, 0xffu, 0x7fu }, VariableLengthQuantity.ToBytes(new[] { 0x0fffffffu }));
+        var integers = new[] { 0x7Fu };
+        var expected = new[] { 0x7Fu };
+        Assert.Equal(expected, VariableLengthQuantity.Decode(integers));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void To_quintuple_byte()
+    public void Two_bytes()
     {
-        Assert.Equal(new[] { 0x81u, 0x80u, 0x80u, 0x80u, 0x00u }, VariableLengthQuantity.ToBytes(new[] { 0x10000000u }));
-        Assert.Equal(new[] { 0x8fu, 0xf8u, 0x80u, 0x80u, 0x00u }, VariableLengthQuantity.ToBytes(new[] { 0xff000000u }));
-        Assert.Equal(new[] { 0x8fu, 0xffu, 0xffu, 0xffu, 0x7fu }, VariableLengthQuantity.ToBytes(new[] { 0xffffffffu }));
+        var integers = new[] { 0xC0u, 0x0u };
+        var expected = new[] { 0x2000u };
+        Assert.Equal(expected, VariableLengthQuantity.Decode(integers));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void From_bytes()
+    public void Three_bytes()
     {
-        Assert.Equal(new[] { 0x7fu }, VariableLengthQuantity.FromBytes(new[] { 0x7fu }));
-        Assert.Equal(new[] { 0x2000u }, VariableLengthQuantity.FromBytes(new[] { 0xc0u, 0x00u }));
-        Assert.Equal(new[] { 0x1fffffu }, VariableLengthQuantity.FromBytes(new[] { 0xffu, 0xffu, 0x7fu }));
-        Assert.Equal(new[] { 0x200000u }, VariableLengthQuantity.FromBytes(new[] { 0x81u, 0x80u, 0x80u, 0x00u }));
-        Assert.Equal(new[] { 0xffffffffu }, VariableLengthQuantity.FromBytes(new[] { 0x8fu, 0xffu, 0xffu, 0xffu, 0x7fu }));
+        var integers = new[] { 0xFFu, 0xFFu, 0x7Fu };
+        var expected = new[] { 0x1FFFFFu };
+        Assert.Equal(expected, VariableLengthQuantity.Decode(integers));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void To_bytes_multiple_values()
+    public void Four_bytes()
     {
-        Assert.Equal(new[] { 0x40u, 0x7fu }, VariableLengthQuantity.ToBytes(new[] { 0x40u, 0x7fu }));
-        Assert.Equal(new[] { 0x81u, 0x80u, 0x00u, 0xc8u, 0xe8u, 0x56u }, VariableLengthQuantity.ToBytes(new[] { 0x4000u, 0x123456u }));
-        Assert.Equal(new[] { 0xc0u, 0x00u, 0xc8u, 0xe8u, 0x56u, 0xffu, 0xffu, 0xffu, 0x7fu, 0x00u, 0xffu, 0x7fu, 0x81u, 0x80u, 0x00u }, VariableLengthQuantity.ToBytes(new[] { 0x2000u, 0x123456u, 0x0fffffffu, 0x00u, 0x3fffu, 0x4000u }));
+        var integers = new[] { 0x81u, 0x80u, 0x80u, 0x0u };
+        var expected = new[] { 0x200000u };
+        Assert.Equal(expected, VariableLengthQuantity.Decode(integers));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void From_bytes_multiple_values()
+    public void Maximum_32_bit_integer()
     {
-        Assert.Equal(new[] { 0x2000u, 0x123456u, 0x0fffffffu, 0x00u, 0x3fffu, 0x4000u }, VariableLengthQuantity.FromBytes(new[] { 0xc0u, 0x00u, 0xc8u, 0xe8u, 0x56u, 0xffu, 0xffu, 0xffu, 0x7fu, 0x00u, 0xffu, 0x7fu, 0x81u, 0x80u, 0x00u }));
+        var integers = new[] { 0x8Fu, 0xFFu, 0xFFu, 0xFFu, 0x7Fu };
+        var expected = new[] { 0xFFFFFFFFu };
+        Assert.Equal(expected, VariableLengthQuantity.Decode(integers));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Incomplete_byte_sequence()
+    public void Incomplete_sequence_causes_error()
     {
-        Assert.Throws<InvalidOperationException>(() => VariableLengthQuantity.FromBytes(new[] { 0xffu }));
+        var integers = new[] { 0xFFu };
+        Assert.Throws<InvalidOperationException>(() => VariableLengthQuantity.Decode(integers));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Overflow()
+    public void Incomplete_sequence_causes_error_even_if_value_is_zero()
     {
-        Assert.Throws<InvalidOperationException>(() => VariableLengthQuantity.FromBytes(new[] { 0xffu, 0xffu, 0xffu, 0xffu, 0x7fu }));
+        var integers = new[] { 0x80u };
+        Assert.Throws<InvalidOperationException>(() => VariableLengthQuantity.Decode(integers));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Chained_execution_is_identity()
+    public void Multiple_values()
     {
-        var test = new[] { 0xf2u, 0xf6u, 0x96u, 0x9cu, 0x3bu, 0x39u, 0x2eu, 0x30u, 0xb3u, 0x24u };
-        Assert.Equal(test, VariableLengthQuantity.FromBytes(VariableLengthQuantity.ToBytes(test)));
+        var integers = new[] { 0xC0u, 0x0u, 0xC8u, 0xE8u, 0x56u, 0xFFu, 0xFFu, 0xFFu, 0x7Fu, 0x0u, 0xFFu, 0x7Fu, 0x81u, 0x80u, 0x0u };
+        var expected = new[] { 0x2000u, 0x123456u, 0xFFFFFFFu, 0x0u, 0x3FFFu, 0x4000u };
+        Assert.Equal(expected, VariableLengthQuantity.Decode(integers));
     }
 }

data/tracks/csharp/exercises/word-count/Example.cs

@@ -4,7 +4,7 @@
 
 public static class WordCount
 {
-    public static IDictionary<string, int> Countwords(string phrase)
+    public static IDictionary<string, int> CountWords(string phrase)
     {
         if (phrase == null) throw new ArgumentNullException("phrase");
 

data/tracks/csharp/exercises/word-count/WordCount.cs

@@ -3,7 +3,7 @@
 
 public static class WordCount
 {
-    public static IDictionary<string, int> Countwords(string phrase)
+    public static IDictionary<string, int> CountWords(string phrase)
     {
         throw new NotImplementedException("You need to implement this function.");
     }

data/tracks/csharp/exercises/word-count/WordCountTest.cs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.0.0 of the canonical data.
+// This file was auto-generated based on version 1.2.0 of the canonical data.
 
 using Xunit;
 using System.Collections.Generic;
@@ -8,7 +8,7 @@ public class WordCountTest
     [Fact]
     public void Count_one_word()
     {
-        var actual = WordCount.Countwords("word");
+        var actual = WordCount.CountWords("word");
         var expected = new Dictionary<string, int>
         {
             ["word"] = 1
@@ -19,7 +19,7 @@ public void Count_one_word()
     [Fact(Skip = "Remove to run test")]
     public void Count_one_of_each_word()
     {
-        var actual = WordCount.Countwords("one of each");
+        var actual = WordCount.CountWords("one of each");
         var expected = new Dictionary<string, int>
         {
             ["one"] = 1,
@@ -32,7 +32,7 @@ public void Count_one_of_each_word()
     [Fact(Skip = "Remove to run test")]
     public void Multiple_occurrences_of_a_word()
     {
-        var actual = WordCount.Countwords("one fish two fish red fish blue fish");
+        var actual = WordCount.CountWords("one fish two fish red fish blue fish");
         var expected = new Dictionary<string, int>
         {
             ["one"] = 1,
@@ -47,7 +47,7 @@ public void Multiple_occurrences_of_a_word()
     [Fact(Skip = "Remove to run test")]
     public void Handles_cramped_lists()
     {
-        var actual = WordCount.Countwords("one,two,three");
+        var actual = WordCount.CountWords("one,two,three");
         var expected = new Dictionary<string, int>
         {
             ["one"] = 1,
@@ -60,7 +60,7 @@ public void Handles_cramped_lists()
     [Fact(Skip = "Remove to run test")]
     public void Handles_expanded_lists()
     {
-        var actual = WordCount.Countwords("one,\ntwo,\nthree");
+        var actual = WordCount.CountWords("one,\ntwo,\nthree");
         var expected = new Dictionary<string, int>
         {
             ["one"] = 1,
@@ -73,7 +73,7 @@ public void Handles_expanded_lists()
     [Fact(Skip = "Remove to run test")]
     public void Ignore_punctuation()
     {
-        var actual = WordCount.Countwords("car: carpet as java: javascript!!&@$%^&");
+        var actual = WordCount.CountWords("car: carpet as java: javascript!!&@$%^&");
         var expected = new Dictionary<string, int>
         {
             ["car"] = 1,
@@ -88,7 +88,7 @@ public void Ignore_punctuation()
     [Fact(Skip = "Remove to run test")]
     public void Include_numbers()
     {
-        var actual = WordCount.Countwords("testing, 1, 2 testing");
+        var actual = WordCount.CountWords("testing, 1, 2 testing");
         var expected = new Dictionary<string, int>
         {
             ["testing"] = 2,
@@ -101,7 +101,7 @@ public void Include_numbers()
     [Fact(Skip = "Remove to run test")]
     public void Normalize_case()
     {
-        var actual = WordCount.Countwords("go Go GO Stop stop");
+        var actual = WordCount.CountWords("go Go GO Stop stop");
         var expected = new Dictionary<string, int>
         {
             ["go"] = 3,
@@ -113,7 +113,7 @@ public void Normalize_case()
     [Fact(Skip = "Remove to run test")]
     public void With_apostrophes()
     {
-        var actual = WordCount.Countwords("First: don't laugh. Then: don't cry.");
+        var actual = WordCount.CountWords("First: don't laugh. Then: don't cry.");
         var expected = new Dictionary<string, int>
         {
             ["first"] = 1,
@@ -128,7 +128,7 @@ public void With_apostrophes()
     [Fact(Skip = "Remove to run test")]
     public void With_quotations()
     {
-        var actual = WordCount.Countwords("Joe can't tell between 'large' and large.");
+        var actual = WordCount.CountWords("Joe can't tell between 'large' and large.");
         var expected = new Dictionary<string, int>
         {
             ["joe"] = 1,
@@ -144,7 +144,7 @@ public void With_quotations()
     [Fact(Skip = "Remove to run test")]
     public void Multiple_spaces_not_detected_as_a_word()
     {
-        var actual = WordCount.Countwords(" multiple   whitespaces");
+        var actual = WordCount.CountWords(" multiple   whitespaces");
         var expected = new Dictionary<string, int>
         {
             ["multiple"] = 1,

data/tracks/csharp/exercises/wordy/WordyTest.cs

@@ -1,4 +1,4 @@
-// This file was auto-generated based on version 1.0.0 of the canonical data.
+// This file was auto-generated based on version 1.1.0 of the canonical data.
 
 using Xunit;
 using System;

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

@@ -38,11 +38,8 @@ public static int Score(int[] dice, YachtCategory category)
 
             //Full House:  Three of one number and two of another.  Sum of all dice.
             case YachtCategory.FullHouse:
-                {
-                    var testHashSet = new HashSet<int>();
-                    dice.ToList().ForEach(x => testHashSet.Add(x));
-                    return (testHashSet.Count() == 2) ? dice.Sum() : 0;
-                }
+                var diceByValue = dice.ToLookup(x => x);
+                return diceByValue.Count == 2 && diceByValue.First().Count() == 2 || diceByValue.First().Count() == 3 ? dice.Sum() : 0;
             //Four-Of-A-Kind:  At least four dice showing the same face.   Sum of those four dice.
             case YachtCategory.FourOfAKind: 
                 var testDict = new Dictionary<int, int>();