trackler 2.0.6.11 → 2.0.6.12

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

@@ -0,0 +1,106 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+
+public class LedgerEntry
+{
+    public LedgerEntry(DateTime date, string description, float change)
+    {
+        Date = date;
+        Description = description;
+        Change = change;
+    }
+
+    public DateTime Date { get; }
+    public string Description { get; }
+    public float Change { get; }
+}
+
+public static class Ledger
+{
+    private const int TruncateLength = 25;
+    private const string TruncateSuffix = "...";
+
+    public static LedgerEntry CreateEntry(string date, string description, int change) =>
+        new LedgerEntry(ParseDate(date), description, ParseChange(change));
+
+    private static DateTime ParseDate(string date) => DateTime.Parse(date, System.Globalization.CultureInfo.InvariantCulture);
+
+    private static float ParseChange(int change) => change / 100.0f;
+
+    private static string CurrencySymbol(string currency)
+    {
+        switch (currency)
+        {
+            case "USD": return "$";
+            case "EUR": return "€";
+            default: throw new ArgumentException("Invalid currency");
+        }
+    }
+
+    private static CultureInfo CultureInfo(string locale)
+    {
+        switch (locale)
+        {
+            case "en-US": return new CultureInfo(locale);
+            case "nl-NL": return new CultureInfo(locale);
+            default: throw new ArgumentException("Invalid locale");
+        }
+    }
+
+    private static string ShortDateFormat(string locale)
+    {
+        switch (locale)
+        {
+            case "en-US": return "MM/dd/yyyy";
+            case "nl-NL": return "dd/MM/yyyy";
+            default: throw new ArgumentException("Invalid locale");
+        }
+    }
+
+    private static CultureInfo getCulture(string currency, string locale)
+    {
+        var culture = CultureInfo(locale);
+        culture.NumberFormat.CurrencySymbol = CurrencySymbol(currency);
+        culture.DateTimeFormat.ShortDatePattern = ShortDateFormat(locale);
+        return culture;
+    }
+
+    private static string FormatHeader(CultureInfo culture)
+    {
+        switch (culture.Name)
+        {
+            case "en-US": return "Date       | Description               | Change       ";
+            case "nl-NL": return "Datum      | Omschrijving              | Verandering  ";
+            default: throw new ArgumentException("Invalid locale");
+        }
+    }
+
+    private static string FormatDate(IFormatProvider culture, DateTime date) => date.ToString("d", culture);
+
+    private static string FoormatDescription(string description) =>
+        description.Length <= TruncateLength ? description : description.Substring(0, TruncateLength - TruncateSuffix.Length) + TruncateSuffix;
+
+    private static string FormatChange(IFormatProvider culture, float change) =>
+        change < 0.0 ? change.ToString("C", culture) : change.ToString("C", culture) + " ";
+
+    private static string FormatEntry(IFormatProvider culture, LedgerEntry entry) =>
+        string.Format("{0} | {1,-25} | {2,13}", FormatDate(culture, entry.Date), FoormatDescription(entry.Description), FormatChange(culture, entry.Change));
+
+    private static IEnumerable<LedgerEntry> OrderEntries(LedgerEntry[] entries) =>
+        entries
+            .OrderBy(x => x.Date)
+            .ThenBy(x => x.Description)
+            .ThenBy(x => x.Change);
+
+    public static string Format(string currency, string locale, LedgerEntry[] entries)
+    {
+        var culture = getCulture(currency, locale);
+        var header = FormatHeader(culture);
+        var printedEntries = OrderEntries(entries).Select(entry => FormatEntry(culture, entry));
+        var lines = new[] { header }.Concat(printedEntries);
+
+        return string.Join("\n", lines);
+    }
+}

data/tracks/csharp/exercises/ledger/Ledger.cs

