trackler 2.0.6.11 → 2.0.6.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 80730bca62f82e148c9c102b1e1c19a0ab33cd53
-  data.tar.gz: ffa6a9582c1d94ee6e33ed0e2c1bc745b2ebb9cb
+  metadata.gz: fa8f1408ac09a98a6c3586666f197c85efa0b7cb
+  data.tar.gz: 71653c98fd6b510de72b238db40cdee9ac0ed1d2
 SHA512:
-  metadata.gz: 954c5a625d030d2892d93506fc9ad67c0117ad8cfedb037194e2cc8dcf9b4c6da18c6f2bd6c368a1ff1dec99afc61b0e20ad9582e9a00983508f231f47abc951
-  data.tar.gz: ad66f22ee9eadabfee064cdb40d83743165106f1f1ff080b3c4383eee26215ccec5895c43704940ddf05bd7f3171a0e22f4a5881833d1fe620085bf7af0cca3e
+  metadata.gz: 3cceac782125c988061568125f85e50bccdb0da21583c36279a48e0b885b265bc3b47a542dbaf5379844b025a4d54c81e462b4e03cb051e7012471242b0aa0fc
+  data.tar.gz: 50ca76ed02285f8230a10d7f5c3b099ce78c18d10aa1bc93726cae239eae45e5a90cb1fbe11707bcf86c4066a9a51726fb235da36ca3469683a25c78ce91d350

data/common/CONTRIBUTING.md

@@ -337,7 +337,12 @@ The exercise should consist of, at minimum:
 * A test suite
 * A reference solution that passes the test (see [#reference-solution](#reference-solution))
 
-Each language track might have additional requirements; check the README in
+You will need to add the exercise to `"exercises"` section of the `config.json` file in the track.
+The order in which the exercises are listed there is the order in which they are fetched by default by `exercism fetch`.
+Typically, exercises are ordered by difficulty, unless there is a particular reason to do otherwise.
+
+Each language track might have additional guidance on how to order their
+exercises or additional requirements on new exercise files; check the README in
 the repository for the track.
 
 ### Providing Feedback on the Site for an Exercise You Implemented

data/common/exercises/difference-of-squares/metadata.yml

@@ -1,4 +1,4 @@
 ---
-blurb: "Find the difference between the sum of the squares and the square of the sums of the first N natural numbers."
+blurb: "Find the difference between the sum of the squares and the square of the sum of the first N natural numbers."
 source: "Problem 6 at Project Euler"
 source_url: "http://projecteuler.net/problem=6"

data/common/exercises/luhn/canonical-data.json

@@ -26,8 +26,8 @@
       "expected": false
     },
     {
-      "description": "strings that contain non-digits are not valid",
-      "input": "827a 1232 7352 0569",
+      "description": "valid strings with a non-digit added become invalid",
+      "input": "046a 454 286",
       "expected": false
     }
   ]

data/common/exercises/rectangles/canonical-data.json

@@ -50,6 +50,31 @@
       ],
       "expected": 5
     },
+    {
+      "description": "rectangle of height 1 is counted",
+      "input": [
+        "+--+",
+        "+--+"
+      ],
+      "expected": 1
+    },
+    {
+      "description": "rectangle of width 1 is counted",
+      "input": [
+        "++",
+        "||",
+        "++"
+      ],
+      "expected": 1
+    },
+    {
+      "description": "1x1 square is counted",
+      "input": [
+        "++",
+        "++"
+      ],
+      "expected": 1
+    },
     {
       "description": "only complete rectangles are counted",
       "input": [

data/common/exercises/rectangles/description.md

@@ -2,13 +2,13 @@ Create a program to count the rectangles in an ASCII diagram like the one below.
 
 ```
    +--+
-   |  |
-+--+--+
+  ++  |
++-++--+
 |  |  |
 +--+--+
 ```
 
-The above diagram contains 5 rectangles:
+The above diagram contains 6 rectangles:
 
 ```
 
@@ -50,5 +50,13 @@ The above diagram contains 5 rectangles:
 +--+
 ```
 
+```
+       
+  ++   
+  ++   
+       
+       
+```
+
 You may assume that the input is always a proper rectangle (i.e. the length of
 every line equals the length of the first line).

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.6.11"
+  VERSION = "2.0.6.12"
 end

data/tracks/ceylon/config.json

@@ -27,6 +27,15 @@
         "Filtering"
       ]
     },
