trackler 2.2.1.150 → 2.2.1.151

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fed064cd5da037514165e2542ec5ffd18f0e98f7
-  data.tar.gz: 594af9b0cc9536b966f3ad65814c53887e84001e
+  metadata.gz: 30a30beb6ce13ee8953a3d97725d3438584dac3e
+  data.tar.gz: fb727d81248459be3ac036e199a7b43421123228
 SHA512:
-  metadata.gz: f16160c281a808804255cd278e5adcf659527c45bc5c326477f40bea126225eb414ae9890cfef6a6fc05720d3524c60952eda679654008419ba26c2fe1718cc6
-  data.tar.gz: f417b67723e2398c1f10154fea8a4059b4506622285b5365d684f3ee9d785cfed60996e5364c5bbb59be1fe7b7e4e7807b86d9a7d0ea518af8a38fbcfae25fb1
+  metadata.gz: 5cddff65e5fb0052b6deb69f7d17051a568ee7afa29a97693d234c55a96b7dc97d1419f11aff58473afe2f1dd2805773d4cc5507d044a1e6308bb69fed4d3a34
+  data.tar.gz: ee0d752600b90ba0019b2d34268fe5a33f2e8878c92d29b6b534868e29960b88dda836248fc4497abe9314706c6c04d5654204512f61a57b0dc231c307e2905f

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.2.1.150"
+  VERSION = "2.2.1.151"
 end

data/tracks/java/exercises/bracket-push/src/test/java/BracketCheckerTest.java

