trackler 2.0.6.34 → 2.0.6.35

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 198b6fef8f99f08933a5950cece11d670f8c55d5
-  data.tar.gz: 60fe20d97d5d76d28013bc55f34e61af774c2545
+  metadata.gz: b60180d66cb803d7af0b313725e9f050d9dc61b0
+  data.tar.gz: cba72b210897ddba5ce87dc79ca7541e9615ab43
 SHA512:
-  metadata.gz: d0e57fc07e060f60f97d7b63f4f65731b759237eb22005cffe9366506c74d9a4d3db12e69c34b14b437892cc909f6a60d6574f2cb32d98a9d05cb5c93c9abff2
-  data.tar.gz: 3bfc8af45d8823761ba9cd317f8de8e873fe178d4e8f4f8785c80582e24751b5d16219d29820b3af80df6f1f049a4859e6129610c9ad64c4b51c9779af0b3a2e
+  metadata.gz: cdaf21409803ea63c534daeca46434a8463f75b65a8e4a3908b924598786f69e90e4c7335b344ba48a60098215eac3c11ec510820e3f36081e1c9baddd23a8b7
+  data.tar.gz: a0b9a0e0ce5411a07b0a5e3221fcebe7da097c20cb83843fb3252d4c9d72f6a44d8861c7925eaf88738fcaff3011cf7e0141c82c38d7a7b2d0b5e45b1cc96bcd

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

@@ -48,6 +48,12 @@
                 "target": 3,
                 "expected": -1
             },
+            {
+                "description": "error if no combination can add up to target",
+                "coins": [5, 10],
+                "target": 94,
+                "expected": -1
+            },
             {
                 "description": "cannot find negative change values",
                 "coins": [1, 2, 5],

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

@@ -10,6 +10,11 @@
       "input": "0",
       "expected": false
     },
+    {
+      "description": "simple valid sin",
+      "input": " 5 9 ",
+      "expected": true
+    },
     {
       "description": "valid Canadian SIN",
       "input": "046 454 286",
@@ -29,6 +34,36 @@
       "description": "valid strings with a non-digit added become invalid",
       "input": "046a 454 286",
       "expected": false
+    },
+    {
+      "description": "punctuation is not allowed",
+      "input": "055-444-285",
+      "expected": false
+    },
+    {
+      "description": "symbols are not allowed",
+      "input": "055£ 444$ 285",
+      "expected": false
+    },
+    {
+      "description": "single zero with space is invalid",
+      "input": " 0",
+      "expected": false
+    },
+    {
+      "description": "lots of zeros are valid",
+      "input": " 00000",
+      "expected": true
+    },
+    {
+      "description": "another valid sin",
+      "input": "055 444 285",
+      "expected": true
+    },
+    {
+      "description": "nine doubled is nine",
+      "input": "091",
+      "expected": true
     }
   ]
 }

data/common/exercises/rotational-cipher/cannonical-data.json

@@ -0,0 +1,70 @@
+{
+    "#": [
+        "The tests are a series of rotation tests: "
+    ],
+    "rotate": {
+        "description": ["Test rotation from English to ROTn"],
+        "cases": [
+            {
+                "description": "rotate a by 1",
+                "text": "a",
+                "shift_key": 1,
+                "expected": "b"
+            },
+            {
+                "description": "rotate a by 26, same output as input",
+                "text": "a",
+                "shift_key": 26,
+                "expected": "a"
+            },
+            {
+                "description": "rotate a by 0, same output as input",
+                "text": "a",
+                "shift_key": 26,
+                "expected": "a"
+            },
+            {
+                "description": "rotate m by 13",
+                "text": "m",
+                "shift_key": 13,
+                "expected": "z"
+            },
+            {
+                "description": "rotate n by 13 with wrap around alphabet",
+                "text": "n",
+                "shift_key": 13,
+                "expected": "a"
+            },
+            {
+                "description": "rotate capital letters",
+                "text": "OMG",
+                "shift_key": 5,
+                "expected": "TRL"
+            },
+            {
+                "description": "rotate spaces",
+                "text": "O M G",
+                "shift_key": 5,
+                "expected": "T R L"
+            },
+            {
+                "description": "rotate numbers",
+                "text": "Testing 1 2 3 testing",
+                "shift_key": 4,
+                "expected": "Xiwxmrk 1 2 3 xiwxmrk"
+            },
+            {
+                "description": "rotate punctuation",
+                "text": "Let's eat, Grandma!",
+                "shift_key": 21,
+                "expected": "Gzo'n zvo, Bmviyhv!"
+            },
+            {
+                "description": "rotate all letters",
+                "text": "The quick brown fox jumps over the lazy dog.",
+                "shift_key": 13,
+                "expected": "Gur dhvpx oebja sbk whzcf bire gur ynml qbt."
+            }
+        ]
+    }
+}