+    {
+      "slug": "largest-series-product",
+      "difficulty": 4,
+      "topics": [
+        "Strings",
+        "Integers",
+        "Transforming"
+      ]
+    },
     {
       "slug": "bracket-push",
       "difficulty": 6,

data/tracks/ceylon/exercises/anagram/source/anagram/AnagramTest.ceylon

@@ -1,44 +1,43 @@
 import ceylon.test { ... }
 
-{[String, {String*}, {String*}]*} cases =>
-  {
-    // no matches
-    ["diaper", {"hello", "world", "zombies", "pants"}, {}],
-    // detects simple anagram
-    ["ant", {"tan", "stand", "at"}, {"tan"}],
-    // does not detect false positives
-    ["galea", {"eagle"}, {}],
-    // detects multiple anagrams
-    ["master", {"stream", "pigeon", "maters"}, {"stream", "maters"}],
-    // does not detect anagram subsets
-    ["good", {"dog", "goody"}, {}],
-    // detects anagram
-    ["listen", {"enlists", "google", "inlets", "banana"}, {"inlets"}],
-    // detects multiple anagrams
-    [
-      "allergy",
-      {"gallery", "ballerina", "regally", "clergy", "largely", "leading"},
-      {"gallery", "regally", "largely"}
-    ],
-    // does not detect identical words
-    ["corn", {"corn", "dark", "Corn", "rank", "CORN", "cron", "park"}, {"cron"}],
-    // does not detect non-anagrams with identical checksum
-    ["mass", {"last"}, {}],
-    // detects anagrams case-insensitively
-    ["Orchestra", {"cashregister", "Carthorse", "radishes"}, {"Carthorse"}],
-    // detects anagrams using case-insensitive subject
-    ["Orchestra", {"cashregister", "carthorse", "radishes"}, {"carthorse"}],
-    // detects anagrams using case-insensitive possible matches
-    ["orchestra", {"cashregister", "Carthorse", "radishes"}, {"Carthorse"}],
-    // does not detect a word as its own anagram
-    ["banana", {"Banana"}, {}],
-    // does not detect a anagram if the original word is repeated
-    ["go", {"go Go GO"}, {}],
-    // anagrams must use all letters exactly once
-    ["tapper", {"patter"}, {}],
-    // capital word is not own anagram
-    ["BANANA", {"Banana"}, {}]
-  };
+{[String, {String*}, {String*}]*} cases => {
+  // no matches
+  ["diaper", {"hello", "world", "zombies", "pants"}, {}],
+  // detects simple anagram
+  ["ant", {"tan", "stand", "at"}, {"tan"}],
+  // does not detect false positives
+  ["galea", {"eagle"}, {}],
+  // detects multiple anagrams
+  ["master", {"stream", "pigeon", "maters"}, {"stream", "maters"}],
+  // does not detect anagram subsets
+  ["good", {"dog", "goody"}, {}],
+  // detects anagram
+  ["listen", {"enlists", "google", "inlets", "banana"}, {"inlets"}],
+  // detects multiple anagrams
+  [
+    "allergy",
+    {"gallery", "ballerina", "regally", "clergy", "largely", "leading"},
+    {"gallery", "regally", "largely"}
+  ],
+  // does not detect identical words
+  ["corn", {"corn", "dark", "Corn", "rank", "CORN", "cron", "park"}, {"cron"}],
+  // does not detect non-anagrams with identical checksum
+  ["mass", {"last"}, {}],
+  // detects anagrams case-insensitively
+  ["Orchestra", {"cashregister", "Carthorse", "radishes"}, {"Carthorse"}],
+  // detects anagrams using case-insensitive subject
+  ["Orchestra", {"cashregister", "carthorse", "radishes"}, {"carthorse"}],
+  // detects anagrams using case-insensitive possible matches
+  ["orchestra", {"cashregister", "Carthorse", "radishes"}, {"Carthorse"}],
+  // does not detect a word as its own anagram
+  ["banana", {"Banana"}, {}],
+  // does not detect a anagram if the original word is repeated
+  ["go", {"go Go GO"}, {}],
+  // anagrams must use all letters exactly once
+  ["tapper", {"patter"}, {}],
+  // capital word is not own anagram
+  ["BANANA", {"Banana"}, {}]
+};
 
 test
 parameters(`value cases`)

data/tracks/ceylon/exercises/bracket-push/source/bracketpush/BracketsTest.ceylon

@@ -1,34 +1,33 @@
 import ceylon.test { ... }
 
-{[String, Boolean]*} cases =>
-  {
-    // paired square brackets
-    ["[]", true],
-    // empty string
-    ["", true],
-    // unpaired brackets
-    ["[[", false],
-    // wrong ordered brackets
-    ["}{", false],
-    // paired with whitespace
-    ["{ }", true],
-    // simple nested brackets
-    ["{[]}", true],
-    // several paired brackets
-    ["{}[]", true],
-    // paired and nested brackets
-    ["([{}({}[])])", true],
-    // unopened closing brackets
-    ["{[)][]}", false],
-    // unpaired and nested brackets
-    ["([{])", false],
-    // paired and wrong nested brackets
-    ["[({]})", false],
-    // math expression
-    ["(((185 + 223.85) * 15) - 543)/2", true],
-    // complex latex expression
-    ["\\left(\\begin{array}{cc} \\frac{1}{3} & x\\\\ \\mathrm{e}^{x} &... x^2 \\end{array}\\right)", true]
-  };
+{[String, Boolean]*} cases => {
+  // paired square brackets
+  ["[]", true],
+  // empty string
+  ["", true],
+  // unpaired brackets
+  ["[[", false],
+  // wrong ordered brackets
+  ["}{", false],
+  // paired with whitespace
+  ["{ }", true],
+  // simple nested brackets
+  ["{[]}", true],
+  // several paired brackets
+  ["{}[]", true],
+  // paired and nested brackets
+  ["([{}({}[])])", true],
+  // unopened closing brackets
+  ["{[)][]}", false],
+  // unpaired and nested brackets
+  ["([{])", false],
+  // paired and wrong nested brackets
+  ["[({]})", false],
+  // math expression
+  ["(((185 + 223.85) * 15) - 543)/2", true],
+  // complex latex expression
+  ["\\left(\\begin{array}{cc} \\frac{1}{3} & x\\\\ \\mathrm{e}^{x} &... x^2 \\end{array}\\right)", true]
+};
 
 test
 parameters(`value cases`)

data/tracks/ceylon/exercises/largest-series-product/example/Series.ceylon

@@ -0,0 +1,13 @@
+class Error() {}
+
+Integer|Error largestProduct(String digits, Integer window) {
+  if (window < 0 || window > digits.size) {
+    return Error();
+  }
+  value parsed = [for (d in digits) if (('0'..'9').contains(d)) d.integer - '0'.integer];
+  if (parsed.size < digits.size) {
+    return Error();
+  }
+  value ranges = {for (i in 0..(digits.size - window)) parsed[i:window]};
+  return max({for (r in ranges) r.fold(1)((acc, e) => acc * e)});
+}

data/tracks/ceylon/exercises/largest-series-product/source/largestseriesproduct/Series.ceylon

@@ -0,0 +1,5 @@
+class Error() {}
+
+Integer|Error largestProduct(String digits, Integer window) {
+  return nothing;
+}

data/tracks/ceylon/exercises/largest-series-product/source/largestseriesproduct/SeriesTest.ceylon

@@ -0,0 +1,30 @@
+import ceylon.test { ... }
+
+{[String, Integer, Integer?]*} cases => {
+  ["29", 2, 18],
+  ["0123456789", 2, 72],
+  ["576802143", 2, 48],
+  ["0123456789", 3, 504],
+  ["1027839564", 3, 270],
+  ["0123456789", 5, 15120],
+  ["73167176531330624919225119674426574742355349194934", 6, 23520],
+  ["0000", 2, 0],
+  ["99099", 3, 0],
+  ["123", 4, null],
+  ["", 0, 1],
+  ["123", 0, 1],
+  ["", 1, null],
+  ["1234a5", 2, null],
+  ["12345", -1, null]
+};
+
+test
+parameters(`value cases`)
+void testLargestProduct(String digits, Integer window, Integer? expected) {
+  value result = largestProduct(digits, window);
+  if (exists expected) {
+    assertEquals(result, expected);
+  } else if (!is Error result) {
+    fail("should have errored, but got ``result``");
+  }
+}

data/tracks/ceylon/exercises/largest-series-product/source/largestseriesproduct/module.ceylon

@@ -0,0 +1,3 @@
+module largestseriesproduct "1.0" {
+  import "ceylon.test" "1.3.1";
+}

data/tracks/csharp/config.json

@@ -175,6 +175,13 @@
         "Classes"
       ]
     },