@@ -8,98 +8,98 @@ public class BracketCheckerTest {
 
     @Test
     public void testPairedSquareBrackets() {
-        final BracketChecker bracketChecker = new BracketChecker("[]");
+        BracketChecker bracketChecker = new BracketChecker("[]");
         assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testEmptyString() {
-        final BracketChecker bracketChecker = new BracketChecker("");
+        BracketChecker bracketChecker = new BracketChecker("");
         assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testUnpairedBrackets() {
-        final BracketChecker bracketChecker = new BracketChecker("[[");
+        BracketChecker bracketChecker = new BracketChecker("[[");
         assertFalse(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testIncorrectlyOrderedBrackets() {
-        final BracketChecker bracketChecker = new BracketChecker("}{");
+        BracketChecker bracketChecker = new BracketChecker("}{");
         assertFalse(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testSingleOpenBracketWithIncorrectClosingBracket() {
-        final BracketChecker bracketChecker = new BracketChecker("{]");
+        BracketChecker bracketChecker = new BracketChecker("{]");
         assertFalse(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testPairedBracketsWithWhitespace() {
-        final BracketChecker bracketChecker = new BracketChecker("{ }");
+        BracketChecker bracketChecker = new BracketChecker("{ }");
         assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testSimpleNestedBrackets() {
-        final BracketChecker bracketChecker = new BracketChecker("{[]}");
+        BracketChecker bracketChecker = new BracketChecker("{[]}");
         assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testSeveralPairedBrackets() {
-        final BracketChecker bracketChecker = new BracketChecker("{}[]");
+        BracketChecker bracketChecker = new BracketChecker("{}[]");
         assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testPairedAndNestedBrackets() {
-        final BracketChecker bracketChecker = new BracketChecker("([{}({}[])])");
+        BracketChecker bracketChecker = new BracketChecker("([{}({}[])])");
         assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testUnopenedClosingBracket() {
-        final BracketChecker bracketChecker = new BracketChecker("{[)][]}");
+        BracketChecker bracketChecker = new BracketChecker("{[)][]}");
         assertFalse(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testUnpairedAndNestedBracket() {
-        final BracketChecker bracketChecker = new BracketChecker("([{])");
+        BracketChecker bracketChecker = new BracketChecker("([{])");
         assertFalse(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testPairedAndIncorrectlyNestedBrackets() {
-        final BracketChecker bracketChecker = new BracketChecker("[({]})");
+        BracketChecker bracketChecker = new BracketChecker("[({]})");
         assertFalse(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testValidMathExpression() {
-        final BracketChecker bracketChecker = new BracketChecker("(((185 + 223.85) * 15) - 543)/2");
+        BracketChecker bracketChecker = new BracketChecker("(((185 + 223.85) * 15) - 543)/2");
         assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testValidComplexLaTeXExpression() {
-        final BracketChecker bracketChecker = new BracketChecker(
+        BracketChecker bracketChecker = new BracketChecker(
                 "\\left(\\begin{array}{cc} \\frac{1}{3} & x\\\\ \\mathrm{e}^{x} &... x^2 \\end{array}\\right)");
 
         assertTrue(bracketChecker.areBracketsMatchedAndNestedCorrectly());

data/tracks/java/exercises/difference-of-squares/src/test/java/DifferenceOfSquaresCalculatorTest.java

@@ -15,72 +15,72 @@ public class DifferenceOfSquaresCalculatorTest {
 
     @Test
     public void testSquareOfSumUpToOne() {
-        final int expected = 1;
-        final int actual = calculator.computeSquareOfSumTo(1);
+        int expected = 1;
+        int actual = calculator.computeSquareOfSumTo(1);
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testSquareOfSumUpToFive() {
-        final int expected = 225;
-        final int actual = calculator.computeSquareOfSumTo(5);
+        int expected = 225;
+        int actual = calculator.computeSquareOfSumTo(5);
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testSquareOfSumUpToHundred() {
-        final int expected = 25502500;
-        final int actual = calculator.computeSquareOfSumTo(100);
+        int expected = 25502500;
+        int actual = calculator.computeSquareOfSumTo(100);
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testSumOfSquaresUpToOne() {
-        final int expected = 1;
-        final int actual = calculator.computeSumOfSquaresTo(1);
+        int expected = 1;
+        int actual = calculator.computeSumOfSquaresTo(1);
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testSumOfSquaresUpToFive() {
-        final int expected = 55;
-        final int actual = calculator.computeSumOfSquaresTo(5);
+        int expected = 55;
+        int actual = calculator.computeSumOfSquaresTo(5);
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testSumOfSquaresUpToHundred() {
-        final int expected = 338350;
-        final int actual = calculator.computeSumOfSquaresTo(100);
+        int expected = 338350;
+        int actual = calculator.computeSumOfSquaresTo(100);
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testDifferenceOfSquaresUpToOne() {
-        final int expected = 0;
-        final int actual = calculator.computeDifferenceOfSquares(1);
+        int expected = 0;
+        int actual = calculator.computeDifferenceOfSquares(1);
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testDifferenceOfSquaresUpToFive() {
-        final int expected = 170;
-        final int actual = calculator.computeDifferenceOfSquares(5);
+        int expected = 170;
+        int actual = calculator.computeDifferenceOfSquares(5);
         assertEquals(expected, actual);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testDifferenceOfSquaresUpToHundred() {
-        final int expected = 25164150;
-        final int actual = calculator.computeDifferenceOfSquares(100);
+        int expected = 25164150;
+        int actual = calculator.computeDifferenceOfSquares(100);
         assertEquals(expected, actual);
     }
 

data/tracks/java/exercises/dominoes/.meta/version

@@ -1,2 +1,2 @@
-1.0.0
+2.1.0
 

data/tracks/java/exercises/tournament/.meta/version

@@ -1 +1 @@
-1.3.0
+1.4.0

data/tracks/powershell/exercises/hamming/HammingDifference.tests.ps1

@@ -1,65 +1,83 @@
-$here = Split-Path -Parent $MyInvocation.MyCommand.Path
-$sut = (Split-Path -Leaf $MyInvocation.MyCommand.Path) -replace '\.tests\.', '.'
-. "$here\$sut"
+$ExercisePath = Split-Path -Parent $MyInvocation.MyCommand.Path
+$ScriptFile = (Split-Path -Leaf $MyInvocation.MyCommand.Path) -replace '\.tests\.', '.'
 
-Describe "HammingTest" {
-    It "tests identical strands" {
-    Get-HammingDifference 'A' 'A' | Should be 0
+$CommandName = "Get-HammingDifference"
+
+# Remove the function if its already found
+If (Get-Command $CommandName -ErrorAction SilentlyContinue){
+    Write-Verbose "Removing the existing $CommandName function from memory as it is already loaded"
+    Remove-Item -Path "Function:\$CommandName"
+}
+
+# Load the script file
+If (Test-Path "$ExercisePath\$ScriptFile"){
+    Write-Output ("Loading: {0}" -f "$ExercisePath\$ScriptFile")
+    . ("$ExercisePath\$ScriptFile")
+}
+Else {
+    # Display an error and stop the tests
+    Write-Error "The file $ScriptFile was not found. You need to create your answer in a file named $ScriptFile" -ErrorAction Stop
+}
+
+Describe "Get-Hamming Test cases" {
+
+    It "Empty strands" {
+        Get-HammingDifference '' '' | Should be 0
+    }
+    
+    It "Empty strands" {
+        Get-HammingDifference 'A' 'A' | Should be 0
     }
 
-    It "tests log identical strands" {
+    It "Long identical strands" {
         Get-HammingDifference "GGACTGA" "GGACTGA" | Should be 0
     }
 
-    It "tests complete distance in single nucleotide strands" {
+    It "Complete distance in single nucleotide strands" {
         Get-HammingDifference "A" "G" | Should be 1
     }
 
-    It "tests complete distance in small strands" {
+    It "Complete distance in small strands" {
         Get-HammingDifference "AG" "CT" | Should be 2
     }
 
-    It "tests small distance in small strands" {
+    It "Small distance in small strands" {
         Get-HammingDifference "AT"  "CT" | Should be 1
     }
 
-    It "tests small distance" {
+    It "Small distance" {
         Get-HammingDifference "GGACG" "GGTCG" | Should be 1
     }
 
-    It "tests small distance in long strands" {
+    It "Small distance in long strands" {
         Get-HammingDifference "ACCAGGG" "ACTATGG" | Should be 2
     }
 
-    It "tests non unique character in first strand" {
-        Get-HammingDifference "AGA" "AGG" | Should be 1
+    It "Non-unique character in first strand" {
+        Get-HammingDifference "AAG" "AAA" | Should be 1
     }
 
-    It "tests non unique character in second strand" {
-        Get-HammingDifference "AGG" "AGA" | Should be 1
+    It "Non-unique character in second strand" {
+        Get-HammingDifference "AAA" "AAG" | Should be 1
     }
 
-    It "tests same nucleotides in different position" {
+    It "Same nucleotides in different positions" {
         Get-HammingDifference "TAG" "GAT" | Should be 2
     }
 
-    It "tests large distance" {
+    It "Large distance" {
         Get-HammingDifference "GATACA" "GCATAA" | Should be 4
     }
 
-    It "tests large distance in off by one strand" {
+    It "Large distance in off-by-one strand" {
         Get-HammingDifference "GGACGGATTCTG" "AGGACGGATTCT" | Should be 9
     }
 
-    It "tests empty strands" {
-        Get-HammingDifference "" "" | Should be 0
-    }
-
-    It "tests disallow first strand longer" {
-        { Get-HammingDifference "AATG" "AAA" } | Should Throw "Mismatching string lengths"
+    It "Disallow first strand longer" {
+        { Get-HammingDifference "AATG" "AAA" } | Should Throw "Left and right strands must be of equal length."
     }
 
-    It "tests disallow second strand longer" {
-        { Get-HammingDifference "ATA" "AGTG" } | Should Throw "Mismatching string lengths"
+    It "Disallow second strand longer" {
+        { Get-HammingDifference "ATA" "AGTG" } | Should Throw "Left and right strands must be of equal length."
     }
 }

data/tracks/powershell/exercises/leap/LeapYear.tests.ps1

@@ -3,31 +3,19 @@ $sut = (Split-Path -Leaf $MyInvocation.MyCommand.Path) -replace '\.tests\.', '.'
 . "$here\$sut"
 
 Describe "LeapYear Tests" {
-    It "tests leap year" {
-        Test-LeapYear(1996) | Should be $true
-    }
-
-    It "tests standard and odd year" {
-        Test-LeapYear(1997) | Should be $false
-    }
-
-    It "tests standard even year" {
-        Test-LeapYear(1998) | Should be $false
-    }
-
-    It "tests standard ninteenth century" {
-        Test-LeapYear(1900) | Should be $false
+    It "Year not divisible by 4: common year" {
+        Test-LeapYear(2015) | Should be $false
     }
 
-    It "tests standard eighteenth year" {
-        Test-LeapYear(1800) | Should be $false
+    It "Year divisible by 4, not divisible by 100: leap year" {
+        Test-LeapYear(1996) | Should be $true
     }
 
-    It "tests leap twenty fourth century" {
-        Test-LeapYear(2400) | Should be $true
+    It "Year divisible by 100, not divisible by 400: common year" {
+        Test-LeapYear(2100) | Should be $false
     }
 
-    It "tests leap year 2000" {
+    It "Year divisible by 400: leap year" {
         Test-LeapYear(2000) | Should be $true
     }
 }

data/tracks/rust/config.json

@@ -18,6 +18,17 @@
         "println"
       ]
     },
+    {
+      "slug": "twofer",
+      "uuid": "c6631a2c-4632-11e8-842f-0ed5f89f718b",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 1,
+      "topics": [
+        "match",
+        "strings"
+      ]
+    },
     {
       "slug": "gigasecond",
       "uuid": "f880b1ef-8f66-41f3-bb89-f39a4ed592a2",
@@ -431,6 +442,18 @@
         "str_vs_string"
       ]
     },
+    {
+      "slug": "simple-cipher",
+      "uuid": "f424a350-50bd-11e8-9c2d-fa7ae01bbebc",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 4,
+      "topics": [
+        "ascii",
+        "chars",
+        "str_vs_string"
+      ]
+    },
     {
       "slug": "etl",
       "uuid": "0c8eeef7-4bab-4cf9-9047-c208b5618312",

data/tracks/rust/exercises/hamming/example.rs

@@ -1,7 +1,7 @@
-pub fn hamming_distance(a : &str, b: &str) -> Result<usize, &'static str> {
+pub fn hamming_distance(a: &str, b: &str) -> Option<usize> {
     if a.len() != b.len() {
-        return Result::Err("inputs of different length");
+        return None;
     }
 
-    Result::Ok(a.chars().zip(b.chars()).filter(|&(a, b)| a != b).count())
+    Some(a.chars().zip(b.chars()).filter(|&(a, b)| a != b).count())
 }

data/tracks/rust/exercises/hamming/src/lib.rs

@@ -1,6 +1,6 @@
 /// Return the Hamming distance between the strings,
-/// or an error if the lengths are mismatched.
-pub fn hamming_distance(s1: &str, s2: &str) -> Result<u64, ()> {
+/// or None if the lengths are mismatched.
+pub fn hamming_distance(s1: &str, s2: &str) -> Option<usize> {
     unimplemented!("What is the Hamming Distance between {:?} and {:?}",
                    s1, s2);
-}
+}

data/tracks/rust/exercises/hamming/tests/hamming.rs

@@ -2,41 +2,41 @@ extern crate hamming;
 
 #[test]
 fn test_no_difference_between_empty_strands() {
-    assert_eq!(hamming::hamming_distance("", ""), Ok(0));
+    assert_eq!(hamming::hamming_distance("", ""), Some(0));
 }
 
 #[test]
 #[ignore]
 fn test_no_difference_between_identical_strands() {
-    assert_eq!(hamming::hamming_distance("GGACTGA", "GGACTGA"), Ok(0));
+    assert_eq!(hamming::hamming_distance("GGACTGA", "GGACTGA"), Some(0));
 }
 
 #[test]
 #[ignore]
 fn test_complete_hamming_distance_in_small_strand() {
-    assert_eq!(hamming::hamming_distance("ACT", "GGA"), Ok(3));
+    assert_eq!(hamming::hamming_distance("ACT", "GGA"), Some(3));
 }
 
 #[test]
 #[ignore]
 fn test_small_hamming_distance_in_the_middle_somewhere() {
-    assert_eq!(hamming::hamming_distance("GGACG", "GGTCG"), Ok(1));
+    assert_eq!(hamming::hamming_distance("GGACG", "GGTCG"), Some(1));
 }
 
 #[test]
 #[ignore]
 fn test_larger_distance() {
-    assert_eq!(hamming::hamming_distance("ACCAGGG", "ACTATGG"), Ok(2));
+    assert_eq!(hamming::hamming_distance("ACCAGGG", "ACTATGG"), Some(2));
 }
 
 #[test]
 #[ignore]
 fn test_first_string_is_longer() {
-    assert!(hamming::hamming_distance("AAA", "AA").is_err());
+    assert_eq!(hamming::hamming_distance("AAA", "AA"), None);
 }
 
 #[test]
 #[ignore]
 fn test_second_string_is_longer() {
-    assert!(hamming::hamming_distance("A", "AA").is_err());
+    assert_eq!(hamming::hamming_distance("A", "AA"), None);
 }

data/tracks/rust/exercises/reverse-string/.meta/hints.md

@@ -1,3 +1,10 @@
 ## Bonus
 Test your function on this string: `uüu` and see what happens. Try to write a function that properly
 reverses this string. Hint: grapheme clusters
+
+To get the bonus test to run, remove the ignore flag (`#[ignore]`) from the
+last test, and execute the tests with:
+
+```bash
+$ cargo test --features grapheme
+```

data/tracks/rust/exercises/reverse-string/Cargo.toml

@@ -3,4 +3,7 @@ name = "reverse_string"
 version = "1.0.0"
 authors = ["Peter Goodspeed-Niklaus <peter.r.goodspeedniklaus@gmail.com>"]
 
+[features]
+grapheme = []
+
 [dependencies]

data/tracks/rust/exercises/reverse-string/README.md

@@ -10,6 +10,13 @@ output: "looc"
 Test your function on this string: `uüu` and see what happens. Try to write a function that properly
 reverses this string. Hint: grapheme clusters
 
+To get the bonus test to run, remove the ignore flag (`#[ignore]`) from the
+last test, and execute the tests with:
+
+```bash
+$ cargo test --features grapheme
+```
+
 
 ## Rust Installation
 

data/tracks/rust/exercises/reverse-string/tests/reverse-string.rs

@@ -62,3 +62,11 @@ fn test_a_palindrome() {
 fn test_wide_characters() {
     process_reverse_case("子猫", "猫子");
 }
+
+#[test]
+#[ignore]
+#[cfg(feature="grapheme")]
+/// grapheme clusters
+fn test_grapheme_clusters() {
+    process_reverse_case("uüu", "uüu");
+}

data/tracks/rust/exercises/simple-cipher/.gitignore

@@ -0,0 +1,3 @@
+# Ignore Cargo.lock if creating a library
+# More information here http://doc.crates.io/guide.html#cargotoml-vs-cargolock
+Cargo.lock

data/tracks/rust/exercises/simple-cipher/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "simple-cipher"
+version = "0.0.0"
+
+[dependencies]
+rand = "0.4.2"

data/tracks/rust/exercises/simple-cipher/README.md

@@ -0,0 +1,121 @@
+# Simple Cipher
+
+Implement a simple shift cipher like Caesar and a more secure substitution cipher.
+
+## Step 1
+
+"If he had anything confidential to say, he wrote it in cipher, that is,
+by so changing the order of the letters of the alphabet, that not a word
+could be made out. If anyone wishes to decipher these, and get at their
+meaning, he must substitute the fourth letter of the alphabet, namely D,
+for A, and so with the others."
+—Suetonius, Life of Julius Caesar
+
+Ciphers are very straight-forward algorithms that allow us to render
+text less readable while still allowing easy deciphering. They are
+vulnerable to many forms of cryptoanalysis, but we are lucky that
+generally our little sisters are not cryptoanalysts.
+
+The Caesar Cipher was used for some messages from Julius Caesar that
+were sent afield. Now Caesar knew that the cipher wasn't very good, but
+he had one ally in that respect: almost nobody could read well. So even
+being a couple letters off was sufficient so that people couldn't
+recognize the few words that they did know.
+
+Your task is to create a simple shift cipher like the Caesar Cipher.
+This image is a great example of the Caesar Cipher:
+
+![Caesar Cipher][1]
+
+For example:
+
+Giving "iamapandabear" as input to the encode function returns the cipher "ldpdsdqgdehdu". Obscure enough to keep our message secret in transit.
+
+When "ldpdsdqgdehdu" is put into the decode function it would return
+the original "iamapandabear" letting your friend read your original
+message.
+
+## Step 2
+
+Shift ciphers are no fun though when your kid sister figures it out. Try
+amending the code to allow us to specify a key and use that for the
+shift distance. This is called a substitution cipher.
+
+Here's an example:
+
+Given the key "aaaaaaaaaaaaaaaaaa", encoding the string "iamapandabear"
+would return the original "iamapandabear".
+
+Given the key "ddddddddddddddddd", encoding our string "iamapandabear"
+would return the obscured "ldpdsdqgdehdu"
+
+In the example above, we've set a = 0 for the key value. So when the
+plaintext is added to the key, we end up with the same message coming
+out. So "aaaa" is not an ideal key. But if we set the key to "dddd", we
+would get the same thing as the Caesar Cipher.
+
+## Step 3
+
+The weakest link in any cipher is the human being. Let's make your
+substitution cipher a little more fault tolerant by providing a source
+of randomness and ensuring that the key contains only lowercase letters.
+
+If someone doesn't submit a key at all, generate a truly random key of
+at least 100 characters in length.
+
+If the key submitted is not composed only of lowercase letters, your
+solution should handle the error in a language-appropriate way.
+
+## Extensions
+
+Shift ciphers work by making the text slightly odd, but are vulnerable
+to frequency analysis. Substitution ciphers help that, but are still
+very vulnerable when the key is short or if spaces are preserved. Later
+on you'll see one solution to this problem in the exercise
+"crypto-square".
+
+If you want to go farther in this field, the questions begin to be about
+how we can exchange keys in a secure way. Take a look at [Diffie-Hellman
+on Wikipedia][dh] for one of the first implementations of this scheme.
+
+[1]: https://upload.wikimedia.org/wikipedia/commons/thumb/4/4a/Caesar_cipher_left_shift_of_3.svg/320px-Caesar_cipher_left_shift_of_3.svg.png
+[dh]: http://en.wikipedia.org/wiki/Diffie%E2%80%93Hellman_key_exchange
+
+## Rust Installation
+
+Refer to the [exercism help page][help-page] for Rust installation and learning
+resources.
+
+## Writing the Code
+
+Execute the tests with:
+
+```bash
+$ cargo test
+```
+
+All but the first test have been ignored.  After you get the first test to
+pass, remove the ignore flag (`#[ignore]`) from the next test and get the tests
+to pass again.  The test file is located in the `tests` directory.   You can
+also remove the ignore flag from all the tests to get them to run all at once
+if you wish.
+
+Make sure to read the [Modules](https://doc.rust-lang.org/book/second-edition/ch07-00-modules.html) chapter if you
+haven't already, it will help you with organizing your files.
+
+## Feedback, Issues, Pull Requests
+
+The [exercism/rust](https://github.com/exercism/rust) repository on GitHub is the home for all of the Rust exercises. If you have feedback about an exercise, or want to help implement new exercises, head over there and create an issue. Members of the rust track team are happy to help!
+
+If you want to know more about Exercism, take a look at the [contribution guide](https://github.com/exercism/docs/blob/master/contributing-to-language-tracks/README.md).
+
+[help-page]: http://exercism.io/languages/rust
+[modules]: https://doc.rust-lang.org/book/second-edition/ch07-00-modules.html
+[cargo]: https://doc.rust-lang.org/book/second-edition/ch14-00-more-about-cargo.html
+
+## Source
+
+Substitution Cipher at Wikipedia [http://en.wikipedia.org/wiki/Substitution_cipher](http://en.wikipedia.org/wiki/Substitution_cipher)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/rust/exercises/simple-cipher/example.rs

@@ -0,0 +1,42 @@
+extern crate rand;
+use rand::Rng;
+
+pub fn encode_random(s: &str) -> (String, String) {
+    let mut r = rand::thread_rng();
+    let mut key = String::new();
+    for _ in 0..100 {
+        key.push(char::from('a' as u8 + r.gen_range(0, 26)));
+    }
+    let encoded = encode(&key, s);
+    (key, encoded.unwrap())
+}
+
+pub fn encode(key: &str, s: &str) -> Option<String> {
+    shift(key, s, 1)
+}
+
+pub fn decode(key: &str, s: &str) -> Option<String> {
+    shift(key, s, -1)
+}
+
+fn shift(key: &str, s: &str, dir: i8) -> Option<String> {
+    if key.is_empty() {
+        return None;
+    }
+    let mut o = String::new();
+    let mut i = 0;
+    let mut key_arr = Vec::new();
+    for c in key.chars() {
+        if !c.is_ascii_lowercase() {
+            return None;
+        }
+        key_arr.push(c);
+    }
+    for c in s.chars() {
+        let shift = key_arr[i % key_arr.len()] as i8 - 'a' as i8;
+        let n = ((c as i8 - 'a' as i8 + dir * shift) % 26 + 26) % 26;
+        o.push(char::from('a' as u8 + n as u8));
+        i += 1;
+    }
+    Some(o)
+}

data/tracks/rust/exercises/simple-cipher/src/lib.rs

@@ -0,0 +1,11 @@
+pub fn encode(key: &str, s: &str) -> Option<String> {
+    unimplemented!("Use {} to encode {} using shift cipher",key,s)
+}
+
+pub fn decode(key: &str, s: &str) -> Option<String> {
+    unimplemented!("Use {} to decode {} using shift cipher",key,s)
+}
+
+pub fn encode_random(s: &str) -> (String, String) {
+    unimplemented!("Generate random key with only a-z chars and encode {}. Return tuple (key, encoded s)",s)
+}

data/tracks/rust/exercises/simple-cipher/tests/simple-cipher.rs

@@ -0,0 +1,171 @@
+extern crate simple_cipher;
+use simple_cipher::*;
+use std::collections::HashSet;
+
+const PLAIN_TEXT: &str = "thisismysecret";
+const KEY: &str = "abcdefghij";
+
+
+#[test]
+fn cipher_can_encode_with_given_key() {
+    assert_eq!(encode(KEY, "aaaaaaaaaa"), Some(KEY.to_string()));
+}
+
+#[test]
+#[ignore]
+fn cipher_can_decode_with_given_key() {
+    assert_eq!(decode(KEY, "abcdefghij"), Some("aaaaaaaaaa".to_string()));
+}
+
+#[test]
+#[ignore]
+fn cipher_is_reversible_given_key() {
+    assert_eq!(
+        decode(KEY, &encode(KEY, PLAIN_TEXT).unwrap()),
+        Some(PLAIN_TEXT.to_string())
+    );
+}
+
+#[test]
+#[ignore]
+fn cipher_can_double_shift_encode() {
+    let plain_text = "iamapandabear";
+    assert_eq!(
+        encode(plain_text, plain_text),
+        Some("qayaeaagaciai".to_string())
+    );
+}
+
+#[test]
+#[ignore]
+fn cipher_can_wrap_encode() {
+    assert_eq!(encode(KEY, "zzzzzzzzzz"), Some("zabcdefghi".to_string()));
+}
+
+#[test]
+#[ignore]
+fn cipher_can_encode_a_message_that_is_shorter_than_the_key() {
+    assert_eq!(encode(KEY, "aaaaa"), Some("abcde".to_string()));
+}
+
+#[test]
+#[ignore]
+fn cipher_can_decode_a_message_that_is_shorter_than_the_key() {
+    assert_eq!(decode(KEY, "abcde"), Some("aaaaa".to_string()));
+}
+
+#[test]
+#[ignore]
+fn encode_returns_none_with_an_all_caps_key() {
+    let key = "ABCDEF";
+    assert_eq!(encode(key, PLAIN_TEXT), None);
+}
+
+#[test]
+#[ignore]
+fn encode_returns_none_with_an_any_caps_key() {
+    let key = "abcdEFg";
+    assert_eq!(encode(key, PLAIN_TEXT), None);
+}
+
+#[test]
+#[ignore]
+fn encode_returns_none_with_numeric_key() {
+    let key = "12345";
+    assert_eq!(encode(key, PLAIN_TEXT), None);
+}
+
+#[test]
+#[ignore]
+fn encode_returns_none_with_any_numeric_key() {
+    let key = "abcd345ef";
+    assert_eq!(encode(key, PLAIN_TEXT), None);
+}
+
+#[test]
+#[ignore]
+fn encode_returns_none_with_empty_key() {
+    let key = "";
+    assert_eq!(encode(key, PLAIN_TEXT), None);
+}
+
+#[test]
+#[ignore]
+fn decode_returns_none_with_an_all_caps_key() {
+    let key = "ABCDEF";
+    assert_eq!(decode(key, PLAIN_TEXT), None);
+}
+
+#[test]
+#[ignore]
+fn decode_returns_none_with_an_any_caps_key() {
+    let key = "abcdEFg";
+    assert_eq!(decode(key, PLAIN_TEXT), None);
+}
+
+#[test]
+#[ignore]
+fn decode_returns_none_with_numeric_key() {
+    let key = "12345";
+    assert_eq!(decode(key, PLAIN_TEXT), None);
+}
+
+#[test]
+#[ignore]
+fn decode_returns_none_with_any_numeric_key() {
+    let key = "abcd345ef";
+    assert_eq!(decode(key, PLAIN_TEXT), None);
+}
+
+#[test]
+#[ignore]
+fn decode_returns_none_with_empty_key() {
+    let key = "";
+    assert_eq!(decode(key, PLAIN_TEXT), None);
+}
+
+#[test]
+#[ignore]
+fn encode_random_uses_key_made_of_letters() {
+    let (k, _) = encode_random(PLAIN_TEXT);
+    assert!(k.chars().all(|c| c.is_ascii_lowercase()));
+}
+
+#[test]
+#[ignore]
+fn encode_random_uses_key_of_100_characters_or_more() {
+    let (k, _) = encode_random(PLAIN_TEXT);
+    assert!(k.len() >= 100);
+}
+
+#[test]
+#[ignore]
+fn encode_random_uses_randomly_generated_key() {
+    let mut keys = HashSet::new();
+    let trials = 100;
+    for _ in 0..trials {
+        keys.insert(encode_random(PLAIN_TEXT).0);
+    }
+    assert_eq!(keys.len(), trials);
+}
+
+#[test]
+#[ignore]
+fn encode_random_can_encode() {
+    let (k, encoded) = encode_random("aaaaaaaaaa");
+    assert_eq!(encoded, k.split_at(10).0);
+}
+
+#[test]
+#[ignore]
+fn encode_random_can_decode() {
+    let (k, _) = encode_random("aaaaaaaaaa");
+    assert_eq!(decode(&k, k.split_at(10).0), Some("aaaaaaaaaa".to_string()));
+}
+
+#[test]
+#[ignore]
+fn encode_random_is_reversible() {
+    let (k, encoded) = encode_random(PLAIN_TEXT);
+    assert_eq!(decode(&k, &encoded), Some(PLAIN_TEXT.to_string()));
+}

data/tracks/rust/exercises/twofer/.gitignore

@@ -0,0 +1,4 @@
+
+/target/
+**/*.rs.bk
+Cargo.lock

data/tracks/rust/exercises/twofer/Cargo.toml

@@ -0,0 +1,5 @@
+[package]
+name = "twofer"
+version = "1.2.0"
+
+[dependencies]

data/tracks/rust/exercises/twofer/README.md

@@ -0,0 +1,47 @@
+## Two-fer
+
+`Two-fer` or `2-fer` is short for two for one. One for you and one for me.
+
+```text
+"One for X, one for me."
+```
+
+When X is a name or "you".
+
+If the given name is "Alice", the result should be "One for Alice, one for me."
+If no name is given, the result should be "One for you, one for me."
+
+## Rust Installation
+
+Refer to the [exercism help page][help-page] for Rust installation and learning
+resources.
+
+## Writing the Code
+
+Execute the tests with:
+
+```bash
+$ cargo test
+```
+
+All but the first test have been ignored.  After you get the first test to
+pass, remove the ignore flag (`#[ignore]`) from the next test and get the tests
+to pass again.  The test file is located in the `tests` directory.   You can
+also remove the ignore flag from all the tests to get them to run all at once
+if you wish.
+
+Make sure to read the [Modules](https://doc.rust-lang.org/book/second-edition/ch07-00-modules.html) chapter if you
+haven't already, it will help you with organizing your files.
+
+## Feedback, Issues, Pull Requests
+
+The [exercism/rust](https://github.com/exercism/rust) repository on GitHub is the home for all of the Rust exercises. If you have feedback about an exercise, or want to help implement new exercises, head over there and create an issue. Members of the rust track team are happy to help!
+
+If you want to know more about Exercism, take a look at the [contribution guide](https://github.com/exercism/docs/blob/master/contributing-to-language-tracks/README.md).
+
+[help-page]: http://exercism.io/languages/rust
+[modules]: https://doc.rust-lang.org/book/second-edition/ch07-00-modules.html
+[cargo]: https://doc.rust-lang.org/book/second-edition/ch14-00-more-about-cargo.html
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/rust/exercises/twofer/example.rs

@@ -0,0 +1,6 @@
+pub fn twofer(name: &str)-> String {
+    match name {
+        "" => "One for you, one for me.".to_string(),
+        _ => format!("One for {}, one for me.",name),
+    }
+}

data/tracks/rust/exercises/twofer/src/lib.rs

@@ -0,0 +1,3 @@
+pub fn twofer(name: &str)-> String {
+    unimplemented!("One for {}, one for me.", name);
+}

data/tracks/rust/exercises/twofer/tests/two-fer.rs

@@ -0,0 +1,19 @@
+extern crate twofer;
+use twofer::twofer;
+
+#[test]
+fn empty_string() {
+    assert_eq!(twofer(""), "One for you, one for me.");
+}
+
+#[test]
+#[ignore]
+fn alice() { 
+    assert_eq!(twofer("Alice"), "One for Alice, one for me.");
+}
+
+#[test]
+#[ignore]
+fn bob() {
+    assert_eq!(twofer("Bob"), "One for Bob, one for me.");
+}

data/tracks/swift/exercises/robot-name/Tests/RobotNameTests/RobotNameTests.swift

@@ -14,7 +14,7 @@ import Foundation
 
 class RobotNameTests: XCTestCase {
     func robotNameIsCorrectlyFormatted(_ name: String) -> Bool {
-        let robotNameRegex = try? Regex(pattern: "\\A\\w{2}\\d{3}\\z", options: Regex.Options.caseInsensitive)
+        let robotNameRegex = try? Regex(pattern: "\\A[A-Z]{2}\\d{3}\\z")
         guard let matches = robotNameRegex?.matches(in: name, options: .withoutAnchoringBounds, range: NSRange(0..<name.utf16.count)) else { return false }
 
         return matches.count > 0

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trackler
 version: !ruby/object:Gem::Version
-  version: 2.2.1.150
+  version: 2.2.1.151
 platform: ruby
 authors:
 - Katrina Owen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-18 00:00:00.000000000 Z
+date: 2018-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -13389,6 +13389,12 @@ files:
 - tracks/rust/exercises/sieve/example.rs
 - tracks/rust/exercises/sieve/src/lib.rs
 - tracks/rust/exercises/sieve/tests/sieve.rs
+- tracks/rust/exercises/simple-cipher/.gitignore
+- tracks/rust/exercises/simple-cipher/Cargo.toml
+- tracks/rust/exercises/simple-cipher/README.md
+- tracks/rust/exercises/simple-cipher/example.rs
+- tracks/rust/exercises/simple-cipher/src/lib.rs
+- tracks/rust/exercises/simple-cipher/tests/simple-cipher.rs
 - tracks/rust/exercises/simple-linked-list/.gitignore
 - tracks/rust/exercises/simple-linked-list/.meta/hints.md
 - tracks/rust/exercises/simple-linked-list/Cargo.toml
@@ -13439,6 +13445,12 @@ files:
 - tracks/rust/exercises/two-bucket/example.rs
 - tracks/rust/exercises/two-bucket/src/lib.rs
 - tracks/rust/exercises/two-bucket/tests/two-bucket.rs
+- tracks/rust/exercises/twofer/.gitignore
+- tracks/rust/exercises/twofer/Cargo.toml
+- tracks/rust/exercises/twofer/README.md
+- tracks/rust/exercises/twofer/example.rs
+- tracks/rust/exercises/twofer/src/lib.rs
+- tracks/rust/exercises/twofer/tests/two-fer.rs
 - tracks/rust/exercises/variable-length-quantity/.gitignore
 - tracks/rust/exercises/variable-length-quantity/Cargo.toml
 - tracks/rust/exercises/variable-length-quantity/README.md