trackler 2.2.1.155 → 2.2.1.156

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

@@ -0,0 +1,107 @@
+using System;
+using System.Linq;
+using System.Text;
+using Generators.Output;
+using Humanizer;
+using Newtonsoft.Json.Linq;
+
+namespace Generators.Exercises
+{
+    public class Zipper : GeneratorExercise
+    {
+        protected override string RenderTestMethodBodyArrange(TestMethodBody testMethodBody)
+        {
+            var arrange = new StringBuilder();
+
+            var tree = RenderTree(testMethodBody.CanonicalDataCase.Input["initialTree"]);
+            arrange.AppendLine($"var tree = {tree};");
+            arrange.AppendLine("var sut = Zipper.FromTree(tree);");
+
+            var operations = RenderOperations(testMethodBody.CanonicalDataCase.Input["operations"]);
+            arrange.AppendLine($"var actual = sut{operations};");
+
+            return arrange.ToString();
+        }
+
+        protected override string RenderTestMethodBodyAssert(TestMethodBody testMethodBody)
+        {
+            var assert = new StringBuilder();
+
+            var expected = RenderExpected(testMethodBody.CanonicalDataCase.Expected);
+            if (expected == null)
+            {
+                assert.AppendLine("Assert.Null(actual);");
+            }
+            else
+            {
+                assert.AppendLine($"var expected = {expected};");
+                assert.AppendLine("Assert.Equal(expected, actual);");
+            }
+
+            return assert.ToString();
+        }
+
+        private static string RenderTree(dynamic tree)
+        {
+            if (tree == null)
+            {
+                return "null";
+            }
+
+            var value = tree["value"];
+            var left = tree["left"] == null ? "null" : RenderTree(tree["left"]);
+            var right = tree["right"] == null ? "null" : RenderTree(tree["right"]);
+
+            return $"new BinTree({value}, {left}, {right})";
+        }
+
+        private static string RenderOperations(dynamic operations)
+        {
+            if (operations.Length == 0)
+            {
+                return "";
+            }
+
+            return "." + string.Join(".", ((object[])operations).Select(RenderOperation));
+        }
+
+        private static string RenderOperation(dynamic operation)
+        {
+            var operationType = (string)operation["operation"];
+
+            switch (operationType)
+            {
+                case "set_value":
+                    return $"SetValue({operation["item"]})";
+                case "set_left":
+                    return $"SetLeft({RenderTree(operation["item"])})";
+                case "set_right":
+                    return $"SetRight({RenderTree(operation["item"])})";
+                default:
+                    return $"{operationType.Pascalize()}()";
+            }
+        }
+
+        private static string RenderExpected(dynamic expected)
+        {
+            switch (expected["type"])
+            {
+                case "int":
+                    return expected["value"].ToString();
+                case "zipper":
+                    if (expected.TryGetValue("value", out dynamic value) && value == null)
+                    {
+                        return null;
+                    }
+
+                    var tree = RenderTree(expected["initialTree"]);
+                    var operations = RenderOperations(expected["operations"]);
+                    return $"Zipper.FromTree({tree}){operations}";
+                case "tree":
+                    return RenderTree(expected["value"]);
+                default:
+                    throw new ArgumentException("Unknown expected type");
+            }
+        }
+    }
+}

data/tracks/csharp/generators/Output/ValueFormatter.cs

@@ -19,6 +19,8 @@ public static string Format(object val)
                 case char c: return c.Format();
                 case Enum enumeration: return enumeration.Format();
                 case Tuple<string, object> tuple: return tuple.Format();
+                case List<int> ints: return ints.Format();
+                case List<object> objects: return objects.Format();
                 case IEnumerable<int> ints: return ints.Format();
                 case IEnumerable<string> strings: return strings.Format();
                 case IEnumerable<UnescapedValue> unescapedValues when unescapedValues.Any(): return unescapedValues.Format();
@@ -30,6 +32,7 @@ public static string Format(object val)
                 case int[,] multidimensionalArray: return multidimensionalArray.Format();
                 case IEnumerable<ValueTuple<int, int>> tuples: return tuples.Format();
                 case IEnumerable<Tuple<string, object>> tuples: return tuples.Format();
