trackler 2.0.6.10 → 2.0.6.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 953233b1b3c26056a61ba8b0155589068f8a106e
-  data.tar.gz: 8111432be32d72c9ee0b52448735add2f6a11333
+  metadata.gz: 80730bca62f82e148c9c102b1e1c19a0ab33cd53
+  data.tar.gz: ffa6a9582c1d94ee6e33ed0e2c1bc745b2ebb9cb
 SHA512:
-  metadata.gz: 0f3b82d836515898a1a27435d01d86748105835110af07ccd8d05a542a0735e24a7112b005cda5aed1e0dc7aa96cbf7daba2b212f44ac70b9225f021d3e7ba36
-  data.tar.gz: 49a6dc1f57ba27a0afa3af2260caf0d8cddcf49148566f893b2434c7dd44ba25ccc2efadd51d619193f5ee8d29e7f81443da39f89b34262d74791d4ae8a2488f
+  metadata.gz: 954c5a625d030d2892d93506fc9ad67c0117ad8cfedb037194e2cc8dcf9b4c6da18c6f2bd6c368a1ff1dec99afc61b0e20ad9582e9a00983508f231f47abc951
+  data.tar.gz: ad66f22ee9eadabfee064cdb40d83743165106f1f1ff080b3c4383eee26215ccec5895c43704940ddf05bd7f3171a0e22f4a5881833d1fe620085bf7af0cca3e

data/common/exercises/circular-buffer/canonical-data.json

