trackler 2.0.8.20 → 2.0.8.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eb72b896068a0db09871303423eb36d77ae12e79
-  data.tar.gz: b4f173c7a80ecc1a8dad8b60f163a92085a97a82
+  metadata.gz: 2491ccce5df1a33884d83cdd96ff6c4f2c05112d
+  data.tar.gz: e4b9594ea3bf42070f042029ac4da76db12148c9
 SHA512:
-  metadata.gz: 36f010e19529f3ff4f39e0a8b3aa16ecbba03834b7fbc36a644e1abef9dc9e1d05e3bb17a81c3ffdecc2daeb9ed0d3c08d68387b1559cd8b3154bad7cf52a2bf
-  data.tar.gz: 9ebce40e4a533258b9920f11ae1354e29aeb926704bf074eb05733d13364335be3e93a993e6f8b3fd7422c131286c3a4d9d38c244ebbe5e0b4b8e8198d0838dc
+  metadata.gz: 890a55c3d39142507ca80cf77e361d6562b1b78791847c5f1eb7fee02870083cb8756259dd66841ab169e929870198512e406eeb416b9f3b2b229b13fd4f6067
+  data.tar.gz: ee04f7b93f395b455fca240796a3cceeabd0224b882f45bd00d72edf54d2f852e66ae6d9524d0b97ee47975a49082aef26b1a1482326f647dcb4f611596407a9

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.8.20"
+  VERSION = "2.0.8.21"
 end

data/tracks/csharp/.travis.yml

@@ -1,10 +1,7 @@
 language: csharp
-sudo: required
 dist: trusty
 dotnet: 1.0.1
 mono: none
-os:
-  - linux
 env:
   global:
     - DOTNET_SKIP_FIRST_TIME_EXPERIENCE: 1
@@ -12,4 +9,4 @@ env:
 script:
   - ./bin/fetch-configlet
   - ./bin/configlet .
-  - ./build.sh
+  - ./build.sh

data/tracks/csharp/exercises/accumulate/HINTS.md