+                case IEnumerable<object> objects: return objects.Format();
                 default: return val?.ToString();
             }
         }
@@ -71,6 +74,8 @@ public static string[] FormatVariable(object val, string name)
 
         private static string Format(this float flt) => flt.ToString(CultureInfo.InvariantCulture);
 
+        private static string Format(this int i) => i.ToString(CultureInfo.InvariantCulture);
+
         private static string Format(this ulong ulng) => $"{ulng}UL";
 
         private static string Format(this Enum @enumeration) =>
@@ -85,6 +90,15 @@ public static string[] FormatVariable(object val, string name)
         private static string Format(this IEnumerable<string> strings) =>
             strings.Any() ? $"new[] {{ {string.Join(", ", strings.Select(Format))} }}" : "new string[0]";
 
+        private static string Format(this IEnumerable<object> objects) =>
+            objects.Any() ? $"new[] {{ {string.Join(", ", objects.Select(Format))} }}" : "new object[0]";
+
+        private static string Format(this List<int> ints) =>
+            ints.Any() ? $"new List<int> {{ {string.Join(", ", ints.Select(Format))} }}" : "new List<int>()";
+
+        private static string Format(this List<object> objects) =>
+            objects.Any() ? $"new List<object> {{ {string.Join(", ", objects.Select(Format))} }}" : "new List<object>()";
+
         private static string Format(this IEnumerable<UnescapedValue> unescapedValues) =>
             $"new[] {{ {string.Join(", ", unescapedValues.Select(Format))} }}";
 

data/tracks/delphi/config.json

@@ -17,6 +17,7 @@
       "slug": "two-fer",
       "uuid": "60eb0882-495d-45f4-8d38-5b10d8851cf6",
       "core": false,
+      "unlocked_by": null,
       "difficulty": 1,
       "topics": [
         "optional_values",
@@ -48,6 +49,7 @@
       "slug": "leap",
       "uuid": "9e54a998-450c-4020-834e-eaa77f909744",
       "core": true,
+      "unlocked_by": null,
       "difficulty": 1,
       "topics": [
         "integers"
@@ -124,6 +126,7 @@
       "slug": "nucleotide-count",
       "uuid": "f2fae277-db73-482c-ac3a-496237ad5a42",
       "core": true,
+      "unlocked_by": null,
       "difficulty": 2,
       "topics": [
         "dictionaries",
@@ -256,6 +259,7 @@
       "slug": "clock",
       "uuid": "0223dfe4-3ff4-4f4e-8cd2-821e1fd50217",
       "core": true,
+      "unlocked_by": null,
       "difficulty": 3,
       "topics": [
         "structural_equality",
@@ -277,6 +281,7 @@
       "slug": "allergies",
       "uuid": "65214085-edfc-4ee7-a286-eca225b57ea3",
       "core": true,
+      "unlocked_by": null,
       "difficulty": 4,
       "topics": [
         "bitwise_operations",
@@ -287,6 +292,7 @@
       "slug": "saddle-points",
       "uuid": "78166582-6df9-4076-bd37-53230cd78f71",
       "core": true,
+      "unlocked_by": null,
       "difficulty": 4,
       "topics": [
         "arrays",
@@ -298,6 +304,7 @@
       "slug": "circular-buffer",
       "uuid": "f949b958-d2e0-4f21-a6db-12ba89f8ab57",
       "core": true,
+      "unlocked_by": null,
       "difficulty": 5,
       "topics": [
         "classes",
@@ -330,6 +337,7 @@
       "slug": "roman-numerals",
       "uuid": "51d6c5fc-6bde-4b78-842b-518346649431",
       "core": true,
+      "unlocked_by": null,
       "difficulty": 5,
       "topics": [
         "control_flow_loops",
@@ -362,6 +370,7 @@
       "slug": "book-store",
       "uuid": "d471f0d3-6d7c-4abe-bf31-712fb0cadea7",
       "core": true,
+      "unlocked_by": null,
       "difficulty": 6,
       "topics": [
         "arrays",
@@ -395,4 +404,4 @@
       ]
     }
   ]
-}
+}

data/tracks/delphi/config/maintainers.json

@@ -2,24 +2,24 @@
   "docs_url": "https://github.com/exercism/docs/blob/master/maintaining-a-track/maintainer-configuration.md",
   "maintainers": [
     {
-      "alumnus": false,
-      "avatar_url": null,
-      "bio": null,
       "github_username": "kotp",
+      "alumnus": false,
+      "show_on_website": false,
+      "name": null,
       "link_text": null,
       "link_url": null,
-      "name": null,
-      "show_on_website": false
+      "avatar_url": null,
+      "bio": null
     },
     {
-      "alumnus": false,
-      "avatar_url": null,
-      "bio": "I have been using Delphi professionally since 1996.  At my day job I develop software used in the control of various types of test machines used by the auto industry.  Exercism is my first real push into Open Source and I'm happy to have this opportunity to teach and share the virtues of Delphi with others.",
       "github_username": "rpottsoh",
+      "alumnus": false,
+      "show_on_website": true,
+      "name": "Ryan Potts",
       "link_text": null,
       "link_url": null,
-      "name": "Ryan Potts",
-      "show_on_website": true
+      "avatar_url": null,
+      "bio": "I have been using Delphi professionally since 1996.  At my day job I develop software used in the control of various types of test machines used by the auto industry.  Exercism is my first real push into Open Source and I'm happy to have this opportunity to teach and share the virtues of Delphi with others."
     }
   ]
-}
+}

data/tracks/elisp/config.json

@@ -192,6 +192,14 @@
       "topics": null,
       "unlocked_by": null,
       "uuid": "059141f0-f28d-4d10-a03a-7852dbfc2d2e"
+    },
+    {
+      "core": false,
+      "difficulty": 1,
+      "slug": "run-length-encoding",
+      "topics": null,
+      "unlocked_by": null,
+      "uuid": "9e8f98f0-6fff-4389-a9a2-9ae43edefa21"
     }
   ],
   "foregone": [],