@@ -0,0 +1,343 @@
+{
+  "#": [
+    "In general, these circular buffers are expected to be stateful,",
+    "and each language will operate on them differently.",
+    "Tests tend to perform a series of operations, some of which expect a certain result.",
+    "As such, this common test suite can only say in abstract terms what should be done.",
+    "",
+    "Tests will contain a number of operations. The operation will be specified in the `operation` key.",
+    "Based on the operation, other keys may be present.",
+    "read: Reading from the buffer should succeed if and only if `should_succeed` is true.",
+    "  If it should succeed, it should produce the item at `expected`. ",
+    "  If it should fail, `expected` will not be present. ",
+    "write: Writing the item located at `item` should succeed if and only if `should_succeed` is true.",
+    "overwrite: Write the item located at `item` into the buffer, removing the oldest item if necessary.",
+    "clear: Clear the buffer.",
+    "",
+    "Failure of either `read` or `write` may be indicated in a manner appropriate for your language:",
+    "Raising an exception, returning (int, error), returning Option<int>, etc.",
+    "",
+    "Finally, note that all values are integers.",
+    "If your language contains generics, you may consider allowing buffers to contain other types.",
+    "Tests for that are not included here.",
+    ""
+  ],
+  "cases": [
+    {
+      "description": "reading empty buffer should fail",
+      "capacity": 1,
+      "operations": [
+        {
+          "operation": "read",
+          "should_succeed": false
+        }
+      ]
+    },
+    {
+      "description": "can read an item just written",
+      "capacity": 1,
+      "operations": [
+        {
+          "operation": "write",
+          "item": 1,
+          "should_succeed": true
+        },
+        {
+          "operation": "read",
+          "should_succeed": true,
+          "expected": 1
+        }
+      ]
+    },
+    {
+      "description": "each item may only be read once",
+      "capacity": 1,
+      "operations": [
+        {
+          "operation": "write",
+          "item": 1,
+          "should_succeed": true
+        },
+        {
+          "operation": "read",
+          "should_succeed": true,
+          "expected": 1
+        },
+        {
+          "operation": "read",
+          "should_succeed": false
+        }
+      ]
+    },
+    {
+      "description": "items are read in the order they are written",
+      "capacity": 2,
+      "operations": [
+        {
+          "operation": "write",
+          "item": 1,
+          "should_succeed": true
+        },
+        {
+          "operation": "write",
+          "item": 2,
+          "should_succeed": true
+        },
+        {
+          "operation": "read",
+          "should_succeed": true,
+          "expected": 1
+        },
+        {
+          "operation": "read",
+          "should_succeed": true,
+          "expected": 2
+        }
+      ]
+    },
+    {
+      "description": "full buffer can't be written to",
+      "capacity": 1,
+      "operations": [
+        {
+          "operation": "write",
+          "item": 1,
+          "should_succeed": true
+        },
+        {
+          "operation": "write",
+          "item": 2,
+          "should_succeed": false
+        }
+      ]
+    },
+    {
+      "description": "a read frees up capacity for another write",
+      "capacity": 1,
+      "operations": [
+        {
+          "operation": "write",
+          "item": 1,
+          "should_succeed": true
+        },
+        {
+          "operation": "read",
+          "should_succeed": true,
+          "expected": 1
+        },
+        {
+          "operation": "write",
+          "item": 2,
+          "should_succeed": true
+        },
+        {
+          "operation": "read",
+          "should_succeed": true,
+          "expected": 2
+        }
+      ]
+    },
+    {
+      "description": "read position is maintained even across multiple writes",
+      "capacity": 3,
+      "operations": [
+        {
+          "operation": "write",
+          "item": 1,
+          "should_succeed": true
+        },
+        {
+          "operation": "write",
+          "item": 2,
+          "should_succeed": true
+        },
+        {
+          "operation": "read",
+          "should_succeed": true,
+          "expected": 1
+        },
+        {
+          "operation": "write",
+          "item": 3,
+          "should_succeed": true
+        },
+        {
+          "operation": "read",
+          "should_succeed": true,
+          "expected": 2
+        },
+        {
+          "operation": "read",
+          "should_succeed": true,
+          "expected": 3
+        }
+      ]
+    },
+    {
+      "description": "items cleared out of buffer can't be read",
+      "capacity": 1,
+      "operations": [
+        {
+          "operation": "write",
+          "item": 1,
+          "should_succeed": true
+        },
+        {
+          "operation": "clear"
+        },
+        {
+          "operation": "read",
+          "should_succeed": false
+        }
+      ]
+    },
+    {
+      "description": "clear frees up capacity for another write",
+      "capacity": 1,
+      "operations": [
+        {
+          "operation": "write",
+          "item": 1,
+          "should_succeed": true
+        },
+        {
+          "operation": "clear"
+        },
+        {
+          "operation": "write",
+          "item": 2,
+          "should_succeed": true
+        },
+        {
+          "operation": "read",
+          "should_succeed": true,
+          "expected": 2
+        }
+      ]
+    },
+    {
+      "description": "clear does nothing on empty buffer",
+      "capacity": 1,
+      "operations": [
+        {
+          "operation": "clear"
+        },
+        {
+          "operation": "write",
+          "item": 1,
+          "should_succeed": true
+        },
+        {
+          "operation": "read",
+          "should_succeed": true,
+          "expected": 1
+        }
+      ]
+    },
+    {
+      "description": "overwrite acts like write on non-full buffer",
+      "capacity": 2,
+      "operations": [
+        {
+          "operation": "write",
+          "item": 1,
+          "should_succeed": true
+        },
+        {
+          "operation": "overwrite",
+          "item": 2
+        },
+        {
+          "operation": "read",
+          "should_succeed": true,
+          "expected": 1
+        },
+        {
+          "operation": "read",
+          "should_succeed": true,
+          "expected": 2
+        }
+      ]
+    },
+    {
+      "description": "overwrite removes the oldest item on full buffer",
+      "capacity": 2,
+      "operations": [
+        {
+          "operation": "write",
+          "item": 1,
+          "should_succeed": true
+        },
+        {
+          "operation": "write",
+          "item": 2,
+          "should_succeed": true
+        },
+        {
+          "operation": "overwrite",
+          "item": 3
+        },
+        {
+          "operation": "read",
+          "should_succeed": true,
+          "expected": 2
+        },
+        {
+          "operation": "read",
+          "should_succeed": true,
+          "expected": 3
+        }
+      ]
+    },
+    {
+      "description": "overwrite doesn't remove an already-read item",
+      "capacity": 3,
+      "operations": [
+        {
+          "operation": "write",
+          "item": 1,
+          "should_succeed": true
+        },
+        {
+          "operation": "write",
+          "item": 2,
+          "should_succeed": true
+        },
+        {
+          "operation": "write",
+          "item": 3,
+          "should_succeed": true
+        },
+        {
+          "operation": "read",
+          "should_succeed": true,
+          "expected": 1
+        },
+        {
+          "operation": "write",
+          "item": 4,
+          "should_succeed": true
+        },
+        {
+          "operation": "overwrite",
+          "item": 5
+        },
+        {
+          "operation": "read",
+          "should_succeed": true,
+          "expected": 3
+        },
+        {
+          "operation": "read",
+          "should_succeed": true,
+          "expected": 4
+        },
+        {
+          "operation": "read",
+          "should_succeed": true,
+          "expected": 5
+        }
+      ]
+    }
+  ]
+}