data/common/exercises/rotational-cipher/description.md

@@ -0,0 +1,30 @@
+# Rotational Cipher
+
+Create an implementation of the rotational cipher, also sometimes called the Caesar cipher.
+
+The Caesar cipher is a simple shift cipher that relies on
+transposing all the letters in the alphabet using an integer key
+between `0` and `26`. Using a key of `0` or `26` will always yield
+the same output due to modular arithmetic. The letter is shifted
+for as many values as the value of the key.
+
+The general notation for rotational ciphers is `ROT + <key>`.
+The most commonly used rotational cipher is `ROT13`.
+
+A `ROT13` on the Latin alphabet would be as follows:
+
+```plain
+Plain:  abcdefghijklmnopqrstuvwxyz
+Cipher: nopqrstuvwxyzabcdefghijklm
+```
+
+It is stronger than the Atbash cipher because it has 27 possible keys, and 25 usable keys.
+
+Ciphertext is written out in the same formatting as the input including spaces and punctuation.
+
+## Examples
+- ROT5  `omg` gives `trl`
+- ROT0  `c` gives `c`
+- ROT26 `Cool` gives `Cool`
+- ROT13 `The quick brown fox jumps over the lazy dog.` gives `Gur dhvpx oebja sbk whzcf bire gur ynml qbt.`
+- ROT13 `Gur dhvpx oebja sbk whzcf bire gur ynml qbt.` gives `The quick brown fox jumps over the lazy dog.`

data/common/exercises/rotational-cipher/metadata.yml

@@ -0,0 +1,4 @@
+---
+blurb: "Create an implementation of the rotational cipher, also sometimes called the Caesar cipher."
+source: "Wikipedia"
+source_url: "https://en.wikipedia.org/wiki/Caesar_cipher"

data/common/exercises/run-length-encoding/description.md

