trackler 2.2.1.40 → 2.2.1.41

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

@@ -1,11 +1,11 @@
 using System;
 using System.Collections.Generic;
 
-public class DNA
+public class NucleotideCount
 {
     public IDictionary<char, int> NucleotideCounts { get; private set; }
 
-    public DNA(string sequence)
+    public NucleotideCount(string sequence)
     {
         InitializeNucleotideCounts(sequence);
     }
@@ -13,16 +13,15 @@ public class DNA
     private void InitializeNucleotideCounts(string sequence)
     {
         NucleotideCounts = new Dictionary<char, int> { { 'A', 0 }, { 'T', 0 }, { 'C', 0 }, { 'G', 0 } };
-        foreach (var s in sequence)
-            NucleotideCounts[s] += 1;
-    }
-
-    public int Count(char nucleotide)
-    {
-        int count;
-        if (!NucleotideCounts.TryGetValue(nucleotide, out count))
+        try
+        {
+            foreach (var s in sequence)
+                NucleotideCounts[s] += 1;
+        }
+        catch (KeyNotFoundException)
+        {
             throw new InvalidNucleotideException();
-        return count;
+        }
     }
 }
 

data/tracks/csharp/exercises/nucleotide-count/NucleotideCount.cs

@@ -1,9 +1,9 @@
 using System;
 using System.Collections.Generic;
 
-public class DNA
+public class NucleotideCount
 {
-    public DNA(string sequence)
+    public NucleotideCount(string sequence)
     {
     }
 
@@ -14,11 +14,6 @@ public class DNA
             throw new NotImplementedException("You need to implement this function.");
         }
     }
-
-    public int Count(char nucleotide)
-    {
-        throw new NotImplementedException("You need to implement this function.");
-    }
 }
 
 public class InvalidNucleotideException : Exception { }

data/tracks/csharp/exercises/nucleotide-count/NucleotideCountTest.cs

@@ -1,65 +1,55 @@
-using System.Collections.Generic;
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
 using Xunit;
+using System.Collections.Generic;
 