@@ -0,0 +1,166 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+
+public class LedgerEntry
+{
+   public LedgerEntry(DateTime date, string desc, float chg)
+   {
+       Date = date;
+       Desc = desc;
+       Chg = chg;
+   }
+
+   public DateTime Date { get; }
+   public string Desc { get; }
+   public float Chg { get; }
+}
+
+public static class Ledger
+{
+   public static LedgerEntry CreateEntry(string date, string desc, int chng)
+   {
+       return new LedgerEntry(DateTime.Parse(date, CultureInfo.InvariantCulture), desc, chng / 100.0f);
+   }
+
+   private static CultureInfo CreateCulture(string cur, string loc)
+   {
+       string curSymb = null;
+       string datPat = null;
+
+       if (cur != "USD" && cur != "EUR")
+       {
+           throw new ArgumentException("Invalid currency");
+       }
+       else
+       {
+           if (loc != "nl-NL" && loc != "en-US")
+           {
+               throw new ArgumentException("Invalid currency");
+           }
+
+           if (cur == "USD")
+           {
+               if (loc == "en-US")
+               {
+                   curSymb = "$";
+                   datPat = "MM/dd/yyyy";
+               }
+               else if (loc == "nl-NL")
+               {
+                   curSymb = "$";
+                   datPat = "dd/MM/yyyy";
+               }
+           }
+
+
+           if (cur == "EUR")
+           {
+               if (loc == "en-US")
+               {
+                   curSymb = "€";
+                   datPat = "MM/dd/yyyy";
+               }
+               else if (loc == "nl-NL")
+               {
+                   curSymb = "€";
+                   datPat = "dd/MM/yyyy";
+               }
+           }
+       }
+
+       var culture = new CultureInfo(loc);
+       culture.NumberFormat.CurrencySymbol = curSymb;
+       culture.DateTimeFormat.ShortDatePattern = datPat;
+       return culture;
+   }
+
+   private static string PrintHead(string loc)
+   {
+       if (loc == "en-US")
+       {
+           return "Date       | Description               | Change       ";
+       }
+
+       else
+       {
+           if (loc == "nl-NL")
+           {
+               return "Datum      | Omschrijving              | Verandering  ";
+           }
+           else
+           {
+               throw new ArgumentException("Invalid locale");
+           }
+       }
+   }
+
+   private static string Date(IFormatProvider culture, DateTime date) => date.ToString("d", culture);
+
+   private static string Description(string desc)
+   {
+       if (desc.Length > 25)
+       {
+           var trunc = desc.Substring(0, 22);
+           trunc += "...";
+           return trunc;
+       }
+
+       return desc;
+   }
+
+   private static string Change(IFormatProvider culture, float cgh)
+   {
+       return cgh < 0.0 ? cgh.ToString("C", culture) : cgh.ToString("C", culture) + " ";
+   }
+
+   private static string PrintEntry(IFormatProvider culture, LedgerEntry entry)
+   {
+       var formatted = "";
+       var date = Date(culture, entry.Date);
+       var description = Description(entry.Desc);
+       var change = Change(culture, entry.Chg);
+
+       formatted += date;
+       formatted += " | ";
+       formatted += string.Format("{0,-25}", description);
+       formatted += " | ";
+       formatted += string.Format("{0,13}", change);
+
+       return formatted;
+   }
+
+
+   private static IEnumerable<LedgerEntry> sort(LedgerEntry[] entries)
+   {
+       var neg = entries.Where(e => e.Chg < 0).OrderBy(x => x.Date + "@" + x.Desc + "@" + x.Chg);
+       var post = entries.Where(e => e.Chg >= 0).OrderBy(x => x.Date + "@" + x.Desc + "@" + x.Chg);
+
+       var result = new List<LedgerEntry>();
+       result.AddRange(neg);
+       result.AddRange(post);
+
+       return result;
+   }
+
+   public static string Format(string currency, string locale, LedgerEntry[] entries)
+   {
+       var formatted = "";
+       formatted += PrintHead(locale);
+
+       var culture = CreateCulture(currency, locale);
+
+       if (entries.Length > 0)
+       {
+           var entriesForOutput = sort(entries);
+
+           for (var i = 0; i < entriesForOutput.Count(); i++)
+           {
+               formatted += "\n" + PrintEntry(culture, entriesForOutput.Skip(i).First());
+           }
+       }
+
+       return formatted;
+   }
+}

data/tracks/csharp/exercises/ledger/LedgerTest.cs

