trackler 2.2.1.12 → 2.2.1.13

data/tracks/csharp/exercises/phone-number/Example.cs

@@ -1,50 +1,23 @@
+using System.Linq;
 using System.Text.RegularExpressions;
 
 public class PhoneNumber
 {
-    private static readonly Regex DigitsOnly = new Regex(@"[^\d]");
+    private static readonly Regex phoneNumberFormat = new Regex("^1?([2-9][0-9]{2}[2-9][0-9]{6})$");
 
-    public string Number { get; private set; }
-    public string AreaCode { get; private set; }
-
-    public PhoneNumber(string phoneNumber)
-    {
-        Number = GetValidatedPhoneNumber(phoneNumber);
-        AreaCode = Number.Substring(0, 3);
-    }
-
-    private static string GetValidatedPhoneNumber(string phoneNumber)
-    {
-        var stripped = StripOutNonNumerics(phoneNumber);
-
-        if (IsInvalidPhoneNumber(stripped))
-            return GetInvalidPhoneNumberReplacement(stripped);
-
-        return stripped;
-    }
-
-    private static string StripOutNonNumerics(string value)
-    {
-        return DigitsOnly.Replace(value, "");
-    }
-
-    private static bool IsInvalidPhoneNumber(string phoneNumber)
-    {
-        return phoneNumber.Length != 10;
-    }
-
-    private static string GetInvalidPhoneNumberReplacement(string phoneNumber)
-    {
-        return IsPhoneNumberWithUSAreaCode(phoneNumber) ? phoneNumber.Substring(1) : "0000000000";
-    }
-
-    private static bool IsPhoneNumberWithUSAreaCode(string value)
-    {
-        return value.Length == 11 && value.StartsWith("1");
-    }
-
-    public override string ToString()
+    public static string Clean(string phoneNumber)
     {
-        return string.Format("({0}) {1}-{2}", AreaCode, Number.Substring(3, 3), Number.Substring(6));
+        var digits = string.Join(string.Empty, phoneNumber.Where(l => l >= '0' && l <= '9'));
+
+        var match = phoneNumberFormat.Match(digits);
+
+        if (match.Success)
+        {
+            return match.Groups[1].ToString();
+        }
+        else
+        {
+            return null;
+        }
     }
 }

data/tracks/csharp/exercises/phone-number/PhoneNumber.cs

@@ -2,23 +2,8 @@
 
 public class PhoneNumber
 {
-    public PhoneNumber(string phoneNumber)
+    public static string Clean(string phoneNumber)
     {
-    }
-
-    public string Number
-    {
-        get
-        {
-            throw new NotImplementedException("You need to implement this function.");
-        }
-    }
-
-    public string AreaCode
-    {
-        get
-        {
-            throw new NotImplementedException("You need to implement this function.");
-        }
+        throw new NotImplementedException("You need to implement this function.");
     }
 }

data/tracks/csharp/exercises/phone-number/PhoneNumberTest.cs