+    {
+      "slug": "error-handling",
+      "difficulty": 3,
+      "topics": [
+        "Exception handling"
+      ]
+    },
     {
       "slug": "kindergarten-garden",
       "difficulty": 3,
@@ -535,6 +542,15 @@
         "Algorithms",
         "Transforming"
       ]
+    },
+    {
+      "slug": "ledger",
+      "difficulty": 5,
+      "topics": [
+        "Globalization",
+        "Text formatting",
+        "Refactoring"
+      ]
     }, 
     {
       "slug": "custom-set",
@@ -543,6 +559,15 @@
         "Sets"
       ]
     },
+    {
+      "slug": "dot-dsl",
+      "difficulty": 5,
+      "topics": [
+        "Domain-specific languages",
+        "Classes",
+        "Equality"
+      ]
+    },
     {
       "slug": "ocr-numbers",
       "difficulty": 5,
@@ -715,6 +740,14 @@
         "Logic"
       ]
     },
+    {
+      "slug": "hangman",
+      "difficulty": 8,
+      "topics": [
+        "Reactive programming",
+        "Events"
+      ]
+    },
     {
       "slug": "diamond",
       "difficulty": 8,
@@ -780,6 +813,14 @@
         "Parsing",
         "Transforming"
       ]
+    },
+    {
+      "slug": "alphametics",
+      "difficulty": 10,
+      "topics": [
+        "Parsing",
+        "Dictionaries"
+      ]
     }
   ],
   "deprecated": [

data/tracks/csharp/exercises/alphametics/AlphameticsTest.cs

@@ -0,0 +1,122 @@
+using NUnit.Framework;
+using System.Collections.Generic;
+
+public class AlphameticsTest
+{
+    [Test]
+    public void Puzzle_with_three_letters()
+    {
+        var actual = Alphametics.Solve("I + BB == ILL");
+        var expected = new Dictionary<char, int>
+        {
+            ['I'] = 1,
+            ['B'] = 9,
+            ['L'] = 0
+        };
+        Assert.That(actual, Is.EqualTo(expected));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Solution_must_have_unique_value_for_each_letter()
+    {
+        Assert.That(() => Alphametics.Solve("A == B"), Throws.Exception);
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Leading_zero_solution_is_invalid()
+    {
+        Assert.That(() => Alphametics.Solve("ACA + DD == BD"), Throws.Exception);
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Puzzle_with_four_letters()
+    {
+        var actual = Alphametics.Solve("AS + A == MOM");
+        var expected = new Dictionary<char, int>
+        {
+            ['A'] = 9,
+            ['S'] = 2,
+            ['M'] = 1,            
+            ['O'] = 0
+        };
+        Assert.That(actual, Is.EqualTo(expected));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Puzzle_with_six_letters()
+    {
+        var actual = Alphametics.Solve("NO + NO + TOO == LATE");
+        var expected = new Dictionary<char, int>
+        {
+            ['N'] = 7,
+            ['O'] = 4,
+            ['T'] = 9,
+            ['L'] = 1,
+            ['A'] = 0,
+            ['E'] = 2
+        };
+        Assert.That(actual, Is.EqualTo(expected));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Puzzle_with_seven_letters()
+    {
+        var actual = Alphametics.Solve("HE + SEES + THE == LIGHT");
+        var expected = new Dictionary<char, int>
+        {
+            ['E'] = 4,
+            ['G'] = 2,
+            ['H'] = 5,
+            ['I'] = 0,
+            ['L'] = 1,
+            ['S'] = 9,
+            ['T'] = 7,
+        };
+        Assert.That(actual, Is.EqualTo(expected));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Puzzle_with_eight_letters()
+    {
+        var actual = Alphametics.Solve("SEND + MORE == MONEY");
+        var expected = new Dictionary<char, int>
+        {
+            ['S'] = 9,
+            ['E'] = 5,
+            ['N'] = 6,
+            ['D'] = 7,
+            ['M'] = 1,
+            ['O'] = 0,
+            ['R'] = 8,
+            ['Y'] = 2,
+        };
+        Assert.That(actual, Is.EqualTo(expected));
+    }
+
+    [Ignore("Remove to run test")]
+    [Test]
+    public void Puzzle_with_ten_letters()
+    {
+        var actual = Alphametics.Solve("AND + A + STRONG + OFFENSE + AS + A + GOOD == DEFENSE");
+        var expected = new Dictionary<char, int>
+        {
+            ['A'] = 5,
+            ['D'] = 3,
+            ['E'] = 4,
+            ['F'] = 7,
+            ['G'] = 8,
+            ['N'] = 0,
+            ['O'] = 2,
+            ['R'] = 1,
+            ['S'] = 6,
+            ['T'] = 9,
+        };
+        Assert.That(actual, Is.EqualTo(expected));
+    }
+}