trackler 2.2.1.137 → 2.2.1.138

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 60bf2574faa34a60a9794b94d789c9e73fb4cbe1
-  data.tar.gz: 40a8dc9eaba4aae1b7dacc47d7f7df71c2ad0ef5
+  metadata.gz: 904ea15d99f928d3a60c4a94f9f6f487b5c56bb4
+  data.tar.gz: 5e14581709b274c20adacd33233c8e268534c83e
 SHA512:
-  metadata.gz: 2f84292883fa84fe0e3531f411e790247ea3f405a2ac4073b19e2330952b6e088598c41f900d47c79bf7ebb3445b624f639fd11b3a660e60c08d829afe223d71
-  data.tar.gz: 62435ae5728a1ff10a08382ea7a11c43985d97f5842a33ea1b27923c43c2a90fba640ccd42e3f71228a7a5ab9b1cf3b253260d93537d8f8201b7150b83991925
+  metadata.gz: e02921838fab6c43ad19a3eabbf7d832e1e6f6568065420af7fa31484393f601d6e990af8eacf8093e5e3caf7885c07aa2436d2eb417977bcebc68f7cac0f2de
+  data.tar.gz: cb188e5c1cea7a4e79f2e8bc6af2561c7b4113cbeef75feab4921d475cb5d3315a20929ade4f705a9c6a51bb1974ec6959a365065e1f7aefd6ae780c4a9f4533

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.2.1.137"
+  VERSION = "2.2.1.138"
 end

data/problem-specifications/exercises/diffie-hellman/canonical-data.json

@@ -0,0 +1,72 @@
+{
+  "exercise": "diffie-hellman",
+  "version": "1.0.0",
+  "comments": [
+    "Optional tests to consider:",
+    "* Validation of parameters:",
+    "  Validate that `p`, `g` are valid.",
+    "  Validate that keys given as inputs are valid.",
+    "  Resources that show what happens if parameters are not validated:",
+    "  http://cryptopals.com/sets/5/challenges/34",
+    "  http://cryptopals.com/sets/5/challenges/35",
+    "* Large numbers:",
+    "  Although the calculations fundamentally do not require large numbers,",
+    "  this is a reasonable real-world use for them",
+    "  and it may be instructive to have an exercise on their use.",
+    "  Consult tracks with this exercise (such as the Go track) for possible inputs to use."
+  ],
+  "cases": [
+    {
+      "description": "private key is in range 1 .. p",
+      "property": "privateKeyIsInRange",
+      "input": {},
+      "expected": {
+        "greaterThan": 1,
+        "lessThan": "p"
+      }
+    },
+    {
+      "description": "private key is random",
+      "property": "privateKeyIsRandom",
+      "input": {},
+      "expected": {
+        "random": true
+      }
+    },
+    {
+      "description": "can calculate public key using private key",
+      "property": "publicKey",
+      "input": {
+        "p": 23,
+        "g": 5,
+        "privateKey": 6
+      },
+      "expected": 8
+    },
+    {
+      "description": "can calculate secret using other party's public key",
+      "property": "secret",
+      "input": {
+        "p": 23,
+        "theirPublicKey": 19,
+        "myPrivateKey": 6
+      },
+      "expected": 2
+    },
+    {
+      "description": "key exchange",
+      "property": "keyExchange",
+      "input": {
+        "p": 23,
+        "g": 5,
+        "alicePrivateKey": "privateKey(p)",
+        "bobPrivateKey": "privateKey(p)",
+        "alicePublicKey": "publicKey(p, g, alicePrivateKey)",
+        "bobPublicKey": "publicKey(p, g, bobPrivateKey)",
+        "secretA": "secret(p, bobPublicKey, alicePrivateKey)",
+        "secretB": "secret(p, alicePublicKey, bobPrivateKey)"
+      },
+      "expected": "secretA == secretB"
+    }
+  ]
+}

data/problem-specifications/exercises/yacht/description.md

@@ -17,7 +17,7 @@ category chosen.
     Sixes           6 × number of sixes     2 3 4 5 6 scores 6
     Full House      Total of the dice       3 3 3 5 5 scores 19
     Four of a Kind  Total of the four dice  4 4 4 4 6 scores 16
-    Little Straight 30 points               1 2 3 4 5 scores 30 
+    Little Straight 30 points               1 2 3 4 5 scores 30
     Big Straight    30 points               2 3 4 5 6 scores 30
     Choice          Sum of the dice         2 3 3 4 6 scores 18
     Yacht           50 points               4 4 4 4 4 scores 50