@@ -0,0 +1,168 @@
+using NUnit.Framework;
+
+public class LedgerTest
+{
+    [Test]
+    public void Empty_ledger()
+    {
+        var currency = "USD";
+        var locale = "en-US";
+        var entries = new LedgerEntry[0];
+        var expected =
+            "Date       | Description               | Change       ";
+
+        Assert.That(Ledger.Format(currency, locale, entries), Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void One_entry()
+    {
+        var currency = "USD";
+        var locale = "en-US";
+        var entries = new[] 
+        {
+            Ledger.CreateEntry("2015-01-01", "Buy present", -1000)
+        };
+        var expected =
+            "Date       | Description               | Change       \n" +
+            "01/01/2015 | Buy present               |      ($10.00)";
+
+        Assert.That(Ledger.Format(currency, locale, entries), Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void Credit_and_debit()
+    {
+        var currency = "USD";
+        var locale = "en-US";
+        var entries = new[] 
+        {
+            Ledger.CreateEntry("2015-01-02", "Get present", 1000),
+            Ledger.CreateEntry("2015-01-01", "Buy present", -1000)
+        };
+        var expected =
+            "Date       | Description               | Change       \n" +
+            "01/01/2015 | Buy present               |      ($10.00)\n" +
+            "01/02/2015 | Get present               |       $10.00 ";
+
+        Assert.That(Ledger.Format(currency, locale, entries), Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void Multiple_entries_on_same_date_ordered_by_description()
+    {
+        var currency = "USD";
+        var locale = "en-US";
+        var entries = new[] 
+        {
+            Ledger.CreateEntry("2015-01-01", "Buy present", -1000),
+            Ledger.CreateEntry("2015-01-01", "Get present", 1000)
+        };
+        var expected =
+            "Date       | Description               | Change       \n" +
+            "01/01/2015 | Buy present               |      ($10.00)\n" +
+            "01/01/2015 | Get present               |       $10.00 ";
+
+        Assert.That(Ledger.Format(currency, locale, entries), Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void Final_order_tie_breaker_is_change()
+    {
+        var currency = "USD";
+        var locale = "en-US";
+        var entries = new[] 
+        {
+            Ledger.CreateEntry("2015-01-01", "Something", 0),
+            Ledger.CreateEntry("2015-01-01", "Something", -1),
+            Ledger.CreateEntry("2015-01-01", "Something", 1)
+        };
+        var expected =
+            "Date       | Description               | Change       \n" +
+            "01/01/2015 | Something                 |       ($0.01)\n" +
+            "01/01/2015 | Something                 |        $0.00 \n" +
+            "01/01/2015 | Something                 |        $0.01 ";
+
+        Assert.That(Ledger.Format(currency, locale, entries), Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void Overlong_descriptions()
+    {
+        var currency = "USD";
+        var locale = "en-US";
+        var entries = new[] 
+        {
+            Ledger.CreateEntry("2015-01-01", "Freude schoner Gotterfunken", -123456)
+        };
+        var expected =
+            "Date       | Description               | Change       \n" +
+            "01/01/2015 | Freude schoner Gotterf... |   ($1,234.56)";
+
+        Assert.That(Ledger.Format(currency, locale, entries), Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void Euros()
+    {
+        var currency = "EUR";
+        var locale = "en-US";
+        var entries = new[] 
+        {
+            Ledger.CreateEntry("2015-01-01", "Buy present", -1000)
+        };
+        var expected =
+            "Date       | Description               | Change       \n" +
+            "01/01/2015 | Buy present               |      (€10.00)";
+
+        Assert.That(Ledger.Format(currency, locale, entries), Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void Dutch_locale()
+    {
+        var currency = "USD";
+        var locale = "nl-NL";
+        var entries = new[] 
+        {
+            Ledger.CreateEntry("2015-03-12", "Buy present", 123456)
+        };
+        var expected =
+            "Datum      | Omschrijving              | Verandering  \n" +
+            "12-03-2015 | Buy present               |   $ 1.234,56 ";
+
+        Assert.That(Ledger.Format(currency, locale, entries), Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void Dutch_negative_number_with_3_digits_before_decimal_point()
+    {
+        var currency = "USD";
+        var locale = "nl-NL";
+        var entries = new[] 
+        {
+            Ledger.CreateEntry("2015-03-12", "Buy present", -12345)
+        };
+        var expected =
+            "Datum      | Omschrijving              | Verandering  \n" +
+            "12-03-2015 | Buy present               |     $ -123,45";
+
+        Assert.That(Ledger.Format(currency, locale, entries), Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void American_negative_number_with_3_digits_before_decimal_point()
+    {
+        var currency = "USD";
+        var locale = "en-US";
+        var entries =   new[] 
+        {
+            Ledger.CreateEntry("2015-03-12", "Buy present", -12345)
+        };
+        var expected =
+            "Date       | Description               | Change       \n" +
+            "03/12/2015 | Buy present               |     ($123.45)";
+
+        Assert.That(Ledger.Format(currency, locale, entries), Is.EqualTo(expected));
+    }
+}

data/tracks/elixir/exercises/allergies/allergies_test.exs

@@ -75,9 +75,9 @@ defmodule AllergiesTest do
     set = Enum.into(list, MapSet.new)
     same_contents = to_contain
       |> Enum.into(MapSet.new)
-      |> Set.equal?(set)
+      |> MapSet.equal?(set)
     assert same_contents,
-           "Expected a set with: #{inspect to_contain} got #{inspect set |> Set.to_list}"
+           "Expected a set with: #{inspect to_contain} got #{inspect set |> MapSet.to_list}"
   end
 
 end

data/tracks/elixir/exercises/markdown/example.exs

@@ -27,9 +27,9 @@ defmodule Markdown do
 
   defp process_md(text_with_md) do
     cond do
-      String.starts_with?(text_with_md, "#") -> parse_header_md_level(text_with_md) |> enclose_with_header_tag
-      String.starts_with?(text_with_md, "*") -> parse_list_md_level(text_with_md)
-      true                                   -> String.split(text_with_md) |> enclose_with_paragraph_tag
+      String.starts_with?(text_with_md, @header_md) -> parse_header_md_level(text_with_md) |> enclose_with_header_tag
+      String.starts_with?(text_with_md, @list_md)   -> parse_list_md_level(text_with_md)
+      true                                          -> String.split(text_with_md) |> enclose_with_paragraph_tag
     end
   end
 

data/tracks/elixir/exercises/phone-number/example.exs

@@ -3,8 +3,6 @@ defmodule Phone do
   Utilities to work with phone numbers.
   """
 
-  @bad_result "0000000000"
-
   @doc """
   Clean up a phone number.
 

data/tracks/elixir/exercises/queen-attack/example.exs

@@ -19,7 +19,7 @@ defmodule Queens do
   """
   @spec to_string(Queens.t()) :: String.t()
   def to_string(%Queens{ white: white, black: black }) do
-    generate_board
+    generate_board()
     |> insert_queen(white, "W")
     |> insert_queen(black, "B")
     |> Enum.map(&Enum.join(&1, " "))

data/tracks/elixir/exercises/wordy/example.exs

@@ -16,7 +16,7 @@ defmodule Wordy do
   end
 
   defp tokenize(sentence) do
-    Regex.scan(~r/(#{all_matchers})/, sentence)
+    Regex.scan(~r/(#{all_matchers()})/, sentence)
     |> Enum.map(&(Enum.at(&1,0)))
   end
 
@@ -53,7 +53,7 @@ defmodule Wordy do
     end
 
     def match?(token) do
-      String.match?(token,~r/#{matcher}/)
+      String.match?(token,~r/#{matcher()}/)
     end
 
     def parse(token) do
@@ -67,7 +67,7 @@ defmodule Wordy do
     end
 
     def match?(token) do
-      String.match?(token,~r/#{matcher}/)
+      String.match?(token,~r/#{matcher()}/)
     end
 
     def parse(_) do
@@ -85,7 +85,7 @@ defmodule Wordy do
     end
 
     def match?(token) do
-      String.match?(token,~r/#{matcher}/)
+      String.match?(token,~r/#{matcher()}/)
     end
 
     def parse(_) do
@@ -103,7 +103,7 @@ defmodule Wordy do
     end
 
     def match?(token) do
-      String.match?(token,~r/#{matcher}/)
+      String.match?(token,~r/#{matcher()}/)
     end
 
     def parse(_) do
@@ -121,7 +121,7 @@ defmodule Wordy do
     end
 
     def match?(token) do
-      String.match?(token,~r/#{matcher}/)
+      String.match?(token,~r/#{matcher()}/)
     end
 
     def parse(_) do

data/tracks/elixir/exercises/zipper/zipper_test.exs

@@ -23,61 +23,61 @@ defmodule ZipperTest do
 
   # @tag :pending
   test "data is retained" do
-    assert (t1 |> from_tree |> to_tree) == t1
+    assert (t1() |> from_tree |> to_tree) == t1()
   end
 
   @tag :pending
   test "left, right and value" do
-    assert (t1 |> from_tree |> left |> right |> value) == 3
+    assert (t1() |> from_tree |> left |> right |> value) == 3
   end
 
   @tag :pending
   test "dead end" do
-    assert (t1 |> from_tree |> left |> left) == nil
+    assert (t1() |> from_tree |> left |> left) == nil
   end
 
   @tag :pending
   test "tree from deep focus" do
-    assert (t1 |> from_tree |> left |> right |> to_tree) == t1
+    assert (t1() |> from_tree |> left |> right |> to_tree) == t1()
   end
 
   @tag :pending
   test "traversing up from top" do
-    assert (t1 |> from_tree |> up) == nil
+    assert (t1() |> from_tree |> up) == nil
   end
 
   @tag :pending
   test "left, right, and up" do
-    assert (t1 |> from_tree |> left |> up |> right |> up |> left |> right |> value) == 3
+    assert (t1() |> from_tree |> left |> up |> right |> up |> left |> right |> value) == 3
   end
 
   @tag :pending
   test "set_value" do
-    assert (t1 |> from_tree |> left |> set_value(5) |> to_tree) == t2
+    assert (t1() |> from_tree |> left |> set_value(5) |> to_tree) == t2()
   end
 
   @tag :pending
   test "set_value after traversing up" do
-    assert (t1 |> from_tree |> left |> right |> up |> set_value(5) |> to_tree) == t2
+    assert (t1() |> from_tree |> left |> right |> up |> set_value(5) |> to_tree) == t2()
   end
 
   @tag :pending
   test "set_left with leaf" do
-    assert (t1 |> from_tree |> left |> set_left(leaf(5)) |> to_tree) == t3
+    assert (t1() |> from_tree |> left |> set_left(leaf(5)) |> to_tree) == t3()
   end
 
   @tag :pending
   test "set_right with nil" do
-    assert (t1 |> from_tree |> left |> set_right(nil) |> to_tree) == t4
+    assert (t1() |> from_tree |> left |> set_right(nil) |> to_tree) == t4()
   end
 
   @tag :pending
   test "set_right with subtree" do
-    assert (t1 |> from_tree |> set_right(bt(6, leaf(7), leaf(8))) |> to_tree) == t5
+    assert (t1() |> from_tree |> set_right(bt(6, leaf(7), leaf(8))) |> to_tree) == t5()
   end
 
   @tag :pending
   test "set_value on deep focus" do
-    assert (t1 |> from_tree |> left |> right |> set_value(5) |> to_tree) == t6
+    assert (t1() |> from_tree |> left |> right |> set_value(5) |> to_tree) == t6()
   end
 end

data/tracks/elixir/mix.exs

@@ -5,7 +5,7 @@ defmodule ExercismTestRunner.Mixfile do
     [app: :tests,
      version: "0.0.1",
      elixir: "~> 1.3",
-     deps: deps,
+     deps: deps(),
      test_paths: ["exercises"],
      consolidate_protocols: false]
   end

data/tracks/fsharp/config.json

@@ -803,6 +803,14 @@
         "Transforming"
       ]
     },
+    {
+      "slug": "alphametics",
+      "difficulty": 9,
+      "topics": [
+        "Parsing",
+        "Maps"
+      ]
+    },
     {
       "slug": "zipper",
       "difficulty": 10,
@@ -828,14 +836,6 @@
         "Recursion",
         "Searching"
       ]
-    },
-    {
-      "slug": "alphametics",
-      "difficulty": 10,
-      "topics": [
-        "Parsing",
-        "Maps"
-      ]
     }
   ],
   "deprecated": [    

data/tracks/fsharp/docs/ABOUT.md

@@ -1 +1,5 @@
 [F#](http://www.tryfsharp.org/Explore) is a strongly-typed, functional language that is part of Microsoft's .NET language stack.
+
+Although F# is great for data science problems, it can elegantly handle almost every problem you throw at it. As F# runs on the .NET runtime, you get access to the entire .NET ecosystem, including all packages on [nuget.org](https://www.nuget.org/). This integration is further simplified due to F# also allowing you to write object-oriented code.
+
+The home page for F# is [fsharp.org](http://fsharp.org/). A great introduction to F# can be found at the [F# for fun and profit](http://fsharpforfunandprofit.com/) website.