@@ -1,53 +1,90 @@
+// This file was auto-generated based on version 1.2.0 of the canonical data.
+
 using Xunit;
 
 public class PhoneNumberTest
 {
     [Fact]
-    public void Cleans_parens_spaces_and_dashes()
+    public void Cleans_the_number()
     {
-        var phone = new PhoneNumber("(123) 456-7890");
-        Assert.Equal("1234567890", phone.Number);
+        var phrase = "(223) 456-7890";
+        Assert.Equal("2234567890", PhoneNumber.Clean(phrase));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Cleans_numbers_with_dots()
     {
-        var phone = new PhoneNumber("123.456.7890");
-        Assert.Equal("1234567890", phone.Number);
+        var phrase = "223.456.7890";
+        Assert.Equal("2234567890", PhoneNumber.Clean(phrase));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Allows_us_country_code()
+    public void Cleans_numbers_with_multiple_spaces()
     {
-        var phone = new PhoneNumber("11234567890");
-        Assert.Equal("1234567890", phone.Number);
+        var phrase = "223 456   7890   ";
+        Assert.Equal("2234567890", PhoneNumber.Clean(phrase));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Invalid_when_11_digits()
+    public void Invalid_when_9_digits()
     {
-        var phone = new PhoneNumber("21234567890");
-        Assert.Equal("0000000000", phone.Number);
+        var phrase = "123456789";
+        Assert.Null(PhoneNumber.Clean(phrase));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Invalid_when_9_digits()
+    public void Invalid_when_11_digits_does_not_start_with_a_1()
+    {
+        var phrase = "22234567890";
+        Assert.Null(PhoneNumber.Clean(phrase));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Valid_when_11_digits_and_starting_with_1()
+    {
+        var phrase = "12234567890";
+        Assert.Equal("2234567890", PhoneNumber.Clean(phrase));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Valid_when_11_digits_and_starting_with_1_even_with_punctuation()
+    {
+        var phrase = "+1 (223) 456-7890";
+        Assert.Equal("2234567890", PhoneNumber.Clean(phrase));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Invalid_when_more_than_11_digits()
+    {
+        var phrase = "321234567890";
+        Assert.Null(PhoneNumber.Clean(phrase));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Invalid_with_letters()
+    {
+        var phrase = "123-abc-7890";
+        Assert.Null(PhoneNumber.Clean(phrase));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Invalid_with_punctuations()
     {
-        var phone = new PhoneNumber("123456789");
-        Assert.Equal("0000000000", phone.Number);
+        var phrase = "123-@:!-7890";
+        Assert.Null(PhoneNumber.Clean(phrase));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Has_an_area_code()
+    public void Invalid_if_area_code_does_not_start_with_2_9()
     {
-        var phone = new PhoneNumber("1234567890");
-        Assert.Equal("123", phone.AreaCode);
+        var phrase = "(123) 456-7890";
+        Assert.Null(PhoneNumber.Clean(phrase));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Formats_a_number()
+    public void Invalid_if_exchange_code_does_not_start_with_2_9()
     {
-        var phone = new PhoneNumber("1234567890");
-        Assert.Equal("(123) 456-7890", phone.ToString());
+        var phrase = "(223) 056-7890";
+        Assert.Null(PhoneNumber.Clean(phrase));
     }
 }

data/tracks/csharp/exercises/prime-factors/Example.cs

@@ -2,7 +2,7 @@
 
 public class PrimeFactors
 {
-    public static int[] For(long number)
+    public static int[] Factors(long number)
     {
         var primes = new List<int>();
         int divisor = 2;

data/tracks/csharp/exercises/prime-factors/PrimeFactors.cs

@@ -2,7 +2,7 @@
 
 public static class PrimeFactors
 {
-    public static int[] For(long number)
+    public static int[] Factors(long number)
     {
         throw new NotImplementedException();
     }

data/tracks/csharp/exercises/prime-factors/PrimeFactorsTest.cs

@@ -1,70 +1,48 @@
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
 using Xunit;
 
 public class PrimeFactorsTest
 {
     [Fact]
-    public void Test_1()
-    {
-        Assert.Equal(new int[0], PrimeFactors.For(1));
-    }
-
-    [Fact(Skip = "Remove to run test")]
-    public void Test_2()
-    {
-        Assert.Equal(new[] { 2 }, PrimeFactors.For(2));
-    }
-
-    [Fact(Skip = "Remove to run test")]
-    public void Test_3()
-    {
-        Assert.Equal(new[] { 3 }, PrimeFactors.For(3));
-    }
-
-    [Fact(Skip = "Remove to run test")]
-    public void Test_4()
-    {
-        Assert.Equal(new[] { 2, 2 }, PrimeFactors.For(4));
-    }
-
-    [Fact(Skip = "Remove to run test")]
-    public void Test_6()
+    public void No_factors()
     {
-        Assert.Equal(new[] { 2, 3 }, PrimeFactors.For(6));
+        Assert.Empty(PrimeFactors.Factors(1));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Test_8()
+    public void Prime_number()
     {
-        Assert.Equal(new[] { 2, 2, 2 }, PrimeFactors.For(8));
+        Assert.Equal(new[] { 2 }, PrimeFactors.Factors(2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Test_9()
+    public void Square_of_a_prime()
     {
-        Assert.Equal(new[] { 3, 3 }, PrimeFactors.For(9));
+        Assert.Equal(new[] { 3, 3 }, PrimeFactors.Factors(9));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Test_27()
+    public void Cube_of_a_prime()
     {
-        Assert.Equal(new[] { 3, 3, 3 }, PrimeFactors.For(27));
+        Assert.Equal(new[] { 2, 2, 2 }, PrimeFactors.Factors(8));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Test_625()
+    public void Product_of_primes_and_non_primes()
     {
-        Assert.Equal(new[] { 5, 5, 5, 5 }, PrimeFactors.For(625));
+        Assert.Equal(new[] { 2, 2, 3 }, PrimeFactors.Factors(12));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Test_901255()
+    public void Product_of_primes()
     {
-        Assert.Equal(new[] { 5, 17, 23, 461 }, PrimeFactors.For(901255));
+        Assert.Equal(new[] { 5, 17, 23, 461 }, PrimeFactors.Factors(901255));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Test_93819012551()
+    public void Factors_include_a_large_prime()
     {
-        Assert.Equal(new[] { 11, 9539, 894119 }, PrimeFactors.For(93819012551));
+        Assert.Equal(new[] { 11, 9539, 894119 }, PrimeFactors.Factors(93819012551));
     }
 }

data/tracks/csharp/exercises/rail-fence-cipher/RailFenceCipherTest.cs

@@ -1,58 +1,60 @@
-using Xunit;
+// This file was auto-generated based on version 1.0.1 of the canonical data.
+
+using Xunit;
 
 public class RailFenceCipherTest
 {
     [Fact]
     public void Encode_with_two_rails()
     {
-        var railFenceCipher = new RailFenceCipher(2);
-        var actual = railFenceCipher.Encode("XOXOXOXOXOXOXOXOXO");
+        var msg = "XOXOXOXOXOXOXOXOXO";
+        var sut = new RailFenceCipher(2);
         var expected = "XXXXXXXXXOOOOOOOOO";
-        Assert.Equal(expected, actual);
+        Assert.Equal(expected, sut.Encode(msg));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Encode_with_three_rails()
     {
-        var railFenceCipher = new RailFenceCipher(3);
-        var actual = railFenceCipher.Encode("WEAREDISCOVEREDFLEEATONCE");
+        var msg = "WEAREDISCOVEREDFLEEATONCE";
+        var sut = new RailFenceCipher(3);
         var expected = "WECRLTEERDSOEEFEAOCAIVDEN";
-        Assert.Equal(expected, actual);
+        Assert.Equal(expected, sut.Encode(msg));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Encode_with_ending_in_the_middle()
     {
-        var railFenceCipher = new RailFenceCipher(4);
-        var actual = railFenceCipher.Encode("EXERCISES");
+        var msg = "EXERCISES";
+        var sut = new RailFenceCipher(4);
         var expected = "ESXIEECSR";
-        Assert.Equal(expected, actual);
+        Assert.Equal(expected, sut.Encode(msg));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Decode_with_three_rails()
     {
-        var railFenceCipher = new RailFenceCipher(3);
-        var actual = railFenceCipher.Decode("TEITELHDVLSNHDTISEIIEA");
+        var msg = "TEITELHDVLSNHDTISEIIEA";
+        var sut = new RailFenceCipher(3);
         var expected = "THEDEVILISINTHEDETAILS";
-        Assert.Equal(expected, actual);
+        Assert.Equal(expected, sut.Decode(msg));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Decode_with_five_rails()
     {
-        var railFenceCipher = new RailFenceCipher(5);
-        var actual = railFenceCipher.Decode("EIEXMSMESAORIWSCE");
+        var msg = "EIEXMSMESAORIWSCE";
+        var sut = new RailFenceCipher(5);
         var expected = "EXERCISMISAWESOME";
-        Assert.Equal(expected, actual);
+        Assert.Equal(expected, sut.Decode(msg));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Decode_with_six_rails()
     {
-        var railFenceCipher = new RailFenceCipher(6);
-        var actual = railFenceCipher.Decode("133714114238148966225439541018335470986172518171757571896261");
+        var msg = "133714114238148966225439541018335470986172518171757571896261";
+        var sut = new RailFenceCipher(6);
         var expected = "112358132134558914423337761098715972584418167651094617711286";
-        Assert.Equal(expected, actual);
+        Assert.Equal(expected, sut.Decode(msg));
     }
 }

data/tracks/csharp/exercises/rna-transcription/Example.cs

@@ -1,15 +1,20 @@
 using System.Collections.Generic;
 using System.Linq;
 
-public class Complement
+public static class RnaTranscription
 {
     private static readonly Dictionary<char, char> DnaToRna = new Dictionary<char, char>
         {
             { 'G', 'C' }, { 'C', 'G' }, { 'T', 'A' }, { 'A', 'U' }
         };
 
-    public static string OfDna(string nucleotide)
+    public static string ToRna(string nucleotide)
     {
+        if (nucleotide.Any(x => !DnaToRna.ContainsKey(x)))
+        {
+            return null;
+        }
+
         return string.Concat(nucleotide.Select(x => DnaToRna[x]));
     }
 }

data/tracks/csharp/exercises/rna-transcription/RnaTranscription.cs

@@ -1,8 +1,8 @@
 using System;
 
-public static class Complement
+public static class RnaTranscription
 {
-    public static string OfDna(string nucleotide)
+    public static string ToRna(string nucleotide)
     {
         throw new NotImplementedException("You need to implement this function.");
     }

data/tracks/csharp/exercises/rna-transcription/RnaTranscriptionTest.cs

@@ -1,34 +1,54 @@
+// This file was auto-generated based on version 1.0.1 of the canonical data.
+
 using Xunit;
 
-public class ComplementTest
+public class RnaTranscriptionTest
 {
     [Fact]
     public void Rna_complement_of_cytosine_is_guanine()
     {
-        Assert.Equal("G", Complement.OfDna("C"));
+        Assert.Equal("G", RnaTranscription.ToRna("C"));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Rna_complement_of_guanine_is_cytosine()
     {
-        Assert.Equal("C", Complement.OfDna("G"));
+        Assert.Equal("C", RnaTranscription.ToRna("G"));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Rna_complement_of_thymine_is_adenine()
     {
-        Assert.Equal("A", Complement.OfDna("T"));
+        Assert.Equal("A", RnaTranscription.ToRna("T"));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Rna_complement_of_adenine_is_uracil()
     {
-        Assert.Equal("U", Complement.OfDna("A"));
+        Assert.Equal("U", RnaTranscription.ToRna("A"));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Rna_complement()
     {
-        Assert.Equal("UGCACCAGAAUU", Complement.OfDna("ACGTGGTCTTAA"));
+        Assert.Equal("UGCACCAGAAUU", RnaTranscription.ToRna("ACGTGGTCTTAA"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Correctly_handles_invalid_input_rna_instead_of_dna_()
+    {
+        Assert.Null(RnaTranscription.ToRna("U"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Correctly_handles_completely_invalid_dna_input()
+    {
+        Assert.Null(RnaTranscription.ToRna("XXX"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Correctly_handles_partially_invalid_dna_input()
+    {
+        Assert.Null(RnaTranscription.ToRna("ACGTXXXCTTAA"));
     }
 }