@@ -0,0 +1,3 @@
+## Hints
+This exercise requires you to write an extension method. For more information, see [this page] 
+(https://msdn.microsoft.com/en-us//library/bb383977.aspx).

data/tracks/csharp/exercises/allergies/HINTS.md

@@ -0,0 +1,3 @@
+## Hints
+This exercise requires you to use bitwise operations. For more information, see [this page]
+(https://msdn.microsoft.com/en-us/library/6a71f45d.aspx). 

data/tracks/csharp/exercises/alphametics/HINTS.md

@@ -0,0 +1,5 @@
+## Hints
+- To parse the text, you could try to use the [Sprache](https://github.com/sprache/Sprache/blob/develop/README.md) library. You can also find a good tutorial [here](https://www.thomaslevesque.com/2017/02/23/easy-text-parsing-in-c-with-sprache/).
+- You can solve this exercise with a brute force algorithm, but this will possibly have a poor runtime performance.
+Try to find a more sophisticated solution. 
+- Hint: You could try the column-wise addition algorithm that is usually taught in school.

data/tracks/csharp/exercises/bank-account/HINTS.md

@@ -0,0 +1,3 @@
+## Hints
+This exercise requires you to handle data related to currency and money. A normal approuch is to use the [Decimal](https://msdn.microsoft.com/en-US/library/system.decimal.aspx) struct to store currency values. 
+Note though that you then only store the numeric value of a currency. 

data/tracks/csharp/exercises/beer-song/HINTS.md

@@ -0,0 +1,2 @@
+## Hints
+- Try to capture the structure of the song in your code, where you build up the song by composing its parts.

data/tracks/csharp/exercises/clock/HINTS.md

@@ -0,0 +1,4 @@
+## Hints
+This exercise requires you to implements a type-specific method for determining equality of instances.
+For more information, see [this page]
+(https://docs.microsoft.com/en-us/dotnet/core/api/System.IEquatable-1) .

data/tracks/csharp/exercises/custom-set/HINTS.md

@@ -0,0 +1,4 @@
+## Hints
+This exercise requires you to implements a type-specific method for determining equality of instances.
+For more information, see [this page]
+(https://docs.microsoft.com/en-us/dotnet/core/api/System.IEquatable-1) .

data/tracks/csharp/exercises/difference-of-squares/HINTS.md

@@ -0,0 +1,4 @@
+## Hints
+This exercise requires you to process a collection of data. You can simplify your code by using LINQ (Language Integrated Query).
+For more information, see [this page]
+(https://docs.microsoft.com/en-us/dotnet/articles/standard/using-linq).

data/tracks/csharp/exercises/diffie-hellman/HINTS.md

@@ -0,0 +1,3 @@
+## Hints
+This exercise requires you to perform calculations on large numbers. To correctly represent large numbers, the
+[BigInteger](https://msdn.microsoft.com/en-us/library/system.numerics.biginteger(v=vs.110).aspx) struct is used.

data/tracks/csharp/exercises/food-chain/HINTS.md

@@ -0,0 +1,2 @@
+## Hints
+- Try to capture the structure of the song in your code, where you build up the song by composing its parts.

data/tracks/csharp/exercises/forth/HINTS.md

@@ -0,0 +1,2 @@
+## Hints
+- To parse the text, you could try to use the [Sprache](https://github.com/sprache/Sprache/blob/develop/README.md) library. You can also find a good tutorial [here](https://www.thomaslevesque.com/2017/02/23/easy-text-parsing-in-c-with-sprache/).

data/tracks/csharp/exercises/hangman/HINTS.md

@@ -0,0 +1,3 @@
+## Hints
+This exercise requires you to work with events. For more information, see [this page]
+(https://docs.microsoft.com/en-us/dotnet/articles/csharp/programming-guide/events/) .

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

@@ -1,6 +1,6 @@
-public class Year
+public static class Leap
 {
-    public static bool IsLeap(int year)
+    public static bool IsLeapYear(int year)
     {
         if (year % 100 == 0)
             return year % 400 == 0;

data/tracks/csharp/exercises/leap/Leap.cs

@@ -1,8 +1,8 @@
 using System;
 
-public static class Year
+public static class Leap
 {
-    public static bool IsLeap(int year)
+    public static bool IsLeapYear(int year)
     {
         throw new NotImplementedException("You need to implement this function.");
     }

data/tracks/csharp/exercises/leap/LeapTest.cs

@@ -5,24 +5,24 @@ public class LeapTest
     [Fact]
     public void Year_not_divisible_by_4_is_common_year()
     {
-        Assert.False(Year.IsLeap(2015));
+        Assert.False(Leap.IsLeapYear(2015));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Year_divisible_by_4_not_divisible_by_100_is_leap_year()
     {
-        Assert.True(Year.IsLeap(2016));
+        Assert.True(Leap.IsLeapYear(2016));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Year_divisible_by_100_not_divisible_by_400_is_common_year()
     {
-        Assert.False(Year.IsLeap(2100));
+        Assert.False(Leap.IsLeapYear(2100));
     }
 
     [Fact(Skip = "Remove to run test")]
     public void Year_divisible_by_400_is_leap_year()
     {
-        Assert.True(Year.IsLeap(2000));
+        Assert.True(Leap.IsLeapYear(2000));
     }
 }

data/tracks/csharp/exercises/sgf-parsing/HINTS.md

@@ -0,0 +1,2 @@
+## Hints
+- To parse the text, you could try to use the [Sprache](https://github.com/sprache/Sprache/blob/develop/README.md) library. You can also find a good tutorial [here](https://www.thomaslevesque.com/2017/02/23/easy-text-parsing-in-c-with-sprache/).

data/tracks/csharp/exercises/simple-linked-list/HINTS.md

@@ -0,0 +1,3 @@
+## Hints
+This exercise requires you to create a linked list data structure which can be iterated. This requires you to implement the IEnumerable\<T> interface. 
+For more information, see [this page](https://msdn.microsoft.com/en-us/library/9eekhta0(v=vs.110).aspx).

data/tracks/csharp/exercises/sublist/HINTS.md

@@ -0,0 +1,3 @@
+## Hints
+To be able to compare data, the IComparable interface is used.
+For more information, see [this page](https://msdn.microsoft.com/en-us/library/system.icomparable(v=vs.110).aspx).

data/tracks/csharp/exercises/twelve-days/HINTS.md

@@ -0,0 +1,2 @@
+## Hints
+- Try to capture the structure of the song in your code, where you build up the song by composing its parts.

data/tracks/csharp/exercises/variable-length-quantity/HINTS.md

@@ -0,0 +1,3 @@
+## Hints
+This exercise requires you to use bitwise operations. For more information, see [this page]
+(https://msdn.microsoft.com/en-us/library/6a71f45d.aspx). 

data/tracks/csharp/exercises/wordy/HINTS.md

@@ -0,0 +1,2 @@
+## Hints
+- To parse the text, you could try to use the [Sprache](https://github.com/sprache/Sprache/blob/develop/README.md) library. You can also find a good tutorial [here](https://www.thomaslevesque.com/2017/02/23/easy-text-parsing-in-c-with-sprache/).

data/tracks/csharp/generators/BooleanTestMethod.cs

@@ -0,0 +1,36 @@
+using System;
+using Humanizer;
+
+namespace Generators
+{
+    public class BooleanTestMethod : TestMethod
+    {
+        public BooleanTestMethod(CanonicalData canonicalData, CanonicalDataCase canonicalDataCase, int index)
+        {
+            Index = index;
+            MethodName = GetMethodName(canonicalDataCase);
+            Body = GetBody(canonicalData, canonicalDataCase);
+        }
+
+        private static string GetMethodName(CanonicalDataCase canonicalDataCase)
+            => canonicalDataCase.Description.Replace(":", " is").Transform(To.TestMethodName);
+
+        private static string GetBody(CanonicalData canonicalData, CanonicalDataCase canonicalDataCase)
+        {
+            var isTrue = Convert.ToBoolean(canonicalDataCase.Expected);
+            var testedClassName = GetTestedClassName(canonicalData);
+            var testedMethod = GetTestedMethod(canonicalDataCase);
+
+            return $"Assert.{isTrue}({testedClassName}.{testedMethod}({canonicalDataCase.Input}));";
+        }
+
+        private static string GetTestedClassName(CanonicalData canonicalData)
+            => canonicalData.Exercise.Transform(To.TestedClassName);
+
+        private static string GetTestedMethod(CanonicalDataCase canonicalDataCase)
+        {
+            var testedMethod = canonicalDataCase.Property.Transform(To.TestedMethodName);
+            return testedMethod.StartsWith("Is") ? testedMethod : "Is" + testedMethod;
+        }
+    }
+}

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

@@ -1,4 +1,7 @@
-namespace Generators.Exercises
+using System.Linq;
+using Humanizer;
+
+namespace Generators.Exercises
 {
     public abstract class Exercise
     {
@@ -9,6 +12,14 @@
 
         public string Name { get; }
 
-        public abstract TestClass CreateTestClass(CanonicalData canonicalData);
+        public TestClass CreateTestClass(CanonicalData canonicalData)
+        {
+            return new TestClass
+            {
+                ClassName = Name.Transform(To.TestClassName),
+                TestMethods = canonicalData.Cases.Select((canonicalDataCase, index) => CreateTestMethod(canonicalData, canonicalDataCase, index)).ToArray()
+            };
+        }
+        protected abstract TestMethod CreateTestMethod(CanonicalData canonicalData, CanonicalDataCase canonicalDataCase, int index);
     }
 }

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

@@ -1,8 +1,4 @@
-using System;
-using System.Linq;
-using Humanizer;
-
-namespace Generators.Exercises
+namespace Generators.Exercises
 {
     public class LeapExercise : Exercise
     {
@@ -10,26 +6,7 @@ namespace Generators.Exercises
         {
         }
 
-        public override TestClass CreateTestClass(CanonicalData canonicalData)
-        {
-            return new TestClass
-            {
-                ClassName = "Leap",
-                TestMethods = canonicalData.Cases.Select(CreateTestMethod).ToArray()
-            };
-        }
-
-        private static TestMethod CreateTestMethod(CanonicalDataCase canonicalDataCase, int index)
-        {
-            var year = Convert.ToInt32(canonicalDataCase.Input);
-            var isTrue = Convert.ToBoolean(canonicalDataCase.Expected);
-
-            return new TestMethod
-            {
-                Index = index,
-                MethodName = canonicalDataCase.Description.Replace(":", " is").Transform(To.TestMethodName),
-                Body = $"Assert.{isTrue}(Year.IsLeap({year}));"
-            };
-        }
+        protected override TestMethod CreateTestMethod(CanonicalData canonicalData, CanonicalDataCase canonicalDataCase, int index)
+            =>  new BooleanTestMethod(canonicalData, canonicalDataCase, index);
     }
 }

data/tracks/csharp/generators/Program.cs

@@ -1,6 +1,5 @@
 using Generators.Exercises;
 using System.IO;
-using Humanizer;
 using Serilog;
 
 namespace Generators
@@ -35,25 +34,25 @@ namespace Generators
     {   
         public static void Generate(Exercise exercise)
         {
-            var testClassContents = GenerateTestClassContents(exercise);
-            var testClassFilePath = TestFilePath(exercise);
+            var testClass = CreateTestClass(exercise);
+            var testClassContents = TestClassRenderer.Render(testClass);
+            var testClassFilePath = TestFilePath(exercise, testClass);
 
             SaveTestClassContentsToFile(testClassFilePath, testClassContents);
             Log.Information("Generated tests for {Exercise} exercise in {TestFile}.", exercise.Name, testClassFilePath);
         }
 
-        private static string GenerateTestClassContents(Exercise exercise)
+        private static TestClass CreateTestClass(Exercise exercise)
         {
             var canonicalData = CanonicalDataParser.Parse(exercise.Name);
-            var testClass = exercise.CreateTestClass(canonicalData);
-            return TestClassRenderer.Render(testClass);
+            return exercise.CreateTestClass(canonicalData);
         }
 
         private static void SaveTestClassContentsToFile(string testClassFilePath, string testClassContents) => 
             File.WriteAllText(testClassFilePath, testClassContents);
 
-        private static string TestFilePath(Exercise exercise) => Path.Combine("..", "exercises", exercise.Name, TestFileName(exercise));
+        private static string TestFilePath(Exercise exercise, TestClass testClass) => Path.Combine("..", "exercises", exercise.Name, TestFileName(testClass));
 
-        private static string TestFileName(Exercise exercise) => $"{exercise.Name.Transform(Humanizer.To.TitleCase)}Test.cs";
+        private static string TestFileName(TestClass testClass) => $"{testClass.ClassName}.cs";
     }
 }

data/tracks/csharp/generators/TestClassNameTransformer.cs

@@ -0,0 +1,9 @@
+using Humanizer;
+
+namespace Generators
+{
+    public class TestClassNameTransformer : IStringTransformer
+    {
+        public string Transform(string input) => $"{input.Dehumanize()}Test";
+    }
+}

data/tracks/csharp/generators/TestClassRenderer.cs

@@ -8,7 +8,7 @@ namespace Generators
         private const string TestClassTemplate =
 @"{UsingNamespaces}
 
-public class {ClassName}Test
+public class {ClassName}
 {
 {Body}
 }";

data/tracks/csharp/generators/TestedClassNameTransformer.cs

@@ -0,0 +1,11 @@
+using System.Text.RegularExpressions;
+using Humanizer;
+
+namespace Generators
+{
+    public class TestedClassNameTransformer : IStringTransformer
+    {
+        public string Transform(string input) 
+            => Regex.Replace(input, @"[^\w]+", "", RegexOptions.Compiled).Underscore().Transform(Humanizer.To.TitleCase);
+    }
+}

data/tracks/csharp/generators/TestedMethodNameTransformer.cs

@@ -0,0 +1,9 @@
+using Humanizer;
+
+namespace Generators
+{
+    public class TestedMethodNameTransformer : IStringTransformer
+    {
+        public string Transform(string input) => input.Dehumanize();
+    }
+}

data/tracks/csharp/generators/To.cs

@@ -2,6 +2,9 @@
 {
     public static class To
     {
+        public static readonly TestedClassNameTransformer TestedClassName = new TestedClassNameTransformer();
+        public static readonly TestClassNameTransformer TestClassName = new TestClassNameTransformer();
+        public static readonly TestedMethodNameTransformer TestedMethodName = new TestedMethodNameTransformer();
         public static readonly TestMethodNameTransformer TestMethodName = new TestMethodNameTransformer();
     }
 }

data/tracks/elixir/config.json

@@ -464,6 +464,14 @@
       "topics": [
         "Pattern Matching"
       ]
+    },
+    {
+      "slug": "ocr-numbers",
+      "difficulty": 6,
+      "topics": [
+        "Strings",
+        "Enumerations"
+      ]
     }
   ],
   "deprecated": [

data/tracks/elixir/exercises/ocr-numbers/example.exs

@@ -0,0 +1,47 @@
+defmodule OCRNumbers do
+
+  @doc """
+  Given a 3 x 4 grid of pipes, underscores, and spaces, determine which number is represented, or
+  whether it is garbled.
+  """
+  @spec convert([String.t]) :: String.t
+  def convert(input) do
+    Enum.chunk(input, 4)
+    |> Enum.map(fn row_set -> _convert(row_set, "") end)
+    |> format_output()
+  end
+
+  def format_output([]), do: {:error, 'invalid line count'}
+  def format_output(rows), do: _format_output(Enum.any?(rows, &_error?/1), rows)
+  def _format_output(true, rows), do: Enum.find(rows, &_error?/1)
+  def _format_output(false, output), do: {:ok, Enum.join(output, ",")}
+  def _error?({:error, _}), do: true
+  def _error?(_), do: false
+
+  def _convert(_, {:error, _} = error), do: error
+  def _convert(input, _) when length(input) != 4, do: {:error, 'invalid line count'}
+  def _convert(["", "", "", ""], output), do: output
+  def _convert(input, output) do
+    split_strings = Enum.map(input, fn a -> String.split_at(a, 3) end)
+    this_character = Enum.map(split_strings, fn ({a, _}) -> a end)
+    other_characters = Enum.map(split_strings, fn {_, a} -> a end)
+    lengths = Enum.map(this_character, fn a -> String.length(a) end)
+
+    _convert(other_characters, update_output(lengths, this_character, output))
+  end
+
+  def update_output([3, 3, 3, 3], chars, output), do: output <> recognize_character(chars)
+  def update_output(_, _, _), do: {:error, 'invalid column count'}
+
+  def recognize_character([" _ ", "| |", "|_|", "   "]), do: "0"
+  def recognize_character(["   ", "  |", "  |", "   "]), do: "1"
+  def recognize_character([" _ ", " _|", "|_ ", "   "]), do: "2"
+  def recognize_character([" _ ", " _|", " _|", "   "]), do: "3"
+  def recognize_character(["   ", "|_|", "  |", "   "]), do: "4"
+  def recognize_character([" _ ", "|_ ", " _|", "   "]), do: "5"
+  def recognize_character([" _ ", "|_ ", "|_|", "   "]), do: "6"
+  def recognize_character([" _ ", "  |", "  |", "   "]), do: "7"
+  def recognize_character([" _ ", "|_|", "|_|", "   "]), do: "8"
+  def recognize_character([" _ ", "|_|", " _|", "   "]), do: "9"
+  def recognize_character(_), do: "?"
+end

data/tracks/elixir/exercises/ocr-numbers/ocr_numbers.exs

@@ -0,0 +1,10 @@
+defmodule OCRNumbers do
+
+  @doc """
+  Given a 3 x 4 grid of pipes, underscores, and spaces, determine which number is represented, or
+  whether it is garbled.
+  """
+  @spec convert([String.t]) :: String.t
+  def convert(input) do
+  end
+end