@@ -14,5 +14,11 @@ the compressed data, which makes it a lossless data compression.
 "AABCCCDEEEE"  ->  "2AB3CD4E"  ->  "AABCCCDEEEE"
 ```
 
+If the string contains any whitespace, it should be passed through unchanged:
+
+```
+"aabc dddef"  ->  "2abc 3def"
+```
+
 For simplicity, you can assume that the unencoded string will only contain
-the letters A through Z.
+the letters A through Z (either lower or uppercase) and whitespace.

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.6.34"
+  VERSION = "2.0.6.35"
 end

data/tracks/elixir/exercises/run-length-encoding/example.exs

@@ -2,13 +2,24 @@ defmodule RunLengthEncoder do
 
   @spec encode(String.t) :: String.t
   def encode(string) do
-    Regex.scan(~r/([A-Z])\1*/, string)
-    |> Enum.map_join(fn([run, c]) -> "#{String.length(run)}#{c}" end)
+    Regex.scan(~r/([a-zA-Z ])\1*/, string)
+    |> Enum.map_join(fn([run, c]) ->
+      if String.match?(run, ~r/\s+/) do
+        run
+      else
+        times = String.length(run)
+        number = if times == 1 do "" else times end
+          "#{number}#{c}"
+      end
+    end)
   end
 
   @spec decode(String.t) :: String.t
   def decode(string) do
-    Regex.scan(~r/(\d+)(.)/, string)
-    |> Enum.map_join(fn [_,n,c] -> String.duplicate(c, String.to_integer(n)) end)
+    Regex.scan(~r/(\d*)(.)/, string)
+    |> Enum.map_join(fn [_,n,c] ->
+      times = if n == "" do 1 else String.to_integer(n) end
+      String.duplicate(c, times)
+    end)
   end
 end

data/tracks/elixir/exercises/run-length-encoding/rle.exs

@@ -1,10 +1,10 @@
 defmodule RunLengthEncoder do
   @doc """
   Generates a string where consecutive elements are represented as a data value and count.
-  "HORSE" => "1H1O1R1S1E"
+  "AABBBCCCC" => "2A3B4C"
   For this example, assume all input are strings, that are all uppercase letters.
   It should also be able to reconstruct the data into its original form.
-  "1H1O1R1S1E" => "HORSE"
+  "2A3B4C" => "AABBBCCCC"
   """
   @spec encode(String.t) :: String.t
   def encode(string) do

data/tracks/elixir/exercises/run-length-encoding/rle_test.exs

@@ -8,32 +8,49 @@ ExUnit.configure exclude: :pending, trace: true
 defmodule RunLengthEncoderTest do
   use ExUnit.Case
 
-  test "empty string returns empty" do
+  test "encode empty string" do
     assert RunLengthEncoder.encode("") === ""
   end
 
   @tag :pending
-  test "simple string gets encoded" do
-    assert RunLengthEncoder.encode("AAA") === "3A"
+  test "encode single characters only" do
+    assert RunLengthEncoder.encode("XYZ") === "XYZ"
   end
 
   @tag :pending
-  test "more complicated string" do
-    assert RunLengthEncoder.encode("HORSE") == "1H1O1R1S1E"
+  test "decode empty string" do
+    assert RunLengthEncoder.decode("") === ""
   end
 
   @tag :pending
-  test "an even more complex string" do
-    assert RunLengthEncoder.encode("WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB") === "12W1B12W3B24W1B"
+  test "decode single characters only" do
+    assert RunLengthEncoder.decode("XYZ") === "XYZ"
   end
 
   @tag :pending
-  test "it decodes an encoded simple string" do
-    assert RunLengthEncoder.decode("3A") === "AAA"
+  test "encode simple" do
+    assert RunLengthEncoder.encode("AABBBCCCC") == "2A3B4C"
   end
 
   @tag :pending
-  test "it decodes a more complicated string" do
-    assert RunLengthEncoder.decode("12W1B12W3B24W1B") === "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB"
+  test "decode simple" do
+    assert RunLengthEncoder.decode("2A3B4C") == "AABBBCCCC"
+  end
+
+  @tag :pending
+  test "encode with single values" do
+    assert RunLengthEncoder.encode("WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB") === "12WB12W3B24WB"
+  end
+
+  @tag :pending
+  test "decode with single values" do
+    assert RunLengthEncoder.decode("12WB12W3B24WB") === "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB"
+  end
+
+  @tag :pending
+  test "decode(encode(...)) combination" do
+    original = "zzz ZZ  zZ"
+    encoded = RunLengthEncoder.encode(original)
+    assert RunLengthEncoder.decode(encoded) === original
   end
 end

data/tracks/go/exercises/bob/bob_test.go

@@ -4,10 +4,13 @@ import "testing"
 
 const targetTestVersion = 2
 
-func TestHeyBob(t *testing.T) {
+func TestTestVersion(t *testing.T) {
 	if testVersion != targetTestVersion {
 		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
 	}
+}
+
+func TestHeyBob(t *testing.T) {
 	for _, tt := range testCases {
 		actual := Hey(tt.input)
 		if actual != tt.expected {

data/tracks/go/exercises/bracket-push/bracket_push_test.go

@@ -48,10 +48,13 @@ var testCases = []struct {
 	},
 }
 
-func TestBracket(t *testing.T) {
+func TestTestVersion(t *testing.T) {
 	if testVersion != targetTestVersion {
-		t.Fatalf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
+		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
 	}
+}
+
+func TestBracket(t *testing.T) {
 	for _, tt := range testCases {
 		actual, err := Bracket(tt.input)
 		// We don't expect errors for any of the test cases

data/tracks/go/exercises/circular-buffer/circular_buffer_test.go

@@ -21,12 +21,6 @@ import (
 
 const targetTestVersion = 4
 
-func TestTestVersion(t *testing.T) {
-	if testVersion != targetTestVersion {
-		t.Errorf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
-	}
-}
-
 // Here is one way you can have a test case verify that the expected
 // interfaces are implemented.
 
@@ -94,6 +88,12 @@ func (tb testBuffer) overwrite(c byte) {
 
 // tests.  separate functions so log will have descriptive test name.
 
+func TestTestVersion(t *testing.T) {
+	if testVersion != targetTestVersion {
+		t.Fatalf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
+	}
+}
+
 func TestReadEmptyBuffer(t *testing.T) {
 	tb := nb(1, t)
 	tb.readFail()

data/tracks/go/exercises/clock/clock_test.go

@@ -29,10 +29,13 @@ import (
 
 const targetTestVersion = 4
 
-func TestCreateClock(t *testing.T) {
+func TestTestVersion(t *testing.T) {
 	if testVersion != targetTestVersion {
 		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
 	}
+}
+
+func TestCreateClock(t *testing.T) {
 	for _, n := range timeTests {
 		if got := New(n.h, n.m); got.String() != n.want {
 			t.Fatalf("New(%d, %d) = %q, want %q", n.h, n.m, got, n.want)

data/tracks/go/exercises/connect/connect_test.go

@@ -17,10 +17,13 @@ func prepare(lines []string) []string {
 
 const targetTestVersion = 3
 
-func TestResultOf(t *testing.T) {
+func TestTestVersion(t *testing.T) {
 	if testVersion != targetTestVersion {
 		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
 	}
+}
+
+func TestResultOf(t *testing.T) {
 	for _, tt := range testCases {
 		actual, err := ResultOf(prepare(tt.board))
 		// We don't expect errors for any of the test cases

data/tracks/go/exercises/crypto-square/crypto_square_test.go

@@ -86,10 +86,13 @@ var tests = []struct {
 	},
 }
 
-func TestEncode(t *testing.T) {
+func TestTestVersion(t *testing.T) {
 	if testVersion != targetTestVersion {
-		t.Errorf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
+		t.Fatalf("Found testVersion = %v, want %v", testVersion, targetTestVersion)
 	}
+}
+
+func TestEncode(t *testing.T) {
 	for _, test := range tests {
 		if ct := Encode(test.pt); ct != test.ct {
 			t.Fatalf(`Encode(%q):

data/tracks/go/exercises/luhn/luhn_test.go

@@ -26,7 +26,7 @@ func TestTestVersion(t *testing.T) {
 func TestValid(t *testing.T) {
 	for _, test := range testCases {
 		if ok := Valid(test.input); ok != test.ok {
-			t.Fatalf("Valid(%s): %s\n\t Expected: %t\n\t Got: %t", test.input, test.description, ok, test.ok)
+			t.Fatalf("Valid(%s): %s\n\t Expected: %t\n\t Got: %t", test.input, test.description, test.ok, ok)
 		}
 	}
 }

data/tracks/javascript/exercises/leap/leap.js

@@ -1,5 +1,5 @@
 //
-// This is only a SKELETON file for the "Bob" exercise. It's been provided as a
+// This is only a SKELETON file for the "Leap" exercise. It's been provided as a
 // convenience to get you started writing code faster.
 //
 

data/tracks/julia/.travis.yml

@@ -2,12 +2,10 @@ language: julia
 
 os:
   - linux
-  - osx
 
 julia:
   - release
   - nightly
-  - 0.5
 
 matrix:
   allow_failures: