trackler 2.2.1.155 → 2.2.1.156

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 13a1a8a03a329b636cf83ebd78d896e2756b1281
-  data.tar.gz: 9a361980610d8be7d89a029ac726db23790694ee
+  metadata.gz: 9be9297151cb81a1a1f348f7fecda5fb043f0cba
+  data.tar.gz: b71394646b1a1ff43954c04fa98f94843b04f7bb
 SHA512:
-  metadata.gz: '058d36c01fb55f20184bc1b494f35965b889a662ba630be8e3cea926ec1a730c43359c1d7a66c67f7b8f9d87f49d48bc2f23b0f3494acbf41da8e3d97619efd0'
-  data.tar.gz: e2b61bc234a7c607d8f4336fdfb2754035a07e1f0f8c3735940a11d1876734d0a2fea984108d6e618a01f45cd4298b88aa9e934ff5c2aab493d5e30e0e722cfa
+  metadata.gz: 62f2aa2dee62bac25a506f182562ef2615953f20ac0c333d666909d773a10da3ab2c00a2dd6458e872d2d457fb699eb612ba95ee25ae2fe59c879e0f8862d5ed
+  data.tar.gz: 322eeb246ff474e163fedcdcb1d9903ac974a62a7cacbb6d97b440af044d3c845167aa4fefbd240fc3b90c57f5676fe4a2419524d6b210843487b3bbf05d52c7

data/.gitmodules

@@ -175,3 +175,6 @@
 [submodule "tracks/cfml"]
 	path = tracks/cfml
 	url = https://github.com/exercism/cfml
+[submodule "tracks/reasonml"]
+	path = tracks/reasonml
+	url = https://github.com/exercism/reasonml

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.2.1.155"
+  VERSION = "2.2.1.156"
 end

data/problem-specifications/exercises/simple-cipher/canonical-data.json

@@ -0,0 +1,147 @@
+{
+  "exercise": "simple-cipher",
+  "version": "1.0.0",
+  "comments":
+    ["Some of the strings used in this file are symbolic and do not represent their literal value. They are:",
+      "cipher.key - Represents the Cipher key",
+      "cipher.encode - Represents the output of the Cipher encode method",
+      "new - Represents the Cipher initialization"],
+  "cases": [
+    {
+      "description": "Random key cipher",
+      "cases": [
+        {
+          "description": "Can encode",
+          "property": "encode",
+          "input": {
+            "plaintext": "aaaaaaaaaa"
+          },
+          "expected": "cipher.key"
+        },
+        {
+          "description": "Can decode",
+          "property": "decode",
+          "input": {
+            "ciphertext": "cipher.key"
+          },
+          "expected": "aaaaaaaaaa"
+        },
+        {
+          "description": "Is reversible. I.e., if you apply decode in a encoded result, you must see the same plaintext encode parameter as a result of the decode method",
+          "property": "decode",
+          "input": {
+            "plaintext": "abcdefghij",
+            "ciphertext": "cipher.encode"
+          },
+          "expected": "abcdefghij"
+        },
+        {
+          "description": "Key is made only of lowercase letters",
+          "property": "key",
+          "input": {},
+          "expected": {
+            "match": "^[a-z]+$"
+          }
+        }
+      ]
+    },
+    {
+      "description": "Substitution cipher",
+      "cases": [
+        {
+          "description": "Can encode",
+          "property": "encode",
+          "input": {
+            "key": "abcdefghij",
+            "plaintext": "aaaaaaaaaa"
+          },
+          "expected": "abcdefghij"
+        },
+        {
+          "description": "Can decode",
+          "property": "decode",
+          "input": {
+            "key": "abcdefghij",
+            "ciphertext": "abcdefghij"
+          },
+          "expected": "aaaaaaaaaa"
+        },
+        {
+          "description": "Is reversible. I.e., if you apply decode in a encoded result, you must see the same plaintext encode parameter as a result of the decode method",
+          "property": "decode",
+          "input": {
+            "key": "abcdefghij",
+            "plaintext": "abcdefghij",
+            "ciphertext": "cipher.encode"
+          },
+          "expected": "abcdefghij"
+        },
+        {
+          "description": "Can double shift encode",
+          "property": "encode",
+          "input": {
+            "key": "iamapandabear",
+            "plaintext": "iamapandabear"
+          },
+          "expected": "qayaeaagaciai"
+        },
+        {
+          "description": "Can wrap on encode", 
+          "property": "encode",
+          "input": {
+            "key": "abcdefghij",
+            "plaintext": "zzzzzzzzzz"
+          },
+          "expected": "zabcdefghi"
+        },
+        {
+          "description": "Can wrap on decode",
+          "property": "decode",
+          "input": {
+            "key": "abcdefghij",
+            "ciphertext": "zabcdefghi"
+          },
+          "expected": "zzzzzzzzzz"
+        },
+        {
+          "description": "Can handle messages longer than the key",
+          "property": "encode",
+          "input": {
+            "key": "abc",
+            "plaintext": "iamapandabear"
+          },
+          "expected": "iboaqcnecbfcr"
+        }
+      ]
+    },
+    {
+      "description": "Incorrect key cipher",
+      "cases": [
+        {
+          "description": "Throws an error with an all uppercase key",
+          "property": "new",
+          "input": {
+            "key": "ABCDEF"
+          },
+          "expected": { "error": "Bad key" }
+        },
+        {
+          "description": "Throws an error with a numeric key",
+          "property": "new",
+          "input": {
+            "key": "12345"
+          },
+          "expected": { "error": "Bad key" }
+        },
+        {
+          "description": "Throws an error with empty key",
+          "property": "new",
+          "input": {
+            "key": ""
+          },
+          "expected": { "error": "Bad key" }
+        }
+      ]
+    }
+  ]
+}

data/tracks/clojure/exercises/hexadecimal/src/hexadecimal.clj

@@ -0,0 +1,5 @@
+(ns hexadecimal)
+
+(defn hex-to-int [] ;; <- arglist goes here
+  ;; your code goes here
+  )

data/tracks/clojure/exercises/isogram/src/isogram.clj

@@ -0,0 +1,5 @@
+(ns isogram)
+
+(defn isogram? [] ;; <- arglist goes here
+  ;; your code goes here
+  )

data/tracks/clojure/exercises/kindergarten-garden/src/kindergarten-garden.clj

@@ -0,0 +1,5 @@
+(ns kindergarten-garden)
+
+(defn garden [] ;; <- arglist goes here
+  ;; your code goes here
+  )

data/tracks/csharp/exercises/list-ops/Example.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 
@@ -14,25 +15,25 @@ private static List<T> Cons<T>(T x, List<T> input)
 
     public static int Length<T>(List<T> input)
     {
-        return Foldl((acc, x) => acc + 1, 0, input);
+        return Foldl(input, 0, (acc, x) => acc + 1);
     }
 
     public static List<T> Reverse<T>(List<T> input)
     {
-        return Foldl((acc, x) => Cons(x, acc), new List<T>(), input);
+        return Foldl(input, new List<T>(), (acc, x) => Cons(x, acc));
     }
 
-    public static List<TOut> Map<TIn, TOut>(Func<TIn, TOut> map, List<TIn> input)
+    public static List<TOut> Map<TIn, TOut>(List<TIn> input, Func<TIn, TOut> map)
     {
-        return Foldr((x, acc) => Cons(map(x), acc), new List<TOut>(), input);
+        return Foldr(input, new List<TOut>(), (x, acc) => Cons(map(x), acc));
     }
 
-    public static List<T> Filter<T>(Func<T, bool> predicate, List<T> input)
+    public static List<T> Filter<T>(List<T> input, Func<T, bool> predicate)
     {
-        return Foldr((x, acc) => predicate(x) ? Cons(x, acc) : acc, new List<T>(), input);
+        return Foldr(input, new List<T>(), (x, acc) => predicate(x) ? Cons(x, acc) : acc);
     }
 
-    public static TOut Foldl<TIn, TOut>(Func<TOut, TIn, TOut> func, TOut start, List<TIn> input)
+    public static TOut Foldl<TIn, TOut>(List<TIn> input, TOut start, Func<TOut, TIn, TOut> func)
     {
         var acc = start;
 
@@ -42,7 +43,7 @@ public static List<T> Filter<T>(Func<T, bool> predicate, List<T> input)
         return acc;
     }
 
-    public static TOut Foldr<TIn, TOut>(Func<TIn, TOut, TOut> func, TOut start, List<TIn> input)
+    public static TOut Foldr<TIn, TOut>(List<TIn> input, TOut start, Func<TIn, TOut, TOut> func)
     {
         var acc = start;
 
@@ -57,7 +58,11 @@ public static List<T> Concat<T>(List<List<T>> input)
         var concatenated = new List<T>();
 
         foreach (var list in input)
-            concatenated = Append(concatenated, list);
+        {
+            if (list is List<T> sublist)
+                concatenated = Append(concatenated, sublist);
+        }
+            
 
         return concatenated;
     }

data/tracks/csharp/exercises/list-ops/ListOps.cs

@@ -14,22 +14,22 @@ public static List<T> Reverse<T>(List<T> input)
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    public static List<TOut> Map<TIn, TOut>(Func<TIn, TOut> map, List<TIn> input)
+    public static List<TOut> Map<TIn, TOut>(List<TIn> input, Func<TIn, TOut> map)
     {
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    public static List<T> Filter<T>(Func<T, bool> predicate, List<T> input)
+    public static List<T> Filter<T>(List<T> input, Func<T, bool> predicate)
     {
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    public static TOut Foldl<TIn, TOut>(Func<TOut, TIn, TOut> func, TOut start, List<TIn> input)
+    public static TOut Foldl<TIn, TOut>(List<TIn> input, TOut start, Func<TOut, TIn, TOut> func)
     {
         throw new NotImplementedException("You need to implement this function.");
     }
 
-    public static TOut Foldr<TIn, TOut>(Func<TIn, TOut, TOut> func, TOut start, List<TIn> input)
+    public static TOut Foldr<TIn, TOut>(List<TIn> input, TOut start, Func<TIn, TOut, TOut> func)
     {
         throw new NotImplementedException("You need to implement this function.");
     }

data/tracks/csharp/exercises/list-ops/ListOpsTest.cs

@@ -1,172 +1,174 @@
-using System.Collections.Generic;
-using System.Linq;
+// This file was auto-generated based on version 2.3.0 of the canonical data.
+
 using Xunit;
+using System;
+using System.Collections.Generic;
 
 public class ListOpsTest
 {
-    private const int Big = 10000;
-    private static readonly List<int> BigList = Range(1, Big);
-    private static readonly List<int> EmptyList = new List<int>();
-
-    private static List<int> Range(int from, int until) => new List<int>(Enumerable.Range(from, (until - from) + 1));
-    private static bool Odd(int x) => x % 2 == 1;
-
-    private static List<T> Cons<T>(T x, List<T> input)
-    {
-        var list = new List<T>(input);
-        list.Insert(0, x);
-
-        return list;
-    }
-
     [Fact]
-    public void LengthOfEmptyList()
-    {
-        Assert.Equal(0, ListOps.Length(EmptyList));
-    }
-
-    [Fact(Skip = "Remove to run test")]
-    public void LengthOfNonEmptyList()
-    {
-        Assert.Equal(4, ListOps.Length(Range(1, 4)));
-    }
-
-    [Fact(Skip = "Remove to run test")]
-    public void LengthOfLargeList()
-    {
-        Assert.Equal(Big, ListOps.Length(Range(1, Big)));
-    }
-
-    [Fact(Skip = "Remove to run test")]
-    public void ReverseOfEmptylist()
-    {
-        Assert.Equal(EmptyList, ListOps.Reverse(EmptyList));
-    }
-
-    [Fact(Skip = "Remove to run test")]
-    public void ReverseOfNonEmptyList()
+    public void Append_entries_to_a_list_and_return_the_new_list_empty_lists()
     {
-        Assert.Equal(Range(1, 100).OrderByDescending(x => x).ToList(), ListOps.Reverse(Range(1, 100)));
+        var list1 = new List<int>();
+        var list2 = new List<int>();
+        Assert.Empty(ListOps.Append(list1, list2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void MapOfEmptylist()
+    public void Append_entries_to_a_list_and_return_the_new_list_empty_list_to_list()
     {
-        Assert.Equal(EmptyList, ListOps.Map(x => x + 1, EmptyList));
+        var list1 = new List<int>();
+        var list2 = new List<int> { 1, 2, 3, 4 };
+        var expected = new List<int> { 1, 2, 3, 4 };
+        Assert.Equal(expected, ListOps.Append(list1, list2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void MapOfNonEmptyList()
+    public void Append_entries_to_a_list_and_return_the_new_list_non_empty_lists()
     {
-        Assert.Equal(new List<int> {2, 4, 6, 8}, ListOps.Map(x => x + 1, new List<int> {1, 3, 5, 7}));
+        var list1 = new List<int> { 1, 2 };
+        var list2 = new List<int> { 2, 3, 4, 5 };
+        var expected = new List<int> { 1, 2, 2, 3, 4, 5 };
+        Assert.Equal(expected, ListOps.Append(list1, list2));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void FilterOfEmptylist()
+    public void Concatenate_a_list_of_lists_empty_list()
     {
-        Assert.Equal(EmptyList, ListOps.Filter(x => true, EmptyList));
+        var lists = new List<List<int>>();
+        Assert.Empty(ListOps.Concat(lists));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void FilterOfNormalList()
+    public void Concatenate_a_list_of_lists_list_of_lists()
     {
-        Assert.Equal(new List<int> {1, 3}, ListOps.Filter(Odd, Range(1, 4)));
+        var lists = new List<List<int>> { new List<int> { 1, 2 }, new List<int> { 3 }, new List<int>(), new List<int> { 4, 5, 6 } };
+        var expected = new List<int> { 1, 2, 3, 4, 5, 6 };
+        Assert.Equal(expected, ListOps.Concat(lists));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void FoldlOfEmptylist()
+    public void Concatenate_a_list_of_lists_list_of_nested_lists()
     {
-        Assert.Equal(0, ListOps.Foldl((acc, x) => acc + x, 0, EmptyList));
+        var lists = new List<List<List<int>>> { new List<List<int>> { new List<int> { 1 }, new List<int> { 2 } }, new List<List<int>> { new List<int> { 3 } }, new List<List<int>> { new List<int>() }, new List<List<int>> { new List<int> { 4, 5, 6 } } };
+        var expected = new List<List<int>> { new List<int> { 1 }, new List<int> { 2 }, new List<int> { 3 }, new List<int>(), new List<int> { 4, 5, 6 } };
+        Assert.Equal(expected, ListOps.Concat(lists));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void FoldlOfNonEmptyList()
+    public void Filter_list_returning_only_values_that_satisfy_the_filter_function_empty_list()
     {
-        Assert.Equal(7, ListOps.Foldl((acc, x) => acc + x, -3, Range(1, 4)));
+        var list = new List<int>();
+        var function = new Func<int, bool>((x) => x % 2 == 1);
+        Assert.Empty(ListOps.Filter(list, function));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void FoldlOfHugeList()
+    public void Filter_list_returning_only_values_that_satisfy_the_filter_function_non_empty_list()
     {
-        Assert.Equal(Big * (Big + 1L) / 2L, ListOps.Foldl((acc, x) => acc + x, 0L, Range(1, Big)));
+        var list = new List<int> { 1, 2, 3, 5 };
+        var function = new Func<int, bool>((x) => x % 2 == 1);
+        var expected = new List<int> { 1, 3, 5 };
+        Assert.Equal(expected, ListOps.Filter(list, function));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void FoldlWithNonCommutativeFunction()
+    public void Returns_the_length_of_a_list_empty_list()
     {
-        Assert.Equal(0, ListOps.Foldl((acc, x) => acc - x, 10, Range(1, 4)));
+        var list = new List<int>();
+        Assert.Equal(0, ListOps.Length(list));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void FoldlIsNotJustFoldrFlip()
+    public void Returns_the_length_of_a_list_non_empty_list()
     {
-        Assert.Equal("fdsa", new string(ListOps.Foldl((acc, x) => Cons(x, acc), new List<char>(), "asdf".ToList()).ToArray()));
+        var list = new List<int> { 1, 2, 3, 4 };
+        Assert.Equal(4, ListOps.Length(list));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void FoldrAsId()
+    public void Return_a_list_of_elements_whose_values_equal_the_list_value_transformed_by_the_mapping_function_empty_list()
     {
-        Assert.Equal(BigList, ListOps.Foldr((x, acc) => Cons(x, acc), EmptyList, Range(1, Big)));
+        var list = new List<int>();
+        var function = new Func<int, int>((x) => x + 1);
+        Assert.Empty(ListOps.Map(list, function));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void FoldrAsAppend()
+    public void Return_a_list_of_elements_whose_values_equal_the_list_value_transformed_by_the_mapping_function_non_empty_list()
     {
-        Assert.Equal(BigList, ListOps.Foldr((x, acc) => Cons(x, acc), Range(100, Big), Range(1, 99)));
+        var list = new List<int> { 1, 3, 5, 7 };
+        var function = new Func<int, int>((x) => x + 1);
+        var expected = new List<int> { 2, 4, 6, 8 };
+        Assert.Equal(expected, ListOps.Map(list, function));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void AppendOfEmptylists()
+    public void Folds_reduces_the_given_list_from_the_left_with_a_function_empty_list()
     {
-        Assert.Equal(EmptyList, ListOps.Append(EmptyList, EmptyList));
+        var list = new List<int>();
+        var initial = 2;
+        var function = new Func<int, int, int>((x, y) => x * y);
+        Assert.Equal(2, ListOps.Foldl(list, initial, function));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void AppendOfEmptyAndNonEmptyLists()
+    public void Folds_reduces_the_given_list_from_the_left_with_a_function_direction_independent_function_applied_to_non_empty_list()
     {
-        Assert.Equal(Range(1, 4), ListOps.Append(EmptyList, Range(1, 4)));
+        var list = new List<int> { 1, 2, 3, 4 };
+        var initial = 5;
+        var function = new Func<int, int, int>((x, y) => x + y);
+        Assert.Equal(15, ListOps.Foldl(list, initial, function));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void AppendOfNonEmptyAndEmptyLists()
+    public void Folds_reduces_the_given_list_from_the_left_with_a_function_direction_dependent_function_applied_to_non_empty_list()
     {
-        Assert.Equal(Range(1, 4), ListOps.Append(Range(1, 4), EmptyList));
+        var list = new List<int> { 2, 5 };
+        var initial = 5;
+        var function = new Func<int, int, int>((x, y) => x / y);
+        Assert.Equal(0, ListOps.Foldl(list, initial, function));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void AppendOfNonEmptylists()
+    public void Folds_reduces_the_given_list_from_the_right_with_a_function_empty_list()
     {
-        Assert.Equal(Range(1, 5), ListOps.Append(Range(1, 3), new List<int> {4, 5}));
+        var list = new List<int>();
+        var initial = 2;
+        var function = new Func<int, int, int>((x, y) => x * y);
+        Assert.Equal(2, ListOps.Foldr(list, initial, function));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void AppendOfLargeLists()
+    public void Folds_reduces_the_given_list_from_the_right_with_a_function_direction_independent_function_applied_to_non_empty_list()
     {
-        Assert.Equal(BigList, ListOps.Append(Range(1, Big / 2), Range(1 + Big / 2, Big)));
+        var list = new List<int> { 1, 2, 3, 4 };
+        var initial = 5;
+        var function = new Func<int, int, int>((x, y) => x + y);
+        Assert.Equal(15, ListOps.Foldr(list, initial, function));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void ConcatOfNoLists()
+    public void Folds_reduces_the_given_list_from_the_right_with_a_function_direction_dependent_function_applied_to_non_empty_list()
     {
-        Assert.Equal(EmptyList, ListOps.Concat(new List<List<int>>()));
+        var list = new List<int> { 2, 5 };
+        var initial = 5;
+        var function = new Func<int, int, int>((x, y) => x / y);
+        Assert.Equal(2, ListOps.Foldr(list, initial, function));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void ConcatOfListOfLists()
+    public void Reverse_the_elements_of_the_list_empty_list()
     {
-        Assert.Equal(Range(1, 6),
-            ListOps.Concat(new List<List<int>>
-            {
-                new List<int> {1, 2},
-                new List<int> {3},
-                EmptyList,
-                new List<int> {4, 5, 6}
-            }));
+        var list = new List<int>();
+        Assert.Empty(ListOps.Reverse(list));
     }
 
     [Fact(Skip = "Remove to run test")]
-    public void ConcatOfLargeListOfSmallLists()
+    public void Reverse_the_elements_of_the_list_non_empty_list()
     {
-        Assert.Equal(BigList, ListOps.Concat(ListOps.Map(x => new List<int> {x}, Range(1, Big))));
+        var list = new List<int> { 1, 3, 5, 7 };
+        var expected = new List<int> { 7, 5, 3, 1 };
+        Assert.Equal(expected, ListOps.Reverse(list));
     }
 }