data/common/exercises/luhn/description.md

@@ -7,8 +7,11 @@ The task is to write a function that checks if a given string is valid.
 
 Validating a Number
 ------
+Strings of length 1 or less are not valid. Spaces are allowed in the input,
+but they should be stripped before checking. All other non-digit characters
+are disallowed.
 
-As an example, here is a valid (but fictitious) Canadian Social Insurance
+As an example of a valid string, here is a fictitious Canadian Social Insurance
 Number.
 
 ```

data/common/exercises/secret-handshake/canonical-data.json

@@ -0,0 +1,67 @@
+{
+    "commands": {
+        "description": ["Create a handshake for a number"],
+        "cases": [
+            {
+                "description": "wink for 1",
+                "input": 1,
+                "expected": ["wink"]
+            },
+            {
+                "description": "double blink for 10",
+                "input": 2,
+                "expected": ["double blink"]
+            },
+            {
+                "description": "close your eyes for 100",
+                "input": 4,
+                "expected": ["close your eyes"]
+            },
+            {
+                "description": "jump for 1000",
+                "input": 8,
+                "expected": ["jump"]
+            },
+            {
+                "description": "combine two actions",
+                "input": 3,
+                "expected": ["wink", "double blink"]
+            },
+            {
+                "description": "reverse two actions",
+                "input": 19,
+                "expected": ["double blink", "wink"]
+            },
+            {
+                "description": "reversing one action gives the same action",
+                "input": 24,
+                "expected": ["jump"]
+            },
+            {
+                "description": "reversing no actions still gives no actions",
+                "input": 16,
+                "expected": []
+            },
+            {
+                "description": "all possible actions",
+                "input": 15,
+                "expected": ["wink", "double blink", "close your eyes", "jump"]
+            },
+            {
+                "description": "reverse all possible actions",
+                "input": 31,
+                "expected": ["jump", "close your eyes", "double blink", "wink"]
+            },
+            {
+                "description": "do nothing for zero",
+                "input": 0,
+                "expected": []
+            },
+            {
+                "description": "do nothing if lower 5 bits not set",
+                "input": 32,
+                "expected": []
+            }
+        ]
+    }
+}

data/common/exercises/secret-handshake/description.md

@@ -16,12 +16,10 @@ binary decide to come up with a secret "handshake".
 
 Here's a couple of examples:
 
-Given the input 9, the function would return the array
-["wink", "jump"]
+Given the input 3, the function would return the array
+["wink", "double blink"] because 3 is 11 in binary.
 
-Given the input "11001", the function would return the array
-["jump", "wink"]
-
-
-The program should consider strings specifying an invalid binary as the
-value 0.
+Given the input 19, the function would return the array
+["double blink", "wink"] because 19 is 10011 in binary.
+Notice that the addition of 16 (10000 in binary)
+has caused the array to be reversed.