trackler 2.2.1.45 → 2.2.1.46

data/tracks/csharp/exercises/largest-series-product/LargestSeriesProductTest.cs

@@ -1,171 +1,97 @@
-using System;
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
 using Xunit;
+using System;
 
 public class LargestSeriesProductTest
 {
     [Fact]
-    public void Can_find_the_largest_product_of_2_with_numbers_in_order()
+    public void Finds_the_largest_product_if_span_equals_length()
     {
-        const string digits = "0123456789";
-        const int span = 2;
-        const int expected = 72;
-
-        Assert.Equal(expected, LargestSeriesProduct.GetLargestProduct(digits, span));
+        Assert.Equal(18, LargestSeriesProduct.GetLargestProduct("29", 2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Can_find_the_largest_product_of_2()
+    public void Can_find_the_largest_product_of_2_with_numbers_in_order()
     {
-        const string digits = "576802143";
-        const int span = 2;
-        const int expected = 48;
-
-        Assert.Equal(expected, LargestSeriesProduct.GetLargestProduct(digits, span));
+        Assert.Equal(72, LargestSeriesProduct.GetLargestProduct("0123456789", 2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Finds_the_largest_product_if_span_equals_length()
+    public void Can_find_the_largest_product_of_2()
     {
-        const string digits = "29";
-        const int span = 2;
-        const int expected = 18;
-
-        Assert.Equal(expected, LargestSeriesProduct.GetLargestProduct(digits, span));
+        Assert.Equal(48, LargestSeriesProduct.GetLargestProduct("576802143", 2));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Can_find_the_largest_product_of_3_with_numbers_in_order()
     {
-        const string digits = "0123456789";
-        const int span = 3;
-        const int expected = 504;
-
-        Assert.Equal(expected, LargestSeriesProduct.GetLargestProduct(digits, span));
+        Assert.Equal(504, LargestSeriesProduct.GetLargestProduct("0123456789", 3));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Can_find_the_largest_product_of_3()
     {
-        const string digits = "1027839564";
-        const int span = 3;
-        const int expected = 270;
-
-        Assert.Equal(expected, LargestSeriesProduct.GetLargestProduct(digits, span));
+        Assert.Equal(270, LargestSeriesProduct.GetLargestProduct("1027839564", 3));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Can_find_the_largest_product_of_5_with_numbers_in_order()
     {
-        const string digits = "0123456789";
-        const int span = 5;
-        const int expected = 15120;
-
-        Assert.Equal(expected, LargestSeriesProduct.GetLargestProduct(digits, span));
+        Assert.Equal(15120, LargestSeriesProduct.GetLargestProduct("0123456789", 5));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Can_get_the_largest_product_of_a_big_number()
     {
-        const string digits = "73167176531330624919225119674426574742355349194934";
-        const int span = 6;
-        const int expected = 23520;
-
-        Assert.Equal(expected, LargestSeriesProduct.GetLargestProduct(digits, span));
-    }
-
-    [Fact(Skip = "Remove to run test")]
-    public void Can_get_the_largest_product_of_a_big_number_II()
-    {
-        const string digits = "52677741234314237566414902593461595376319419139427";
-        const int span = 6;
-        const int expected = 28350;
-
-        Assert.Equal(expected, LargestSeriesProduct.GetLargestProduct(digits, span));
-    }
-
-    [Fact(Skip = "Remove to run test")]
-    public void Can_get_the_largest_product_of_a_big_number_III()
-    {
-        const string digits = "7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450";
-        const int span = 13;
-        const long expected = 23514624000;
-
-        Assert.Equal(expected, LargestSeriesProduct.GetLargestProduct(digits, span));
+        Assert.Equal(23520, LargestSeriesProduct.GetLargestProduct("73167176531330624919225119674426574742355349194934", 6));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Reports_zero_if_the_only_digits_are_zero()
     {
-        const string digits = "0000";
-        const int span = 2;
-        const int expected = 0;
-
-        Assert.Equal(expected, LargestSeriesProduct.GetLargestProduct(digits, span));
+        Assert.Equal(0, LargestSeriesProduct.GetLargestProduct("0000", 2));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Reports_zero_if_all_spans_include_zero()
     {
-        const string digits = "99099";
-        const int span = 3;
-        const int expected = 0;
-
-        Assert.Equal(expected, LargestSeriesProduct.GetLargestProduct(digits, span));
+        Assert.Equal(0, LargestSeriesProduct.GetLargestProduct("99099", 3));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Reports_1_for_empty_string_and_empty_product_0_span()
+    public void Rejects_span_longer_than_string_length()
     {
-        const string digits = "";
-        const int span = 0;
-        const int expected = 1;
-
-        Assert.Equal(expected, LargestSeriesProduct.GetLargestProduct(digits, span));
+        Assert.Throws<ArgumentException>(() => LargestSeriesProduct.GetLargestProduct("123", 4));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Reports_1_for_nonempty_string_and_empty_product_0_span()
+    public void Reports_1_for_empty_string_and_empty_product_0_span_()
     {
-        const string digits = "123";
-        const int span = 0;
-        const int expected = 1;
-
-        Assert.Equal(expected, LargestSeriesProduct.GetLargestProduct(digits, span));
+        Assert.Equal(1, LargestSeriesProduct.GetLargestProduct("", 0));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Rejects_span_longer_than_string_length()
+    public void Reports_1_for_nonempty_string_and_empty_product_0_span_()
     {
-        const string digits = "123";
-        const int span = 4;
-
-        Assert.Throws<ArgumentException>(() => LargestSeriesProduct.GetLargestProduct(digits, span));
+        Assert.Equal(1, LargestSeriesProduct.GetLargestProduct("123", 0));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Rejects_empty_string_and_nonzero_span()
     {
-        const string digits = "";
-        const int span = 1;
-
-        Assert.Throws<ArgumentException>(() => LargestSeriesProduct.GetLargestProduct(digits, span));
+        Assert.Throws<ArgumentException>(() => LargestSeriesProduct.GetLargestProduct("", 1));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Rejects_invalid_character_in_digits()
     {
-        const string digits = "1234a5";
-        const int span = 2;
-
-        Assert.Throws<ArgumentException>(() => LargestSeriesProduct.GetLargestProduct(digits, span));
+        Assert.Throws<ArgumentException>(() => LargestSeriesProduct.GetLargestProduct("1234a5", 2));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Rejects_negative_span()
     {
-        const string digits = "12345";
-        const int span = -1;
-
-        Assert.Throws<ArgumentException>(() => LargestSeriesProduct.GetLargestProduct(digits, span));
+        Assert.Throws<ArgumentException>(() => LargestSeriesProduct.GetLargestProduct("12345", -1));
     }
 }

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

@@ -3,11 +3,11 @@
 
 public class Minesweeper
 {
-    public static string Annotate(string input)
+    public static string[] Annotate(string[] input)
     {
         var results = new List<string>();
 
-        var board = input.Split("\n".ToCharArray());
+        var board = input;
 
         for (int i = 0; i < board.Length; i++)
         {
@@ -31,7 +31,7 @@ public static string Annotate(string input)
             results.Add(result);
         }
 
-        return string.Join("\n", results);
+        return results.ToArray();
     }
 
     private static int GetCountForSquare(string[] board, int x, int y)

data/tracks/csharp/exercises/minesweeper/Minesweeper.cs

@@ -2,7 +2,7 @@
 
 public static class Minesweeper
 {
-    public static string Annotate(string input)
+    public static string[] Annotate(string[] input)
     {
         throw new NotImplementedException("You need to implement this function.");
     }

data/tracks/csharp/exercises/minesweeper/MinesweeperTest.cs

@@ -1,142 +1,240 @@
-using Xunit;
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
+using Xunit;
 
 public class MinesweeperTest
 {
     [Fact]
-    public void Zero_sized_board()
+    public void No_rows()
     {
-        var input = "";
-        var expected = "";
+        var input = new string[] 
+        { 
+             
+        };
+        var expected = new string[] 
+        { 
+             
+        };
+        Assert.Equal(expected, Minesweeper.Annotate(input));
+    }
 
+    [Fact(Skip = "Remove to run test")]
+    public void No_columns()
+    {
+        var input = new string[] 
+        { 
+            "" 
+        };
+        var expected = new string[] 
+        { 
+            "" 
+        };
         Assert.Equal(expected, Minesweeper.Annotate(input));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Empty_board()
+    public void No_mines()
     {
-        var input = FormatInput(new[]
-        {
+        var input = new string[] 
+        { 
             "   ",
             "   ",
             "   "
-        });
-
-        var expected = FormatInput(new[]
-        {
+             
+        };
+        var expected = new string[] 
+        { 
             "   ",
             "   ",
             "   "
-        });
-
+             
+        };
         Assert.Equal(expected, Minesweeper.Annotate(input));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Board_full_of_mines()
+    public void Board_with_only_mines()
     {
-        var input = FormatInput(new[]
-        {
+        var input = new string[] 
+        { 
             "***",
             "***",
             "***"
-        });
-
-        var expected = FormatInput(new[]
-        {
+             
+        };
+        var expected = new string[] 
+        { 
             "***",
             "***",
             "***"
-        });
+             
+        };
+        Assert.Equal(expected, Minesweeper.Annotate(input));
+    }
 
+    [Fact(Skip = "Remove to run test")]
+    public void Mine_surrounded_by_spaces()
+    {
+        var input = new string[] 
+        { 
+            "   ",
+            " * ",
+            "   "
+             
+        };
+        var expected = new string[] 
+        { 
+            "111",
+            "1*1",
+            "111"
+             
+        };
         Assert.Equal(expected, Minesweeper.Annotate(input));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Surrounded()
+    public void Space_surrounded_by_mines()
     {
-        var input = FormatInput(new[]
-        {
+        var input = new string[] 
+        { 
             "***",
             "* *",
             "***"
-        });
-
-        var expected = FormatInput(new[]
-        {
+             
+        };
+        var expected = new string[] 
+        { 
             "***",
             "*8*",
             "***"
-        });
-
+             
+        };
         Assert.Equal(expected, Minesweeper.Annotate(input));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Horizontal_line()
     {
-        var input = FormatInput(new[]
-        {
-            " * * "
-        });
-
-        var expected = FormatInput(new[]
-        {
-            "1*2*1"
-        });
+        var input = new string[] 
+        { 
+            " * * " 
+        };
+        var expected = new string[] 
+        { 
+            "1*2*1" 
+        };
+        Assert.Equal(expected, Minesweeper.Annotate(input));
+    }
 
+    [Fact(Skip = "Remove to run test")]
+    public void Horizontal_line_mines_at_edges()
+    {
+        var input = new string[] 
+        { 
+            "*   *" 
+        };
+        var expected = new string[] 
+        { 
+            "*1 1*" 
+        };
         Assert.Equal(expected, Minesweeper.Annotate(input));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Vertical_line()
     {
-        var input = FormatInput(new[]
-        {
+        var input = new string[] 
+        { 
             " ",
             "*",
             " ",
             "*",
             " "
-        });
-
-        var expected = FormatInput(new[]
-        {
+             
+        };
+        var expected = new string[] 
+        { 
             "1",
             "*",
             "2",
             "*",
             "1"
-        });
+             
+        };
+        Assert.Equal(expected, Minesweeper.Annotate(input));
+    }
 
+    [Fact(Skip = "Remove to run test")]
+    public void Vertical_line_mines_at_edges()
+    {
+        var input = new string[] 
+        { 
+            "*",
+            " ",
+            " ",
+            " ",
+            "*"
+             
+        };
+        var expected = new string[] 
+        { 
+            "*",
+            "1",
+            " ",
+            "1",
+            "*"
+             
+        };
         Assert.Equal(expected, Minesweeper.Annotate(input));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Cross()
     {
-        var input = FormatInput(new[]
-        {
+        var input = new string[] 
+        { 
             "  *  ",
             "  *  ",
             "*****",
             "  *  ",
             "  *  "
-        });
-
-        var expected = FormatInput(new[]
-        {
+             
+        };
+        var expected = new string[] 
+        { 
             " 2*2 ",
             "25*52",
             "*****",
             "25*52",
             " 2*2 "
-        });
-
+             
+        };
         Assert.Equal(expected, Minesweeper.Annotate(input));
     }
-    
-    private string FormatInput(string[] input)
+
+    [Fact(Skip = "Remove to run test")]
+    public void Large_board()
     {
-        return string.Join("\n", input);
+        var input = new string[] 
+        { 
+            " *  * ",
+            "  *   ",
+            "    * ",
+            "   * *",
+            " *  * ",
+            "      "
+             
+        };
+        var expected = new string[] 
+        { 
+            "1*22*1",
+            "12*322",
+            " 123*2",
+            "112*4*",
+            "1*22*2",
+            "111111"
+             
+        };
+        Assert.Equal(expected, Minesweeper.Annotate(input));
     }
 }