trackler 2.0.8.34 → 2.0.8.35

data/tracks/csharp/exercises/beer-song/Example.cs

@@ -1,6 +1,6 @@
 using System.Linq;
 
-public static class Beer
+public static class BeerSong
 {
     public static string Verse(int number)
     {
@@ -17,11 +17,6 @@ public static string Verse(int number)
         }
     }
 
-    public static string Sing(int start, int stop)
-    {
-        return Enumerable.Range(stop, start - stop + 1)
-                            .Reverse()
-                            .Select(Verse)
-                            .Aggregate("", (acc, verse) => acc + verse + "\n");
-    }
+    public static string Verses(int begin, int end)
+        => string.Join("\n", Enumerable.Range(end, begin - end + 1).Reverse().Select(Verse));
 }

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

@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using System.Text.RegularExpressions;
 
-public static class WordProblem
+public static class Wordy
 {
     private static readonly Regex VariableAndOperatorGroupsRegex =
         new Regex(string.Format(@"{0} {1} {0}\s*{1}*\s*{0}*", @"(-?\d+)", "(plus|minus|multiplied by|divided by)"));
@@ -14,9 +14,9 @@ public static class WordProblem
             { "divided by", (x, y) => x / y },
         };
 
-    public static int Solve(string problem)
+    public static int Answer(string question)
     {
-        var parsedProblem = ParseProblem(problem);
+        var parsedProblem = ParseProblem(question);
         var firstPass = Operations[parsedProblem.Operation1](parsedProblem.X, parsedProblem.Y);
         if (parsedProblem.Operation2.Length == 0)
             return firstPass;

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

@@ -1,8 +1,8 @@
 using System;
 
-public static class WordProblem
+public static class Wordy
 {
-    public static int Solve(string problem)
+    public static int Answer(string question)
     {
         throw new NotImplementedException("You need to implement this function.");
     }

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

@@ -1,101 +1,101 @@
-using System;
 using Xunit;
+using System;
 
-public class WordProblemTest
+public class WordyTest
 {
     [Fact]
-    public void Can_parse_and_solve_addition_problems()
+    public void Addition()
     {
-        Assert.Equal(2, WordProblem.Solve("What is 1 plus 1?"));
+        Assert.Equal(2, Wordy.Answer("What is 1 plus 1?"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Can_add_double_digit_numbers()
+    public void More_addition()
     {
-        Assert.Equal(55, WordProblem.Solve("What is 53 plus 2?"));
+        Assert.Equal(55, Wordy.Answer("What is 53 plus 2?"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Can_add_negative_numbers()
+    public void Addition_with_negative_numbers()
     {
-        Assert.Equal(-11, WordProblem.Solve("What is -1 plus -10?"));
+        Assert.Equal(-11, Wordy.Answer("What is -1 plus -10?"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Can_add_large_numbers()
+    public void Large_addition()
     {
-        Assert.Equal(45801, WordProblem.Solve("What is 123 plus 45678?"));
+        Assert.Equal(45801, Wordy.Answer("What is 123 plus 45678?"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Can_parse_and_solve_subtraction_problems()
+    public void Subtraction()
     {
-        Assert.Equal(16, WordProblem.Solve("What is 4 minus -12"));
+        Assert.Equal(16, Wordy.Answer("What is 4 minus -12?"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Can_parse_and_solve_multiplication_problems()
+    public void Multiplication()
     {
-        Assert.Equal(-75, WordProblem.Solve("What is -3 multiplied by 25?"));
+        Assert.Equal(-75, Wordy.Answer("What is -3 multiplied by 25?"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Can_parse_and_solve_division_problems()
+    public void Division()
     {
-        Assert.Equal(-11, WordProblem.Solve("What is 33 divided by -3?"));
+        Assert.Equal(-11, Wordy.Answer("What is 33 divided by -3?"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Can_add_twice()
+    public void Multiple_additions()
     {
-        Assert.Equal(3, WordProblem.Solve("What is 1 plus 1 plus 1?"));
+        Assert.Equal(3, Wordy.Answer("What is 1 plus 1 plus 1?"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Can_add_then_subtract()
+    public void Addition_and_subtraction()
     {
-        Assert.Equal(8, WordProblem.Solve("What is 1 plus 5 minus -2?"));
+        Assert.Equal(8, Wordy.Answer("What is 1 plus 5 minus -2?"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Can_subtract_twice()
+    public void Multiple_subtraction()
     {
-        Assert.Equal(3, WordProblem.Solve("What is 20 minus 4 minus 13?"));
+        Assert.Equal(3, Wordy.Answer("What is 20 minus 4 minus 13?"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Can_subtract_then_add()
+    public void Subtraction_then_addition()
     {
-        Assert.Equal(14, WordProblem.Solve("What is 17 minus 6 plus 3?"));
+        Assert.Equal(14, Wordy.Answer("What is 17 minus 6 plus 3?"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Can_multiply_twice()
+    public void Multiple_multiplication()
     {
-        Assert.Equal(-12, WordProblem.Solve("What is 2 multiplied by -2 multiplied by 3?"));
+        Assert.Equal(-12, Wordy.Answer("What is 2 multiplied by -2 multiplied by 3?"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Can_add_then_multiply()
+    public void Addition_and_multiplication()
     {
-        Assert.Equal(-8, WordProblem.Solve("What is -3 plus 7 multiplied by -2?"));
+        Assert.Equal(-8, Wordy.Answer("What is -3 plus 7 multiplied by -2?"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Can_divide_twice()
+    public void Multiple_division()
     {
-        Assert.Equal(2, WordProblem.Solve("What is -12 divided by 2 divided by -3?"));
+        Assert.Equal(2, Wordy.Answer("What is -12 divided by 2 divided by -3?"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Cubed_is_too_advanced()
+    public void Unknown_operation()
     {
-        Assert.Throws<ArgumentException>(() => WordProblem.Solve("What is 53 cubed?"));
+        Assert.Throws<ArgumentException>(() => Wordy.Answer("What is 52 cubed?"));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Irrelevant_problems_are_not_valid()
+    public void Non_math_question()
     {
-        Assert.Throws<ArgumentException>(() => WordProblem.Solve("Who is the president of the United States?"));
+        Assert.Throws<ArgumentException>(() => Wordy.Answer("Who is the President of the United States?"));
     }
-}
+}

data/tracks/csharp/generators/Data/CanonicalDataValue.cs

@@ -1,10 +1,24 @@
-using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json.Linq;
 
 namespace Generators.Data
 {
     public static class CanonicalDataValue
     {
-        public static string StringArrayToString(object expected)
-            => string.Join("\\n\"+\n\"", ((JArray) expected).Values<string>());
+        public static string ExpectedToMultiLineString(object expected)
+        {
+            switch (expected)
+            {
+                case IEnumerable<string> enumerable:
+                    return string.Join("\\n\"+\n\"", enumerable);
+                case JArray jarray:
+                    return ExpectedToMultiLineString(((JArray) expected).Values<string>());
+                case string str:
+                    return ExpectedToMultiLineString(str.Split('\n'));
+                default:
+                    throw new ArgumentException("Cannot convert expected value to multil-ine string.");
+            }
+        }
     }
 }

data/tracks/csharp/generators/Exercises/BeerSongExercise.cs

@@ -0,0 +1,33 @@
+using Generators.Data;
+using Generators.Methods;
+
+namespace Generators.Exercises
+{
+    public class BeerSongExercise : EqualityExercise
+    {
+        public BeerSongExercise() : base("beer-song")
+        {
+        }
+
+        protected override TestMethodData CreateTestMethodData(CanonicalData canonicalData, CanonicalDataCase canonicalDataCase, int index)
+        {
+            var testMethodData = base.CreateTestMethodData(canonicalData, canonicalDataCase, index);
+
+            testMethodData.Options.UseVariableForExpected = true;
+            testMethodData.Options.FormatExpected = true;
+
+            testMethodData.CanonicalDataCase.Expected = CanonicalDataValue.ExpectedToMultiLineString(testMethodData.CanonicalDataCase.Expected);
+
+            if (testMethodData.CanonicalDataCase.Property == "verse")
+                testMethodData.Options.InputProperty = "number";
+            else
+                testMethodData.CanonicalDataCase.Input = new[] 
+                { 
+                    testMethodData.CanonicalDataCase.Data["beginning"], 
+                    testMethodData.CanonicalDataCase.Data["end"]
+                };
+                
+            return testMethodData;
+        }
+    }
+}

data/tracks/csharp/generators/Exercises/EqualityExercise.cs

@@ -9,6 +9,11 @@ protected EqualityExercise(string name) : base(name)
         }
 
         protected override TestMethod CreateTestMethod(TestMethodData testMethodData)
-            => CreateEqualityTestMethod(testMethodData);
+        {
+            if (testMethodData.Options.ThrowExceptionWhenExpectedValueEquals(testMethodData.CanonicalDataCase.Expected))
+                return CreateExceptionTestMethod(testMethodData);
+
+            return CreateEqualityTestMethod(testMethodData);
+        }
     }
 }

data/tracks/csharp/generators/Exercises/FoodChainExercise.cs

@@ -14,7 +14,7 @@ protected override TestMethodData CreateTestMethodData(CanonicalData canonicalDa
             var testMethodData = base.CreateTestMethodData(canonicalData, canonicalDataCase, index);
 
             testMethodData.Options.UseVariableForExpected = true;
-            testMethodData.CanonicalDataCase.Expected = CanonicalDataValue.StringArrayToString(canonicalDataCase.Expected);
+            testMethodData.CanonicalDataCase.Expected = CanonicalDataValue.ExpectedToMultiLineString(testMethodData.CanonicalDataCase.Expected);
 
             if (testMethodData.CanonicalDataCase.Data.ContainsKey("end verse"))
                 testMethodData.CanonicalDataCase.Input = new[] { testMethodData.CanonicalDataCase.Data["start verse"], testMethodData.CanonicalDataCase.Data["end verse"] };

data/tracks/csharp/generators/Exercises/HelloWorldExercise.cs

@@ -0,0 +1,9 @@
+namespace Generators.Exercises
+{
+    public class HelloWorldExercise : EqualityExercise
+    {
+        public HelloWorldExercise() : base("hello-world")
+        {
+        }
+    }
+}

data/tracks/csharp/generators/Exercises/NthPrimeExercise.cs

@@ -1,4 +1,5 @@
 using System;
+using Generators.Data;
 using Generators.Methods;
 
 namespace Generators.Exercises
@@ -9,15 +10,13 @@ public NthPrimeExercise() : base("nth-prime")
         {
         }
 
-        protected override TestMethod CreateTestMethod(TestMethodData testMethodData)
+        protected override TestMethodOptions CreateTestMethodOptions(CanonicalData canonicalData, CanonicalDataCase canonicalDataCase, int index)
         {
-            if (testMethodData.CanonicalDataCase.Expected is bool b && !b)
-            {
-                testMethodData.Options.ExceptionType = typeof(ArgumentOutOfRangeException);
-                return CreateExceptionTestMethod(testMethodData);
-            }
+            var testMethodOptions = base.CreateTestMethodOptions(canonicalData, canonicalDataCase, index);
+            testMethodOptions.ExceptionType = typeof(ArgumentOutOfRangeException);
+            testMethodOptions.ThrowExceptionWhenExpectedValueEquals = x => x is bool;
 
-            return CreateEqualityTestMethod(testMethodData);
-        }   
+            return testMethodOptions;
+        }
     }
 }

data/tracks/csharp/generators/Exercises/WordyExercise.cs

@@ -0,0 +1,20 @@
+using Generators.Data;
+using Generators.Methods;
+
+namespace Generators.Exercises
+{
+    public class WordyExercise : EqualityExercise
+    {
+        public WordyExercise() : base("wordy")
+        {
+        }
+
+        protected override TestMethodOptions CreateTestMethodOptions(CanonicalData canonicalData, CanonicalDataCase canonicalDataCase, int index)
+        {
+            var testMethodOptions = base.CreateTestMethodOptions(canonicalData, canonicalDataCase, index);
+            testMethodOptions.ThrowExceptionWhenExpectedValueEquals = x => x is bool;
+
+            return testMethodOptions;
+        }
+    }
+}

data/tracks/csharp/generators/Methods/TestMethodOptions.cs

@@ -10,5 +10,6 @@ public class TestMethodOptions
         public bool UseVariableForExpected { get; set; } = false;
         public Type ExceptionType { get; set; } = typeof(ArgumentException);
         public TestedMethodType TestedMethodType { get; set; } = TestedMethodType.Static;
+        public Func<object, bool> ThrowExceptionWhenExpectedValueEquals { get; set; } = (x) => false;
     }
 }

data/tracks/elixir/README.md

@@ -7,7 +7,7 @@ Exercism Exercises in Elixir
 
 The exercises currently target Elixir 1.3.2 and Erlang/OTP 19. Detailed installation instructions can be found at [http://elixir-lang.org/install.html](http://elixir-lang.org/install.html).
 
-##Contributing
+## Contributing
 
 Thank you so much for contributing! :tada:
 

data/tracks/go/config.json

@@ -496,6 +496,15 @@
       "difficulty": 1,
       "slug": "forth",
       "topics": []
+    },
+    {
+      "difficulty": 1,
+      "slug": "change",
+      "topics": [
+        "Control-flow (loops)",
+        "Arrays",
+        "Algorithms"
+      ]
     }
   ]
 }

data/tracks/go/exercises/accumulate/accumulate.go

@@ -0,0 +1,5 @@
+package accumulate
+
+const testVersion = 1
+
+func Accumulate([]string, func(string) string) []string

data/tracks/go/exercises/change/cases_test.go

@@ -0,0 +1,83 @@
+package change
+
+// Source: exercism/x-common
+// Commit: 3d8b5b3 change: Fix canonical-data.json formatting
+
+var testCases = []struct {
+	description    string
+	coins          []int
+	target         int
+	valid          bool  // true => no error, false => error expected
+	expectedChange []int // when .valid == true, the expected change coins
+}{
+	{
+		"single coin change",
+		[]int{1, 5, 10, 25, 100},
+		25,
+		true,
+		[]int{25},
+	},
+	{
+		"multiple coin change",
+		[]int{1, 5, 10, 25, 100},
+		15,
+		true,
+		[]int{5, 10},
+	},
+	{
+		"change with Lilliputian Coins",
+		[]int{1, 4, 15, 20, 50},
+		23,
+		true,
+		[]int{4, 4, 15},
+	},
+	{
+		"change with Lower Elbonia Coins",
+		[]int{1, 5, 10, 21, 25},
+		63,
+		true,
+		[]int{21, 21, 21},
+	},
+	{
+		"large target values",
+		[]int{1, 2, 5, 10, 20, 50, 100},
+		999,
+		true,
+		[]int{2, 2, 5, 20, 20, 50, 100, 100, 100, 100, 100, 100, 100, 100, 100},
+	},
+	{
+		"possible change without unit coins available",
+		[]int{2, 5, 10, 20, 50},
+		21,
+		true,
+		[]int{2, 2, 2, 5, 10},
+	},
+	{
+		"no coins make 0 change",
+		[]int{1, 5, 10, 21, 25},
+		0,
+		true,
+		[]int{},
+	},
+	{
+		"error testing for change smaller than the smallest of coins",
+		[]int{5, 10},
+		3,
+		false,
+		[]int(nil),
+	},
+	{
+		"error if no combination can add up to target",
+		[]int{5, 10},
+		94,
+		false,
+		[]int(nil),
+	},
+	{
+		"cannot find negative change values",
+		[]int{1, 2, 5},
+		-5,
+		false,
+		[]int(nil),
+	},
+}