@@ -26,7 +26,7 @@ If the dice do not satisfy the requirements of a category, the score is zero.
 If, for example, *Four Of A Kind* is entered in the *Yacht* category, zero
 points are scored. A *Yacht* scores zero if entered in the *Full House* category.
 
-## Task 
+## Task
 Given a list of values for five dice and a category, your solution should return
 the score of the dice for that category. If the dice do not satisfy the requirements
 of the category your solution should return 0. You can assume that five values

data/tracks/csharp/exercises/sgf-parsing/Example.cs

@@ -17,7 +17,7 @@ public SgfTree(IDictionary<string, string[]> data, params SgfTree[] children)
 
 public static class SgfParser
 {
-    private static char Unescape(char c) => c == 'n' || c == 'r' || c == 't' ? ' ' : c;
+    private static char Unescape(char c) => c == 'n' ? '\n' : c == 'r' || c == 't' ? ' ' : c;
     private static string ToString(IEnumerable<char> chars) => new string(chars.ToArray());
 
     private static readonly Parser<char> NormalChar = Parse.Char(c => c != '\\' && c != ']', "Normal char");

data/tracks/csharp/exercises/sgf-parsing/SgfParsingTest.cs

@@ -112,7 +112,7 @@ public void Multiple_properties()
     public void Escaped_property()
     {
         const string input = @"(;A[\]b\nc\nd\t\te \n\]])";
-        var expected = TreeWithNoChildren(CreateData("A", @"]b c d  e  ]"));
+        var expected = TreeWithNoChildren(CreateData("A", "]b\nc\nd  e \n]"));
         Assert.Equal(expected, SgfParser.ParseTree(input), SgfTreeEqualityComparer.Instance);
     }
 

data/tracks/csharp/exercises/sublist/SublistTest.cs

@@ -1,150 +1,109 @@
-using System.Collections.Generic;
-using System.Linq;
+// This file was auto-generated based on version 1.1.0 of the canonical data.
+
 using Xunit;
+using System.Collections.Generic;
 
 public class SublistTest
 {
     [Fact]
-    public void Empty_equals_empty()
+    public void Empty_lists()
     {
-        var list1 = new List<int>();
-        var list2 = new List<int>();
-        Assert.Equal(SublistType.Equal, Sublist.Classify(list1, list2));
+        Assert.Equal(SublistType.Equal, Sublist.Classify(new List<int>() { }, new List<int>() { }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Empty_is_a_sublist_of_anything()
+    public void Empty_list_within_non_empty_list()
     {
-        var list1 = new List<int>();
-        var list2 = new List<int> { 1, 2, 3, 4 };
-        Assert.Equal(SublistType.Sublist, Sublist.Classify(list1, list2));
+        Assert.Equal(SublistType.Sublist, Sublist.Classify(new List<int>() { }, new List<int>() { 1, 2, 3 }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Anything_is_a_superlist_of_empty()
+    public void Non_empty_list_contains_empty_list()
     {
-        var list1 = new List<int> { 1, 2, 3, 4 };
-        var list2 = new List<int>();
-        Assert.Equal(SublistType.Superlist, Sublist.Classify(list1, list2));
+        Assert.Equal(SublistType.Superlist, Sublist.Classify(new List<int>() { 1, 2, 3 }, new List<int>() { }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void One_is_not_two()
+    public void List_equals_itself()
     {
-        var list1 = new List<int> { 1 };
-        var list2 = new List<int> { 2 };
-        Assert.Equal(SublistType.Unequal, Sublist.Classify(list1, list2));
+        Assert.Equal(SublistType.Equal, Sublist.Classify(new List<int>() { 1, 2, 3 }, new List<int>() { 1, 2, 3 }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Compare_larger_equal_lists()
+    public void Different_lists()
     {
-        var list1 = new List<char>(Enumerable.Repeat('x', 1000));
-        var list2 = new List<char>(Enumerable.Repeat('x', 1000));
-        Assert.Equal(SublistType.Equal, Sublist.Classify(list1, list2));
+        Assert.Equal(SublistType.Unequal, Sublist.Classify(new List<int>() { 1, 2, 3 }, new List<int>() { 2, 3, 4 }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Sublist_at_start()
+    public void False_start()
     {
-        var list1 = new List<int> { 1, 2, 3 };
-        var list2 = new List<int> { 1, 2, 3, 4, 5 };
-        Assert.Equal(SublistType.Sublist, Sublist.Classify(list1, list2));
+        Assert.Equal(SublistType.Sublist, Sublist.Classify(new List<int>() { 1, 2, 5 }, new List<int>() { 0, 1, 2, 3, 1, 2, 5, 6 }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Sublist_in_middle()
+    public void Consecutive()
     {
-        var list1 = new List<int> { 4, 3, 2 };
-        var list2 = new List<int> { 5, 4, 3, 2, 1 };
-        Assert.Equal(SublistType.Sublist, Sublist.Classify(list1, list2));
+        Assert.Equal(SublistType.Sublist, Sublist.Classify(new List<int>() { 1, 1, 2 }, new List<int>() { 0, 1, 1, 1, 2, 1, 2 }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Sublist_at_end()
-    {
-        var list1 = new List<int> { 3, 4, 5 };
-        var list2 = new List<int> { 1, 2, 3, 4, 5 };
-        Assert.Equal(SublistType.Sublist, Sublist.Classify(list1, list2));
-    }
-
-    [Fact(Skip = "Remove to run test")]
-    public void Partially_matching_sublist_at_start()
+    public void Sublist_at_start()
     {
-        var list1 = new List<int> { 1, 1, 2 };
-        var list2 = new List<int> { 1, 1, 1, 2 };
-        Assert.Equal(SublistType.Sublist, Sublist.Classify(list1, list2));
+        Assert.Equal(SublistType.Sublist, Sublist.Classify(new List<int>() { 0, 1, 2 }, new List<int>() { 0, 1, 2, 3, 4, 5 }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Sublist_early_in_huge_list()
+    public void Sublist_in_middle()
     {
-        var list1 = new List<int> { 3, 4, 5 };
-        var list2 = new List<int>(Enumerable.Range(1, 1000000));
-        Assert.Equal(SublistType.Sublist, Sublist.Classify(list1, list2));
+        Assert.Equal(SublistType.Sublist, Sublist.Classify(new List<int>() { 2, 3, 4 }, new List<int>() { 0, 1, 2, 3, 4, 5 }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Huge_sublist_not_in_huge_list()
+    public void Sublist_at_end()
     {
-        var list1 = new List<int>(Enumerable.Range(10, 1000001));
-        var list2 = new List<int>(Enumerable.Range(1, 1000000));
-        Assert.Equal(SublistType.Unequal, Sublist.Classify(list1, list2));
+        Assert.Equal(SublistType.Sublist, Sublist.Classify(new List<int>() { 3, 4, 5 }, new List<int>() { 0, 1, 2, 3, 4, 5 }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Superlist_at_start()
+    public void At_start_of_superlist()
     {
-        var list1 = new List<int> { 1, 2, 3, 4, 5 };
-        var list2 = new List<int> { 1, 2, 3 };
-        Assert.Equal(SublistType.Superlist, Sublist.Classify(list1, list2));
+        Assert.Equal(SublistType.Superlist, Sublist.Classify(new List<int>() { 0, 1, 2, 3, 4, 5 }, new List<int>() { 0, 1, 2 }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Superlist_in_middle()
+    public void In_middle_of_superlist()
     {
-        var list1 = new List<int> { 5, 4, 3, 2, 1 };
-        var list2 = new List<int> { 4, 3, 2 };
-        Assert.Equal(SublistType.Superlist, Sublist.Classify(list1, list2));
+        Assert.Equal(SublistType.Superlist, Sublist.Classify(new List<int>() { 0, 1, 2, 3, 4, 5 }, new List<int>() { 2, 3 }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Superlist_at_end()
+    public void At_end_of_superlist()
     {
-        var list1 = new List<int> { 1, 2, 3, 4, 5 };
-        var list2 = new List<int> { 3, 4, 5 };
-        Assert.Equal(SublistType.Superlist, Sublist.Classify(list1, list2));
+        Assert.Equal(SublistType.Superlist, Sublist.Classify(new List<int>() { 0, 1, 2, 3, 4, 5 }, new List<int>() { 3, 4, 5 }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Partially_matching_superlist_at_start()
+    public void First_list_missing_element_from_second_list()
     {
-        var list1 = new List<int> { 1, 1, 1, 2 };
-        var list2 = new List<int> { 1, 1, 2 };
-        Assert.Equal(SublistType.Superlist, Sublist.Classify(list1, list2));
+        Assert.Equal(SublistType.Unequal, Sublist.Classify(new List<int>() { 1, 3 }, new List<int>() { 1, 2, 3 }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Superlist_early_in_huge_list()
+    public void Second_list_missing_element_from_first_list()
     {
-        var list1 = new List<int>(Enumerable.Range(1, 1000000));
-        var list2 = new List<int> { 3, 4, 5 };
-        Assert.Equal(SublistType.Superlist, Sublist.Classify(list1, list2));
+        Assert.Equal(SublistType.Unequal, Sublist.Classify(new List<int>() { 1, 2, 3 }, new List<int>() { 1, 3 }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Recurring_values_sublist()
+    public void Order_matters_to_a_list()
     {
-        var list1 = new List<int> { 1, 2, 1, 2, 3 };
-        var list2 = new List<int> { 1, 2, 3, 1, 2, 1, 2, 3, 2, 1 };
-        Assert.Equal(SublistType.Sublist, Sublist.Classify(list1, list2));
+        Assert.Equal(SublistType.Unequal, Sublist.Classify(new List<int>() { 1, 2, 3 }, new List<int>() { 3, 2, 1 }));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void Recurring_values_unequal()
+    public void Same_digits_but_different_numbers()
     {
-        var list1 = new List<int> { 1, 2, 1, 2, 3 };
-        var list2 = new List<int> { 1, 2, 3, 1, 2, 3, 2, 3, 2, 1 };
-        Assert.Equal(SublistType.Unequal, Sublist.Classify(list1, list2));
+        Assert.Equal(SublistType.Unequal, Sublist.Classify(new List<int>() { 1, 0, 1 }, new List<int>() { 10, 1 }));
     }
 }

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

@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using Generators.Input;
+using Generators.Output;
+using Humanizer;
+
+namespace Generators.Exercises
+{
+    public class Sublist : GeneratorExercise
+    {
+        protected override HashSet<string> AddAdditionalNamespaces() => new HashSet<string>() { typeof(IList<int>).Namespace };
+
+        private UnescapedValue InputValues(int[] list)
+        {
+            var template = (list != null) ? string.Join(", ", Array.ConvertAll<int, string>(list, (x) => { return $"{x}"; })) : "";
+            return new UnescapedValue($"new List<int>() {{ {template} }}".Replace("  ", " "));
+        }
+        protected override void UpdateCanonicalData(CanonicalData canonicalData)
+        {
+            foreach (var canonicalDataCase in canonicalData.Cases)
+            {              
+                var input = canonicalDataCase.Properties["input"] as Dictionary<string, object>;
+                input["listOne"] = InputValues(input["listOne"] as int[]);
+                input["listTwo"] = InputValues(input["listTwo"] as int[]);
+
+                canonicalDataCase.Property = "classify";
+                canonicalDataCase.Properties["expected"] = new UnescapedValue($"SublistType.{(canonicalDataCase.Properties["expected"] as string).Dehumanize()}");
+            }
+        }
+    }
+}
+

data/tracks/elisp/exercises/bob/README.md

@@ -6,6 +6,8 @@ Bob answers 'Sure.' if you ask him a question.
 
 He answers 'Whoa, chill out!' if you yell at him.
 
+He answers 'Calm down, I know what I'm doing!' if you yell a question at him.
+
 He says 'Fine. Be that way!' if you address him without actually saying
 anything.
 

data/tracks/elisp/exercises/bob/bob-test.el

@@ -1,43 +1,64 @@
 ;;; bob-test.el --- ERT tests for Bob (exercism)
 
 ;;; Commentary:
+;; Common test data version: 1.2.0 6dc2014
 
 ;;; Code:
 
 (load-file "bob.el")
 
 
-(ert-deftest responds-to-something ()
+(ert-deftest responds-to-stating-something ()
   (should (string= "Whatever." (response-for "Tom-ay-to, tom-aaaah-to."))))
 
-(ert-deftest responds-to-shouts ()
+(ert-deftest responds-to-shouting ()
   (should
    (string= "Whoa, chill out!" (response-for "WATCH OUT!"))))
 
-(ert-deftest responds-to-questions ()
+(ert-deftest responds-to-shouting-gibberish ()
+  (should
+   (string= "Whoa, chill out!" (response-for "FCECDFCAAB"))))
+
+(ert-deftest responds-to-asking-a-question ()
   (should
    (string= "Sure." (response-for "Does this cryogenic chamber make me look fat?"))))
 
-(ert-deftest responds-to-forceful-talking ()
+(ert-deftest responds-to-asking-a-numeric-question ()
   (should
-   (string= "Whatever." (response-for "Let's go make out behind the gym!"))))
+   (string= "Sure." (response-for "You are, what, like 15?"))))
 
-(ert-deftest responds-to-acronyms ()
+(ert-deftest responds-to-asking-gibberish ()
   (should
-   (string= "Whatever." (response-for "It's OK if you don't want to go to the DMV."))))
+   (string= "Sure." (response-for "fffbbcbeab?"))))
 
-(ert-deftest responds-to-forceful-questions ()
+(ert-deftest responds-to-talking-forcefully ()
   (should
-   (string= "Whoa, chill out!" (response-for "WHAT THE HELL WERE YOU THINKING?"))))
+   (string= "Whatever." (response-for "Let's go make out behind the gym!"))))
 
-(ert-deftest responds-to-shouting-with-special-chars ()
+(ert-deftest responds-to-using-acronyms-in-regular-speech ()
   (should
-   (string= "Whoa, chill out!" (response-for "ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!"))))
+   (string= "Whatever." (response-for "It's OK if you don't want to go to the DMV."))))
+
+(ert-deftest responds-to-forceful-question ()
+  (should
+   (string= "Calm down, I know what I'm doing!" (response-for "WHAT THE HELL WERE YOU THINKING?"))))
 
 (ert-deftest responds-to-shouting-numbers ()
   (should
    (string= "Whoa, chill out!" (response-for "1, 2, 3, GO!"))))
 
+(ert-deftest responds-to-only-numbers ()
+  (should
+   (string= "Whatever." (response-for "1, 2, 3"))))
+
+(ert-deftest responds-to-questions-with-only-numbers ()
+  (should
+   (string= "Sure." (response-for "4?"))))
+
+(ert-deftest responds-to-shouting-with-special-chars ()
+  (should
+   (string= "Whoa, chill out!" (response-for "ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!"))))
+
 (ert-deftest responds-to-shouting-with-no-exclamation-mark ()
   (should
    (string= "Whoa, chill out!" (response-for "I HATE YOU"))))
@@ -46,6 +67,14 @@
   (should
    (string= "Whatever." (response-for "Ending with ? means a question."))))
 
+(ert-deftest responds-to-non-letters-with-question ()
+  (should
+   (string= "Sure." (response-for ":) ?"))))
+
+(ert-deftest responds-to-prattling-on ()
+  (should
+   (string= "Sure." (response-for "Wait! Hang on. Are you going to be OK?"))))
+
 (ert-deftest responds-to-silence ()
   (should
    (string= "Fine. Be that way!" (response-for ""))))
@@ -54,13 +83,29 @@
   (should
    (string= "Fine. Be that way!" (response-for "    "))))
 
-(ert-deftest responds-to-only-numbers ()
+(ert-deftest responds-to-alternate-silence ()
   (should
-   (string= "Whatever." (response-for "1, 2, 3"))))
+   (string= "Fine. Be that way!" (response-for "\t\t\t\t\t\t\t\t\t\t"))))
 
-(ert-deftest responds-to-number-questions ()
+(ert-deftest responds-to-multiple-line-question ()
   (should
-   (string= "Sure." (response-for "4?"))))
+   (string= "Whatever." (response-for "\nDoes this cryogenic chamber make me look fat?\nno"))))
+
+(ert-deftest responds-to-starting-with-whitespace ()
+  (should
+   (string= "Whatever." (response-for "         hmmmmmmm..."))))
+
+(ert-deftest responds-to-ending-with-whitespace ()
+  (should
+   (string= "Sure." (response-for "Okay if like my  spacebar  quite a bit?   "))))
+
+(ert-deftest responds-to-other-whitespace ()
+  (should
+   (string= "Fine. Be that way!" (response-for "\n\r \t"))))
+
+(ert-deftest responds-to-non-question-ending-with-whitespace ()
+  (should
+   (string= "Whatever." (response-for "This is a statement ending with whitespace      "))))
 
 (provide 'bob-test)
 ;;;bob-test.el ends here