trackler 2.0.8.24 → 2.0.8.26

data/tracks/ceylon/README.md

@@ -1,9 +1,9 @@
 # xceylon
 
-Exercism problems in Ceylon.
-
 [![Build Status](https://travis-ci.org/exercism/xceylon.svg?branch=master)](https://travis-ci.org/exercism/xceylon)
 
+Exercism problems in Ceylon.
+
 ## Contributing Guide
 
 ### Asking for help

data/tracks/csharp/.gitattributes

@@ -0,0 +1,11 @@
+*        text=auto
+
+*.cs     text=auto diff=csharp
+*.csproj text=auto
+*.sln    text=auto eol=crlf
+*.sh     eol=lf
+*.ps1    eol=crlf
+
+*.jpg    binary
+*.png    binary
+*.gif    binary

data/tracks/csharp/appveyor.yml

@@ -1,7 +1,4 @@
 image: Visual Studio 2017
-environment:
-  DOTNET_CLI_TELEMETRY_OPTOUT: true
-  DOTNET_SKIP_FIRST_TIME_EXPERIENCE: true
 test: off
 build_script:
-- ps: ./build.ps1
+- ps: ./build.ps1

data/tracks/csharp/exercises/acronym/AcronymTest.cs

@@ -33,7 +33,7 @@ public class AcronymTest
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void NonAcronymAllCapsWord()
+    public void Non_acronym_all_caps_word()
     {
         Assert.Equal("GIMP", Acronym.Abbreviate("GNU Image Manipulation Program"));
     }

data/tracks/csharp/exercises/atbash-cipher/AtbashCipher.cs

@@ -1,9 +1,14 @@
 using System;
 
-public static class Atbash
+public static class AtbashCipher
 {
-    public static string Encode(string value)
+    public static string Encode(string plainValue)
     {
         throw new NotImplementedException("You need to implement this function.");
     }
-}
+
+    public static string Decode(string encodedValue)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

data/tracks/csharp/exercises/atbash-cipher/AtbashCipherTest.cs

@@ -0,0 +1,76 @@
+using Xunit;
+
+public class AtbashCipherTest
+{
+    [Fact]
+    public void Encode_yes()
+    {
+        Assert.Equal("bvh", AtbashCipher.Encode("yes"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Encode_no()
+    {
+        Assert.Equal("ml", AtbashCipher.Encode("no"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Encode_omg()
+    {
+        Assert.Equal("lnt", AtbashCipher.Encode("OMG"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Encode_spaces()
+    {
+        Assert.Equal("lnt", AtbashCipher.Encode("O M G"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Encode_mindblowingly()
+    {
+        Assert.Equal("nrmwy oldrm tob", AtbashCipher.Encode("mindblowingly"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Encode_numbers()
+    {
+        Assert.Equal("gvhgr mt123 gvhgr mt", AtbashCipher.Encode("Testing,1 2 3, testing."));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Encode_deep_thought()
+    {
+        Assert.Equal("gifgs rhurx grlm", AtbashCipher.Encode("Truth is fiction."));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Encode_all_the_letters()
+    {
+        Assert.Equal("gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt", AtbashCipher.Encode("The quick brown fox jumps over the lazy dog."));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Decode_exercism()
+    {
+        Assert.Equal("exercism", AtbashCipher.Decode("vcvix rhn"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Decode_a_sentence()
+    {
+        Assert.Equal("anobstacleisoftenasteppingstone", AtbashCipher.Decode("zmlyh gzxov rhlug vmzhg vkkrm thglm v"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Decode_numbers()
+    {
+        Assert.Equal("testing123testing", AtbashCipher.Decode("gvhgr mt123 gvhgr mt"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Decode_all_the_letters()
+    {
+        Assert.Equal("thequickbrownfoxjumpsoverthelazydog", AtbashCipher.Decode("gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt"));
+    }
+}

data/tracks/csharp/exercises/atbash-cipher/Example.cs

@@ -1,35 +1,34 @@
+using System;
 using System.Collections.Generic;
 using System.Linq;
 
-public static class Atbash
+public static class AtbashCipher
 {
-    private const string PLAIN = "abcdefghijklmnopqrstuvwxyz";
-    private const string CIPHER = "zyxwvutsrqponmlkjihgfedcba";
+    private const int BlockSize = 5;
+    private const string Plain = "abcdefghijklmnopqrstuvwxyz0123456789";
+    private const string Cipher = "zyxwvutsrqponmlkjihgfedcba0123456789";
 
-    public static string Encode(string value)
-    {
-        var encoded = string.Concat(StripInvalidCharacters(value).ToLower().Select(ApplyCipher));
-        return SplitIntoFiveLetterWords(encoded);
-    }
+    public static string Encode(string plainValue) 
+        => string.Join(" ", EncodeInBlocks(GetEncodedCharacters(plainValue)));
 
-    private static string StripInvalidCharacters(string value)
-    {
-        return string.Concat(value.Where(char.IsLetterOrDigit));
-    }
+    public static string Decode(string encodedValue)
+        => new string(encodedValue.Replace(" ", "").Select(Decode).ToArray());
 
-    private static char ApplyCipher(char value)
-    {
-        var idx = PLAIN.IndexOf(value);
-        return idx >= 0 ? CIPHER[idx] : value;
-    }
+    private static IEnumerable<char> GetEncodedCharacters(string words) 
+        => GetValidCharacters(words).Select(Encode);
 
-    private static string SplitIntoFiveLetterWords(string value)
-    {
-        var words = new List<string>();
+    private static IEnumerable<char> GetValidCharacters(string words) 
+        => words.ToLowerInvariant().Where(char.IsLetterOrDigit);
+
+    private static char Encode(char c) => Cipher[Plain.IndexOf(c)];
 
-        for (int i = 0; i < value.Length; i += 5)
-            words.Add(i + 5 <= value.Length ? value.Substring(i, 5) : value.Substring(i));
+    private static char Decode(char c) => Plain[Cipher.IndexOf(c)];
+
+    private static IEnumerable<string> EncodeInBlocks(IEnumerable<char> value)
+    {
+        var valueAsString = new string(value.ToArray());
 
-        return string.Join(" ", words);
+        for (var i = 0; i < valueAsString.Length; i += BlockSize)
+            yield return valueAsString.Substring(i, Math.Min(BlockSize, valueAsString.Length - i));
     }
 }

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

@@ -1,7 +1,7 @@
 using System;
 using System.Collections.Generic;
 
-public class Isogram
+public static class Isogram
 {
     public static bool IsIsogram(string word)
     {
@@ -17,4 +17,4 @@ public class Isogram
 
         return true;
     }
-}
+}

data/tracks/csharp/exercises/isogram/IsogramTest.cs

@@ -1,20 +1,52 @@
-using Xunit;
+using Xunit;
 
 public class IsogramTest
 {
-    [Theory]
-    [InlineData("duplicates", true)]
-    [InlineData("eleven", false)]
-    [InlineData("subdermatoglyphic", true)]
-    [InlineData("Alphabet", false)]
-    [InlineData("thumbscrew-japingly", true)]
-    [InlineData("Hjelmqvist-Gryb-Zock-Pfund-Wax", true)]
-    [InlineData("Heizölrückstoßabdämpfung", true)]
-    [InlineData("the quick brown fox", false)]
-    [InlineData("Emily Jung Schwartzkopf", true)]
-    [InlineData("éléphant", false)]
-    public void Isogram_correctly_detects_isograms(string input, bool expected)
-    {
-        Assert.Equal(expected, Isogram.IsIsogram(input));
+    [Fact]
+    public void Empty_string()
+    {
+        Assert.True(Isogram.IsIsogram(""));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Isogram_with_only_lower_case_characters()
+    {
+        Assert.True(Isogram.IsIsogram("isogram"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Word_with_one_duplicated_character()
+    {
+        Assert.False(Isogram.IsIsogram("eleven"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Longest_reported_english_isogram()
+    {
+        Assert.True(Isogram.IsIsogram("subdermatoglyphic"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Word_with_duplicated_character_in_mixed_case()
+    {
+        Assert.False(Isogram.IsIsogram("Alphabet"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Hypothetical_isogrammic_word_with_hyphen()
+    {
+        Assert.True(Isogram.IsIsogram("thumbscrew-japingly"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Isogram_with_duplicated_non_letter_character()
+    {
+        Assert.True(Isogram.IsIsogram("Hjelmqvist-Gryb-Zock-Pfund-Wax"));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Made_up_name_that_is_an_isogram()
+    {
+        Assert.True(Isogram.IsIsogram("Emily Jung Schwartzkopf"));
     }
 }

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

@@ -4,8 +4,11 @@ using System.Linq;
 
 public static class NthPrime
 {
-    public static int Nth(int nth)
+    public static int Prime(int nth)
     {
+        if (nth < 1)
+            throw new ArgumentOutOfRangeException();
+
         return Primes().Skip(nth - 1).First();
     }
 

data/tracks/csharp/exercises/nth-prime/NthPrime.cs

@@ -4,7 +4,7 @@ using System.Linq;
 
 public static class NthPrime
 {
-    public static int Nth(int nth)
+    public static int Prime(int nth)
     {
         throw new NotImplementedException("You need to implement this function.");
     }

data/tracks/csharp/exercises/nth-prime/NthPrimeTest.cs

@@ -1,21 +1,35 @@
-using Xunit;
+using Xunit;
+using System;
 
 public class NthPrimeTest
 {
-    [Theory]
-    [InlineData(1, 2)]
-    [InlineData(2, 3)]
-    [InlineData(3, 5)]
-    [InlineData(4, 7)]
-    [InlineData(5, 11)]
-    [InlineData(6, 13)]
-    [InlineData(7, 17)]
-    [InlineData(8, 19)]
-    [InlineData(1000, 7919)]
-    [InlineData(10000, 104729)]
-    [InlineData(10001, 104743)]
-    public void Nth_prime_calculated(int nth, int expected)
+    [Fact]
+    public void First_prime()
     {
-        Assert.Equal(expected, NthPrime.Nth(nth));
+        Assert.Equal(2, NthPrime.Prime(1));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Second_prime()
+    {
+        Assert.Equal(3, NthPrime.Prime(2));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Sixth_prime()
+    {
+        Assert.Equal(13, NthPrime.Prime(6));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Big_prime()
+    {
+        Assert.Equal(104743, NthPrime.Prime(10001));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void There_is_no_zeroth_prime()
+    {
+        Assert.Throws<ArgumentOutOfRangeException>(() => NthPrime.Prime(0));
     }
 }

data/tracks/csharp/exercises/perfect-numbers/Example.cs

@@ -1,35 +1,33 @@
-public enum NumberType
+using System;
+
+public enum Classification
 {
     Perfect,
     Abundant,
     Deficient
 }
 
-public class PerfectNumbers
+public static class PerfectNumbers
 {
-    public static NumberType Classify(int number)
+    public static Classification Classify(int number)
     {
+        if (number < 1)
+            throw new ArgumentOutOfRangeException();
+
         int sumOfFactors = 0;
 
         for (int i = 1; i < number; i++)
         {
             if (number % i == 0)
-            {
                 sumOfFactors += i;
-            }
         }
 
         if (sumOfFactors < number)
-        {
-            return NumberType.Deficient;
-        }
-        else if (sumOfFactors == number)
-        {
-            return NumberType.Perfect;
-        }
-        else
-        {
-            return NumberType.Abundant;
-        }
+            return Classification.Deficient;
+            
+        if (sumOfFactors == number)
+            return Classification.Perfect;
+        
+        return Classification.Abundant;
     }
 }

data/tracks/csharp/exercises/perfect-numbers/PerfectNumbers.cs

@@ -1,6 +1,6 @@
 using System;
 
-public enum NumberType
+public enum Classification
 {
     Perfect,
     Abundant,
@@ -9,7 +9,7 @@ public enum NumberType
 
 public static class PerfectNumbers
 {
-    public static NumberType Classify(int number)
+    public static Classification Classify(int number)
     {
         throw new NotImplementedException();
     }

data/tracks/csharp/exercises/perfect-numbers/PerfectNumbersTest.cs

@@ -1,31 +1,83 @@
-using Xunit;
+using Xunit;
+using System;
 
 public class PerfectNumbersTest
 {
-    [Theory]
-    [InlineData(3)]
-    [InlineData(7)]
-    [InlineData(13)]
-    public void Can_classify_deficient_numbers(int number)
-    {
-        Assert.Equal(NumberType.Deficient, PerfectNumbers.Classify(number));
-    }
-    
-    [Theory(Skip = "Remove to run test")]
-    [InlineData(6)]
-    [InlineData(28)]
-    [InlineData(496)]
-    public void Can_classify_perfect_numbers(int number)
-    {
-        Assert.Equal(NumberType.Perfect, PerfectNumbers.Classify(number));
-    }
-    
-    [Theory(Skip = "Remove to run test")]
-    [InlineData(12)]
-    [InlineData(18)]
-    [InlineData(20)]
-    public void Can_classify_abundant_numbers(int number)
-    {
-        Assert.Equal(NumberType.Abundant, PerfectNumbers.Classify(number));
+    [Fact]
+    public void Smallest_perfect_number_is_classified_correctly()
+    {
+        Assert.Equal(Classification.Perfect, PerfectNumbers.Classify(6));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Medium_perfect_number_is_classified_correctly()
+    {
+        Assert.Equal(Classification.Perfect, PerfectNumbers.Classify(28));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Large_perfect_number_is_classified_correctly()
+    {
+        Assert.Equal(Classification.Perfect, PerfectNumbers.Classify(33550336));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Smallest_abundant_number_is_classified_correctly()
+    {
+        Assert.Equal(Classification.Abundant, PerfectNumbers.Classify(12));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Medium_abundant_number_is_classified_correctly()
+    {
+        Assert.Equal(Classification.Abundant, PerfectNumbers.Classify(30));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Large_abundant_number_is_classified_correctly()
+    {
+        Assert.Equal(Classification.Abundant, PerfectNumbers.Classify(33550335));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Smallest_prime_deficient_number_is_classified_correctly()
+    {
+        Assert.Equal(Classification.Deficient, PerfectNumbers.Classify(2));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Smallest_non_prime_deficient_number_is_classified_correctly()
+    {
+        Assert.Equal(Classification.Deficient, PerfectNumbers.Classify(4));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Medium_deficient_number_is_classified_correctly()
+    {
+        Assert.Equal(Classification.Deficient, PerfectNumbers.Classify(32));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Large_deficient_number_is_classified_correctly()
+    {
+        Assert.Equal(Classification.Deficient, PerfectNumbers.Classify(33550337));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Edge_case_no_factors_other_than_itself_is_classified_correctly()
+    {
+        Assert.Equal(Classification.Deficient, PerfectNumbers.Classify(1));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Zero_is_rejected_not_a_natural_number_()
+    {
+        Assert.Throws<ArgumentOutOfRangeException>(() => PerfectNumbers.Classify(0));
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Negative_integer_is_rejected_not_a_natural_number_()
+    {
+        Assert.Throws<ArgumentOutOfRangeException>(() => PerfectNumbers.Classify(-1));
     }
 }