-public class NucleoTideCountTest
+public class NucleotideCountTest
 {
     [Fact]
-    public void Has_no_nucleotides()
-    {
-        var dna = new DNA("");
-        var expected = new Dictionary<char, int> { { 'A', 0 }, { 'T', 0 }, { 'C', 0 }, { 'G', 0 } };
-        Assert.Equal(expected, dna.NucleotideCounts);
-    }
-
-    [Fact(Skip = "Remove to run test")]
-    public void Has_no_adenosine()
-    {
-        var dna = new DNA("");
-        Assert.Equal(0, dna.Count('A'));
-    }
-
-    [Fact(Skip = "Remove to run test")]
-    public void Repetitive_cytidine_gets_counts()
-    {
-        var dna = new DNA("CCCCC");
-        Assert.Equal(5, dna.Count('C'));
-    }
-
-    [Fact(Skip = "Remove to run test")]
-    public void Repetitive_sequence_has_only_guanosine()
-    {
-        var dna = new DNA("GGGGGGGG");
-        var expected = new Dictionary<char, int> { { 'A', 0 }, { 'T', 0 }, { 'C', 0 }, { 'G', 8 } };
-        Assert.Equal(expected, dna.NucleotideCounts);
-    }
-
-    [Fact(Skip = "Remove to run test")]
-    public void Counts_only_thymidine()
+    public void Empty_strand()
     {
-        var dna = new DNA("GGGGTAACCCGG");
-        Assert.Equal(1, dna.Count('T'));
+        var sut = new NucleotideCount("");
+        var expected = new Dictionary<char, int>
+        {
+            ['A'] = 0,
+            ['C'] = 0,
+            ['G'] = 0,
+            ['T'] = 0
+        };
+        Assert.Equal(expected, sut.NucleotideCounts);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Counts_a_nucleotide_only_once()
+    public void Strand_with_repeated_nucleotide()
     {
-        var dna = new DNA("GGTTGG");
-        dna.Count('T');
-        Assert.Equal(2, dna.Count('T'));
+        var sut = new NucleotideCount("GGGGGGG");
+        var expected = new Dictionary<char, int>
+        {
+            ['A'] = 0,
+            ['C'] = 0,
+            ['G'] = 7,
+            ['T'] = 0
+        };
+        Assert.Equal(expected, sut.NucleotideCounts);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Validates_nucleotides()
+    public void Strand_with_multiple_nucleotides()
     {
-        var dna = new DNA("GGTTGG");
-        Assert.Throws<InvalidNucleotideException>(() => dna.Count('X'));
+        var sut = new NucleotideCount("AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC");
+        var expected = new Dictionary<char, int>
+        {
+            ['A'] = 20,
+            ['C'] = 12,
+            ['G'] = 17,
+            ['T'] = 21
+        };
+        Assert.Equal(expected, sut.NucleotideCounts);
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Counts_all_nucleotides()
+    public void Strand_with_invalid_nucleotides()
     {
-        var dna = new DNA("AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC");
-        var expected = new Dictionary<char, int> { { 'A', 20 }, { 'T', 21 }, { 'C', 12 }, { 'G', 17 } };
-        Assert.Equal(expected, dna.NucleotideCounts);
+        Assert.Throws<InvalidNucleotideException>(() => new NucleotideCount("AGXXACT"));
     }
-}
+}

data/tracks/csharp/exercises/pig-latin/Example.cs

@@ -14,7 +14,7 @@ public class PigLatin
             return word + "ay";
         if (WordStartsWithPrefixes(word, "thr", "sch"))
             return word.Substring(3) + word.Substring(0, 3) + "ay";
-        if (WordStartsWithPrefixes(word, "ch", "qu", "th"))
+        if (WordStartsWithPrefixes(word, "ch", "qu", "th", "rh"))
             return word.Substring(2) + word.Substring(0, 2) + "ay";
         if (WordStartsWithConsonantAndQu(word))
             return word.Substring(3) + word[0] + "quay";

data/tracks/csharp/exercises/pig-latin/PigLatinTest.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;
 
@@ -52,12 +52,6 @@ public class PigLatinTest
         Assert.Equal("oalakay", PigLatin.Translate("koala"));
     }
 
-    [Fact(Skip = "Remove to run test")]
-    public void Word_beginning_with_y()
-    {
-        Assert.Equal("ellowyay", PigLatin.Translate("yellow"));
-    }
-
     [Fact(Skip = "Remove to run test")]
     public void Word_beginning_with_x()
     {
@@ -118,6 +112,24 @@ public class PigLatinTest
         Assert.Equal("xrayay", PigLatin.Translate("xray"));
     }
 
+    [Fact(Skip = "Remove to run test")]
+    public void Y_is_treated_like_a_consonant_at_the_beginning_of_a_word()
+    {
+        Assert.Equal("ellowyay", PigLatin.Translate("yellow"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Y_is_treated_like_a_vowel_at_the_end_of_a_consonant_cluster()
+    {
+        Assert.Equal("ythmrhay", PigLatin.Translate("rhythm"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Y_as_second_letter_in_two_letter_word()
+    {
+        Assert.Equal("ymay", PigLatin.Translate("my"));
+    }
+
     [Fact(Skip = "Remove to run test")]
     public void A_whole_phrase()
     {

data/tracks/csharp/exercises/sum-of-multiples/SumOfMultiplesTest.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;
 
@@ -16,6 +16,12 @@ public class SumOfMultiplesTest
         Assert.Equal(3, SumOfMultiples.Sum(new[] { 3, 5 }, 4));
     }
 
+    [Fact(Skip = "Remove to run test")]
+    public void Multiples_of_3_up_to_7()
+    {
+        Assert.Equal(9, SumOfMultiples.Sum(new[] { 3 }, 7));
+    }
+
     [Fact(Skip = "Remove to run test")]
     public void Multiples_of_3_or_5_up_to_10()
     {

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

@@ -84,7 +84,7 @@ public class Tournament
         writer.WriteLine(
             "{0,-30:S} | {1,2:D} | {2,2:D} | {3,2:D} | {4,2:D} | {5,2:D}",
             "Team", "MP", "W", "D", "L", "P");
-        foreach (var pair in this.teams.OrderByDescending(pair => pair.Value.Score)) {
+        foreach (var pair in this.teams.OrderByDescending(pair => pair.Value.Score).ThenBy(pair => pair.Key)) {
             writer.WriteLine(
                 "{0,-30:S} | {1,2:D} | {2,2:D} | {3,2:D} | {4,2:D} | {5,2:D}",
                 pair.Key, pair.Value.Played, pair.Value.Wins,

data/tracks/csharp/exercises/tournament/TournamentTest.cs

@@ -1,87 +1,170 @@
-using System;
+// This file was auto-generated based on version 1.3.0 of the canonical data.
+
+using Xunit;
+using System;
 using System.IO;
 using System.Text;
-using Xunit;
 
 public class TournamentTest
 {
-    readonly string input1 = 
-        "Αllegoric Alaskians;Blithering Badgers;win" + Environment.NewLine +
-        "Devastating Donkeys;Courageous Californians;draw" + Environment.NewLine +
-        "Devastating Donkeys;Αllegoric Alaskians;win" + Environment.NewLine +
-        "Courageous Californians;Blithering Badgers;loss" + Environment.NewLine +
-        "Blithering Badgers;Devastating Donkeys;loss" + Environment.NewLine +
-        "Αllegoric Alaskians;Courageous Californians;win".Trim();
-    
-    private readonly string input2 = 
-        "Allegoric Alaskians;Blithering Badgers;win" + Environment.NewLine +
-        "Devastating Donkeys_Courageous Californians;draw" + Environment.NewLine +
-        "Devastating Donkeys;Allegoric Alaskians;win" + Environment.NewLine +
-        "" + Environment.NewLine +
-        "Courageous Californians;Blithering Badgers;loss" + Environment.NewLine +
-        "Bla;Bla;Bla" + Environment.NewLine +
-        "Blithering Badgers;Devastating Donkeys;loss" + Environment.NewLine +
-        "# Yackity yackity yack" + Environment.NewLine +
-        "Allegoric Alaskians;Courageous Californians;win" + Environment.NewLine +
-        "Devastating Donkeys;Courageous Californians;draw" + Environment.NewLine +
-        "Devastating Donkeys@Courageous Californians;draw"; // Trim() omitted by design
-    
-    private readonly string input3 = 
-        "Allegoric Alaskians;Blithering Badgers;win" + Environment.NewLine +
-        "Devastating Donkeys;Allegoric Alaskians;win" + Environment.NewLine +
-        "Courageous Californians;Blithering Badgers;loss" + Environment.NewLine +
-        "Allegoric Alaskians;Courageous Californians;win".Trim();
-    
-    readonly string expected1 =
-        "Team                           | MP |  W |  D |  L |  P" + Environment.NewLine +
-        "Devastating Donkeys            |  3 |  2 |  1 |  0 |  7" + Environment.NewLine +
-        "Αllegoric Alaskians            |  3 |  2 |  0 |  1 |  6" + Environment.NewLine +
-        "Blithering Badgers             |  3 |  1 |  0 |  2 |  3" + Environment.NewLine +
-        "Courageous Californians        |  3 |  0 |  1 |  2 |  1".Trim();
-    
-    private readonly string expected2 =
-        "Team                           | MP |  W |  D |  L |  P" + Environment.NewLine +
-        "Devastating Donkeys            |  3 |  2 |  1 |  0 |  7" + Environment.NewLine +
-        "Allegoric Alaskians            |  3 |  2 |  0 |  1 |  6" + Environment.NewLine +
-        "Blithering Badgers             |  3 |  1 |  0 |  2 |  3" + Environment.NewLine +
-        "Courageous Californians        |  3 |  0 |  1 |  2 |  1".Trim();
-    
-    private readonly string expected3 = 
-        "Team                           | MP |  W |  D |  L |  P" + Environment.NewLine +
-        "Allegoric Alaskians            |  3 |  2 |  0 |  1 |  6" + Environment.NewLine +
-        "Blithering Badgers             |  2 |  1 |  0 |  1 |  3" + Environment.NewLine +
-        "Devastating Donkeys            |  1 |  1 |  0 |  0 |  3" + Environment.NewLine +
-        "Courageous Californians        |  2 |  0 |  0 |  2 |  0".Trim();
+    [Fact]
+    public void Just_the_header_if_no_input()
+    {
+        var input = string.Empty;
+        var expected = "Team                           | MP |  W |  D |  L |  P".Trim();
+        Assert.Equal(expected, RunTally(input).Trim());
+    }
 
-    private string RunTally(string input)
+    [Fact(Skip = "Remove to run test")]
+    public void A_win_is_three_points_a_loss_is_zero_points()
     {
-        var encoding = new UTF8Encoding();
-        
-        using (var inStream = new MemoryStream(encoding.GetBytes(input)))
-        {
-            using (var outStream = new MemoryStream())
-            {
-                Tournament.Tally(inStream, outStream);
-                return encoding.GetString(outStream.ToArray());
-            }
-        }
+        var input = "Allegoric Alaskans;Blithering Badgers;win".Trim();
+        var expected = "Team                           | MP |  W |  D |  L |  P" + Environment.NewLine +
+                       "Allegoric Alaskans             |  1 |  1 |  0 |  0 |  3" + Environment.NewLine +
+                       "Blithering Badgers             |  1 |  0 |  0 |  1 |  0"
+                       .Trim();
+        Assert.Equal(expected, RunTally(input).Trim());
     }
 
-    [Fact]
-    public void Test_good()
+    [Fact(Skip = "Remove to run test")]
+    public void A_win_can_also_be_expressed_as_a_loss()
+    {
+        var input = "Blithering Badgers;Allegoric Alaskans;loss".Trim();
+        var expected = "Team                           | MP |  W |  D |  L |  P" + Environment.NewLine +
+                       "Allegoric Alaskans             |  1 |  1 |  0 |  0 |  3" + Environment.NewLine +
+                       "Blithering Badgers             |  1 |  0 |  0 |  1 |  0"
+                       .Trim();
+        Assert.Equal(expected, RunTally(input).Trim());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void A_different_team_can_win()
+    {
+        var input = "Blithering Badgers;Allegoric Alaskans;win".Trim();
+        var expected = "Team                           | MP |  W |  D |  L |  P" + Environment.NewLine +
+                       "Blithering Badgers             |  1 |  1 |  0 |  0 |  3" + Environment.NewLine +
+                       "Allegoric Alaskans             |  1 |  0 |  0 |  1 |  0"
+                       .Trim();
+        Assert.Equal(expected, RunTally(input).Trim());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void A_draw_is_one_point_each()
+    {
+        var input = "Allegoric Alaskans;Blithering Badgers;draw".Trim();
+        var expected = "Team                           | MP |  W |  D |  L |  P" + Environment.NewLine +
+                       "Allegoric Alaskans             |  1 |  0 |  1 |  0 |  1" + Environment.NewLine +
+                       "Blithering Badgers             |  1 |  0 |  1 |  0 |  1"
+                       .Trim();
+        Assert.Equal(expected, RunTally(input).Trim());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void There_can_be_more_than_one_match()
+    {
+        var input = "Allegoric Alaskans;Blithering Badgers;win" + Environment.NewLine +
+                       "Allegoric Alaskans;Blithering Badgers;win"
+                       .Trim();
+        var expected = "Team                           | MP |  W |  D |  L |  P" + Environment.NewLine +
+                       "Allegoric Alaskans             |  2 |  2 |  0 |  0 |  6" + Environment.NewLine +
+                       "Blithering Badgers             |  2 |  0 |  0 |  2 |  0"
+                       .Trim();
+        Assert.Equal(expected, RunTally(input).Trim());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void There_can_be_more_than_one_winner()
+    {
+        var input = "Allegoric Alaskans;Blithering Badgers;loss" + Environment.NewLine +
+                       "Allegoric Alaskans;Blithering Badgers;win"
+                       .Trim();
+        var expected = "Team                           | MP |  W |  D |  L |  P" + Environment.NewLine +
+                       "Allegoric Alaskans             |  2 |  1 |  0 |  1 |  3" + Environment.NewLine +
+                       "Blithering Badgers             |  2 |  1 |  0 |  1 |  3"
+                       .Trim();
+        Assert.Equal(expected, RunTally(input).Trim());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void There_can_be_more_than_two_teams()
+    {
+        var input = "Allegoric Alaskans;Blithering Badgers;win" + Environment.NewLine +
+                       "Blithering Badgers;Courageous Californians;win" + Environment.NewLine +
+                       "Courageous Californians;Allegoric Alaskans;loss"
+                       .Trim();
+        var expected = "Team                           | MP |  W |  D |  L |  P" + Environment.NewLine +
+                       "Allegoric Alaskans             |  2 |  2 |  0 |  0 |  6" + Environment.NewLine +
+                       "Blithering Badgers             |  2 |  1 |  0 |  1 |  3" + Environment.NewLine +
+                       "Courageous Californians        |  2 |  0 |  0 |  2 |  0"
+                       .Trim();
+        Assert.Equal(expected, RunTally(input).Trim());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Typical_input()
     {
-        Assert.Equal(expected1, RunTally(input1).Trim());
+        var input = "Allegoric Alaskans;Blithering Badgers;win" + Environment.NewLine +
+                       "Devastating Donkeys;Courageous Californians;draw" + Environment.NewLine +
+                       "Devastating Donkeys;Allegoric Alaskans;win" + Environment.NewLine +
+                       "Courageous Californians;Blithering Badgers;loss" + Environment.NewLine +
+                       "Blithering Badgers;Devastating Donkeys;loss" + Environment.NewLine +
+                       "Allegoric Alaskans;Courageous Californians;win"
+                       .Trim();
+        var expected = "Team                           | MP |  W |  D |  L |  P" + Environment.NewLine +
+                       "Devastating Donkeys            |  3 |  2 |  1 |  0 |  7" + Environment.NewLine +
+                       "Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6" + Environment.NewLine +
+                       "Blithering Badgers             |  3 |  1 |  0 |  2 |  3" + Environment.NewLine +
+                       "Courageous Californians        |  3 |  0 |  1 |  2 |  1"
+                       .Trim();
+        Assert.Equal(expected, RunTally(input).Trim());
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Test_ignore_bad_lines()
+    public void Incomplete_competition_not_all_pairs_have_played_()
     {
-        Assert.Equal(expected2, RunTally(input2).Trim());
+        var input = "Allegoric Alaskans;Blithering Badgers;loss" + Environment.NewLine +
+                       "Devastating Donkeys;Allegoric Alaskans;loss" + Environment.NewLine +
+                       "Courageous Californians;Blithering Badgers;draw" + Environment.NewLine +
+                       "Allegoric Alaskans;Courageous Californians;win"
+                       .Trim();
+        var expected = "Team                           | MP |  W |  D |  L |  P" + Environment.NewLine +
+                       "Allegoric Alaskans             |  3 |  2 |  0 |  1 |  6" + Environment.NewLine +
+                       "Blithering Badgers             |  2 |  1 |  1 |  0 |  4" + Environment.NewLine +
+                       "Courageous Californians        |  2 |  0 |  1 |  1 |  1" + Environment.NewLine +
+                       "Devastating Donkeys            |  1 |  0 |  0 |  1 |  0"
+                       .Trim();
+        Assert.Equal(expected, RunTally(input).Trim());
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Test_incomplete_competition()
+    public void Ties_broken_alphabetically()
     {
-        Assert.Equal(expected3, RunTally(input3).Trim());
+        var input = "Courageous Californians;Devastating Donkeys;win" + Environment.NewLine +
+                       "Allegoric Alaskans;Blithering Badgers;win" + Environment.NewLine +
+                       "Devastating Donkeys;Allegoric Alaskans;loss" + Environment.NewLine +
+                       "Courageous Californians;Blithering Badgers;win" + Environment.NewLine +
+                       "Blithering Badgers;Devastating Donkeys;draw" + Environment.NewLine +
+                       "Allegoric Alaskans;Courageous Californians;draw"
+                       .Trim();
+        var expected = "Team                           | MP |  W |  D |  L |  P" + Environment.NewLine +
+                       "Allegoric Alaskans             |  3 |  2 |  1 |  0 |  7" + Environment.NewLine +
+                       "Courageous Californians        |  3 |  2 |  1 |  0 |  7" + Environment.NewLine +
+                       "Blithering Badgers             |  3 |  0 |  1 |  2 |  1" + Environment.NewLine +
+                       "Devastating Donkeys            |  3 |  0 |  1 |  2 |  1"
+                       .Trim();
+        Assert.Equal(expected, RunTally(input).Trim());
+    }
+
+    private string RunTally(string input)
+    {
+        var encoding = new UTF8Encoding();
+        using (var inStream = new MemoryStream(encoding.GetBytes(input)))
+        {
+            using (var outStream = new MemoryStream())
+            {
+                Tournament.Tally(inStream, outStream);
+                return encoding.GetString(outStream.ToArray());
+            }
+        }
     }
-}
+}

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

@@ -5,18 +5,36 @@ public enum TriangleKind
 {
     Equilateral,
     Isosceles,
-    Scalene
+    Scalene,
+    Invalid
 }
 
 public static class Triangle
 {
-    public static TriangleKind Kind(decimal side1, decimal side2, decimal side3)
+    
+    public static bool IsScalene(double side1, double side2, double side3)
+    {
+        return Kind(side1, side2, side3) == TriangleKind.Scalene;
+    }
+
+    public static bool IsIsosceles(double side1, double side2, double side3) 
+    {
+        var triangle = Kind(side1, side2, side3);
+        return triangle == TriangleKind.Isosceles || triangle == TriangleKind.Equilateral;
+    }
+
+    public static bool IsEquilateral(double side1, double side2, double side3) 
+    {
+        return Kind(side1, side2, side3) == TriangleKind.Equilateral;
+    }
+
+    private static TriangleKind Kind(double side1, double side2, double side3)
     {
         if (AllSidesAreZero(side1, side2, side3) ||
             HasImpossibleSides(side1, side2, side3) ||
             ViolatesTriangleInequality(side1, side2, side3))
         {
-            throw new TriangleException();
+            return TriangleKind.Invalid;
         }
 
         int uniqueSides = UniqueSides(side1, side2, side3);
@@ -27,24 +45,24 @@ public static class Triangle
         return TriangleKind.Scalene;
     }
 
-    private static bool AllSidesAreZero(decimal side1, decimal side2, decimal side3)
+    private static bool AllSidesAreZero(double side1, double side2, double side3)
     {
         return side1 == 0 && side2 == 0 && side3 == 0;
     }
 
-    private static bool HasImpossibleSides(decimal side1, decimal side2, decimal side3)
+    private static bool HasImpossibleSides(double side1, double side2, double side3)
     {
         return side1 < 0 || side2 < 0 || side3 < 0;
     }
 
-    private static bool ViolatesTriangleInequality(decimal side1, decimal side2, decimal side3)
+    private static bool ViolatesTriangleInequality(double side1, double side2, double side3)
     {
         return side1 + side2 <= side3 || side1 + side3 <= side2 || side2 + side3 <= side1;
     }
 
-    private static int UniqueSides(decimal side1, decimal side2, decimal side3)
+    private static int UniqueSides(double side1, double side2, double side3)
     {
-        decimal[] sides = { side1, side2, side3 };
+        double[] sides = { side1, side2, side3 };
         return sides.Distinct().Count();
     }
 }

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

@@ -9,7 +9,22 @@ public enum TriangleKind
 
 public static class Triangle
 {
-    public static TriangleKind Kind(decimal side1, decimal side2, decimal side3)
+    public static bool IsScalene(double side1, double side2, double side3)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public static bool IsIsosceles(double side1, double side2, double side3) 
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public static bool IsEquilateral(double side1, double side2, double side3) 
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+    
+    private static TriangleKind Kind(double side1, double side2, double side3)
     {
         throw new NotImplementedException("You need to implement this function.");
     }