data/tracks/elisp/exercises/run-length-encoding/README.md

@@ -0,0 +1,36 @@
+# Run Length Encoding
+
+Implement run-length encoding and decoding.
+
+Run-length encoding (RLE) is a simple form of data compression, where runs
+(consecutive data elements) are replaced by just one data value and count.
+
+For example we can represent the original 53 characters with only 13.
+
+```text
+"WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB"  ->  "12WB12W3B24WB"
+```
+
+RLE allows the original data to be perfectly reconstructed from
+the compressed data, which makes it a lossless data compression.
+
+```text
+"AABCCCDEEEE"  ->  "2AB3CD4E"  ->  "AABCCCDEEEE"
+```
+
+For simplicity, you can assume that the unencoded string will only contain
+the letters A through Z (either lower or upper case) and whitespace. This way
+data to be encoded will never contain any numbers and numbers inside data to
+be decoded always represent the count for the following character.
+
+## General help
+
+For more detailed information about running tests, code style and linting,
+please see the [help page](http://exercism.io/languages/clojure).
+
+## Source
+
+Wikipedia [https://en.wikipedia.org/wiki/Run-length_encoding](https://en.wikipedia.org/wiki/Run-length_encoding)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/elisp/exercises/run-length-encoding/example.el

@@ -0,0 +1,62 @@
+;;; run-length-encoding.el --- run-length-encoding Exercise (exercism)
+
+;;; Commentary:
+
+;;; Code:
+
+
+(defun run-length-group (s)
+  "return list of character run counts"
+  (let ((case-fold-search nil)
+	groups)
+    (with-temp-buffer
+      (insert s)
+      (goto-char (point-min))
+      (while (re-search-forward "\\(.\\)\\1*" nil t)
+	(push (cons
+	       (length (match-string 0))
+	       (match-string 1))
+	      groups)))
+    (nreverse groups)))
+
+;; (run-length-group "bbaaaac")
+
+
+(defun run-length-encode (s)
+  "encodes a string with run-length-encoding"
+  (mapconcat (lambda (v)
+	       (if (= (car v) 1)
+		   (cdr v)
+		 (format "%d%s" (car v) (cdr v))))
+	     (run-length-group s)
+	     ""))
+
+;; "2a3b4c" (run-length-encode "aabbbcccc")
+
+
+(defun run-length-parse (s)
+  "split string into pairs containing a count and a character"
+  (let (rtn)
+    (with-temp-buffer
+      (insert s)
+      (goto-char (point-min))
+      (while (re-search-forward "\\([0-9]*\\)\\(.\\)" nil t)
+	(push (cons
+	       (string-to-number (match-string 1))
+	       (string-to-char (match-string 2)))
+	      rtn)))
+    (nreverse rtn)))
+
+;; (run-length-parse "2a3b4cz")
+
+
+(defun run-length-decode (s)
+  "decodes a run-length-encoded string"
+  (mapconcat (lambda (n)
+	       (make-vector (if (= (car n) 0) 1 (car n)) (cdr n)))
+	     (run-length-parse s)
+	     ""))
+
+
+(provide 'run-length-encoding)
+;;; run-length-encoding.el ends here

data/tracks/elisp/exercises/run-length-encoding/run-length-encoding-test.el

@@ -0,0 +1,61 @@
+;;; run-length-encoding-test.el --- Tests for run-length-encoding (exercism)
+
+;;; Commentary:
+
+;;; Code:
+
+(load-file "run-length-encoding.el")
+
+(ert-deftest encode-empty-string ()
+  "encode an empty string"
+  (should (string= (run-length-encode "") "")))
+
+(ert-deftest encode-single-characters-without-count ()
+  "encode single characters without count"
+  (should (string= (run-length-encode "XYZ") "XYZ")))
+
+(ert-deftest encode-string-with-no-single-characters ()
+  "encode string with no single characters"
+  (should (string= (run-length-encode "AABBBCCCC") "2A3B4C")))
+
+(ert-deftest encode-string-with-single-and-mixed-characters ()
+  "encode string with single and mixed characters"
+  (should (string= (run-length-encode "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB") "12WB12W3B24WB")))
+
+(ert-deftest encode-multiple-whitespace ()
+  "encode string with whitespace characters mixed in it"
+  (should (string= (run-length-encode "  hsqq qww  ") "2 hs2q q2w2 ")))
+
+(ert-deftest encode-lowercase ()
+  "encode string with lowercase characters"
+  (should (string= (run-length-encode "aabbbcccc") "2a3b4c")))
+
+(ert-deftest decode-empty-string ()
+  "decode empty string"
+  (should (string= (run-length-decode "") "")))
+
+(ert-deftest decode-single-characters ()
+  "decode string with single characters only"
+  (should (string= (run-length-decode "XYZ") "XYZ")))
+
+(ert-deftest decode-no-single-characters ()
+  "decode string with no single characters"
+  (should (string= (run-length-decode "2A3B4C") "AABBBCCCC")))
+
+(ert-deftest decode-single-and-repeated-characters ()
+  "decode string with single and repeated characters"
+  (should (string= (run-length-decode "12WB12W3B24WB") "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB")))
+
+(ert-deftest decode-lowercase ()
+  "decode string with lowercase characters"
+  (should (string= (run-length-decode "2a3b4c") "aabbbcccc")))
+
+(ert-deftest decode-mixed-whitespace ()
+  "decode string with mixed whitespace characters in it"
+  (should (string= (run-length-decode "2 hs2q q2w2 ") "  hsqq qww  ")))
+
+(ert-deftest consistency ()
+  "Encode a string and then decode it. Should return the same one."
+  (should (string= (run-length-decode (run-length-encode "zzz ZZ  zZ")) "zzz ZZ  zZ")))
+
+;;; run-length-encoding-test.el ends here

data/tracks/elisp/exercises/run-length-encoding/run-length-encoding.el

@@ -0,0 +1,9 @@
+;;; run-length-encoding.el --- run-length-encoding Exercise (exercism)
+
+;;; Commentary:
+
+;;; Code:
+
+
+(provide 'run-length-encoding)
+;;; run-length-encoding.el ends here