trackler 2.0.6.3 → 2.0.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cb456c079419313a6ce0e9bd9442ced587c8f3a9
-  data.tar.gz: b5cab80a086b12263490be5017b91406891ae13a
+  metadata.gz: b6aba1544337c241fe655409dc6f50da3ec7b21a
+  data.tar.gz: 9e50e4e647c05032ada9d09a96130d2543b7a20e
 SHA512:
-  metadata.gz: c6b863818cbcc41b49d6f5c828c71d97d592a7eb41d7f12f0a19914ddb39a0b36b1cec01a859c03717ff512ea57d69f2141e329e05eca95cb023851f725a924f
-  data.tar.gz: aff5310dd0bf1b56b3a68d415b26d95215fe26cd63d4b7f5f0e0abf24140a9e6d241fbed08d6d1d87b1bb3fd41aec865c6412da7614cad0e83a456acd8f3845d
+  metadata.gz: 607f0c63e16fa33ba4d4dce2389451ed73afc0770e7bdb5dde7181a01047ed1474dfac5bcbdc50b3842eec47242f58dcee14d05abfc968b6c022a06c956ae506
+  data.tar.gz: 5c2b8db8780598b58ad8a09c4637dccdb264841f5746e0c82f66d864b10c5483a6703edc04a9a307cf35dd14b2ad7833a7d49762d14e1c534a69a1c46580ebdb

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.6.3"
+  VERSION = "2.0.6.4"
 end

data/tracks/go/config.json

@@ -24,7 +24,12 @@
     {
       "difficulty": 1,
       "slug": "hello-world",
-      "topics": []
+      "topics": [
+          "Control-flow (if-else statements)",
+          "Optional values",
+          "Strings",
+          "Text formatting"
+      ]
     },
     {
       "difficulty": 1,

data/tracks/java/exercises/atbash-cipher/src/test/java/AtbashTest.java

@@ -45,10 +45,10 @@ public class AtbashTest {
 
     @RunWith(Parameterized.class)
     public static class DecodeTest {
-        private String input;
-        private String expectedOutput;
+        private String ciphertext;
+        private String plaintext;
 
-        @Parameters
+        @Parameters(name = "{index}: expected ciphertext \"{0}\" to decode to plaintext \"{1}\".")
         public static Collection<Object[]> data() {
             return Arrays.asList(new Object[][] {
                     { "vcvix rhn", "exercism" },
@@ -57,15 +57,15 @@ public class AtbashTest {
             });
         }
 
-        public DecodeTest(String input, String expectedOutput) {
-            this.input = input;
-            this.expectedOutput = expectedOutput;
+        public DecodeTest(String ciphertext, String plaintext) {
+            this.ciphertext = ciphertext;
+            this.plaintext = plaintext;
         }
 
         @Ignore
     @Test
         public void test() {
-            assertEquals(expectedOutput, Atbash.decode(input));
+            assertEquals(plaintext, Atbash.decode(ciphertext));
         }
     }
 }

data/tracks/perl6/config.json

@@ -21,6 +21,11 @@
       "slug": "bob",
       "topics": []
     },
+    {
+        "difficulty" : 1, 
+        "slug" : "atbash-cipher",
+        "topics" : [] 
+    },
     {
       "difficulty": 1,
       "slug": "leap",

data/tracks/perl6/exercises/atbash-cipher/Example.p6

@@ -0,0 +1,12 @@
+sub encode($input) is export {
+    decode($input.lc.trans( ['a'..'z', 0..9] => '', :complement ) )
+        .comb(5)
+        .join: ' ';
+}
+
+sub decode (Str $input) is export {
+    return $input
+            .lc
+            .subst( /\W/, '', :g )
+            .trans( [ 'a'..'z' ] =>  ['a'..'z'].reverse );
+}

data/tracks/perl6/exercises/atbash-cipher/cases.json

@@ -0,0 +1,82 @@
+{ 
+    "#": [
+        "The tests are divided into two groups: ",
+        "* Encoding from English to atbash cipher",
+        "* Decoding from atbash cipher to all-lowercase-mashed-together English"
+    ],
+    "encode": {
+        "description": ["Test encoding from English to atbash"],
+        "cases": [
+            {
+                "description": "encode yes",
+                "phrase": "yes",
+                "expected": "bvh"
+            },
+            {
+                "description": "encode no",
+                "phrase": "no",
+                "expected": "ml"
+            },
+            {
+                "description": "encode OMG",
+                "phrase": "OMG",
+                "expected": "lnt"
+            },
+            {
+                "description": "encode spaces",
+                "phrase": "O M G",
+                "expected": "lnt"
+            },
+            {
+                "description": "encode mindblowingly",
+                "phrase": "mindblowingly",
+                "expected": "nrmwy oldrm tob"
+            },
+            {
+                "description": "encode numbers",
+                "phrase": "Testing,1 2 3, testing.",
+                "expected": "gvhgr mt123 gvhgr mt"
+            },
+            {
+                "description": "encode deep thought",
+                "phrase": "Truth is fiction.",
+                "expected": "gifgs rhurx grlm"
+            },
+            {
+                "description": "encode all the letters",
+                "phrase": "The quick brown fox jumps over the lazy dog.",
+                "expected": "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt"
+            },
+            {
+                "description": "encode ignores non ascii",
+                "phrase": "non ascii éignored",
+                "expected": "mlmzh xrrrt mlivw"
+            }
+        ]
+    },
+    "decode": {
+        "description": ["Test decoding from atbash to English"],
+        "cases": [
+            {
+                "description": "decode exercism",
+                "phrase": "vcvix rhn",
+                "expected": "exercism"
+            },
+            {
+                "description": "decode a sentence",
+                "phrase": "zmlyh gzxov rhlug vmzhg vkkrm thglm v",
+                "expected": "anobstacleisoftenasteppingstone"
+            },
+            {
+                "description": "decode numbers",
+                "phrase": "gvhgr mt123 gvhgr mt",
+                "expected": "testing123testing"
+            },
+            {
+                "description": "decode all the letters",
+                "phrase": "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt",
+                "expected": "thequickbrownfoxjumpsoverthelazydog"
+            }
+        ]
+    }
+}

data/tracks/perl6/exercises/atbash-cipher/cipher.t

@@ -0,0 +1,36 @@
+#!/usr/bin/env perl6
+
+use Test;
+use JSON::Tiny;
+
+use lib ( my $dir = IO::Path.new($?FILE).parent ).path;
+
+my $module_name = %*ENV<EXERCISM>.so ?? 'Example' !! 'Allergies';
+my @potential_module = <p6 pm6 pm>.map:  $module_name ~ '.' ~ *; 
+
+my $module = first { $dir.child($_).e }, |@potential_module
+    or die "No file '$module_name.p6' found\n";
+
+require $module <&encode &decode>;
+
+plan 2;
+
+my %cases = from-json $dir.child('cases.json').slurp;
+
+subtest 'encode' => {
+    my @cases = |%cases.<encode>.<cases>;
+
+    plan +@cases;
+
+    is encode( .<phrase> ), .<expected>, .<description>
+        for @cases;
+};
+
+subtest 'decode' => {
+    my @cases = |%cases.<decode>.<cases>;
+
+    plan +@cases;
+
+    is decode( .<phrase> ), .<expected>, .<description>
+        for @cases;
+};

data/tracks/rust/config.json

@@ -115,6 +115,7 @@
       "slug": "nucleotide-count",
       "difficulty": 1,
       "topics": [
+        "Result",
         "filter",
         "entry api",
         "mutablity",

data/tracks/rust/exercises/nucleotide-count/example.rs

@@ -1,13 +1,24 @@
 use std::collections::HashMap;
 
-pub fn count(nucleotide: char, input: &str) -> usize {
-    input.chars().filter(|&c| c == nucleotide).count()
+static VALID_NUCLEOTIDES: &'static str = "ACGT";
+
+pub fn count(nucleotide: char, input: &str) -> Result<usize, char> {
+    let valid = |x: char| { VALID_NUCLEOTIDES.contains(x) };
+    if valid(nucleotide) && input.chars().all(valid) {
+        Ok(input.chars().filter(|&c| c == nucleotide).count())
+    } else {
+        Err(nucleotide)
+    }
 }
 
-pub fn nucleotide_counts(input: &str) -> HashMap<char, usize> {
-    let mut map: HashMap<char, usize> = "ACGT".chars().map(|c| (c, 0)).collect();
+pub fn nucleotide_counts(input: &str) -> Result<HashMap<char, usize>, char> {
+    let mut map: HashMap<char, usize> = VALID_NUCLEOTIDES.chars().map(|c| (c, 0)).collect();
     for nucleotide in input.chars() {
-        *map.entry(nucleotide).or_insert(0) += 1;
+        if let Some(n) = map.get_mut(&nucleotide) {
+            *n += 1;
+        } else {
+            return Err(nucleotide);
+        }
     }
-    map
+    Ok(map)
 }

data/tracks/rust/exercises/nucleotide-count/tests/nucleotide-count.rs

@@ -7,7 +7,7 @@ fn check_dna(s: &str, pairs: &[(char, usize)]) {
     // message for assert_eq! is as informative as possible. A simpler
     // solution would simply check the length of the map, and then
     // check for the presence and value of each key in the given pairs vector.
-    let mut m: HashMap<char, usize> = dna::nucleotide_counts(s);
+    let mut m: HashMap<char, usize> = dna::nucleotide_counts(s).unwrap();
     for &(k, v) in pairs.iter() {
         assert_eq!((k, m.remove(&k).unwrap()), (k, v));
     }
@@ -16,20 +16,44 @@ fn check_dna(s: &str, pairs: &[(char, usize)]) {
 }
 
 #[test]
+fn count_returns_result() {
+    assert!(dna::count('A', "").is_ok());
+}
+
+#[test]
+#[ignore]
 fn test_count_empty() {
-    assert_eq!(dna::count('A', ""), 0);
+    assert_eq!(dna::count('A', "").unwrap(), 0);
+}
+
+#[test]
+#[ignore]
+fn count_invalid_nucleotide() {
+    assert!(dna::count('X', "A").is_err());
+}
+
+#[test]
+#[ignore]
+fn count_invalid_dna() {
+    assert!(dna::count('A', "AX").is_err());
 }
 
 #[test]
 #[ignore]
 fn test_count_repetitive_cytosine() {
-    assert_eq!(dna::count('C', "CCCCC"), 5);
+    assert_eq!(dna::count('C', "CCCCC").unwrap(), 5);
 }
 
 #[test]
 #[ignore]
 fn test_count_only_thymine() {
-    assert_eq!(dna::count('T', "GGGGGTAACCCGG"), 1);
+    assert_eq!(dna::count('T', "GGGGGTAACCCGG").unwrap(), 1);
+}
+
+#[test]
+#[ignore]
+fn counts_returns_result() {
+    assert!(dna::nucleotide_counts("ACGT").is_ok());
 }
 
 #[test]
@@ -56,3 +80,9 @@ fn test_nucleotide_count_counts_all() {
          GAGTGTCTGATAGCAGC",
         &[('A', 20), ('T', 21), ('C', 12), ('G', 17)]);
 }
+
+#[test]
+#[ignore]
+fn counts_invalid_nucleotide_results_in_err() {
+    assert!(dna::nucleotide_counts("GGXXX").is_err());
+}

data/tracks/rust/problems.md

@@ -36,7 +36,7 @@ hamming |  Result
 pascals-triangle | Math, Vec, Index (optional)
 scrabble-score |  chaining higher-order functions, HashMap (optional)
 pangram | filter, ascii (optional)
-nucleotide-count |  filter, entry api, mutablity, match
+nucleotide-count |  Result, filter, entry api, mutablity, match
 largest-series-product | Result, windows, higher-order functions, char
 word-count |  hashmap, str vs string, chars, entry api
 atbash-cipher | str vs string, primitive types, iterators, chars, ascii

data/tracks/scala/config.json

@@ -28,6 +28,15 @@
             "Sets"
       ]
 		},
+    {
+      "slug": "run-length-encoding",
+      "difficulty": 1,
+      "topics": [
+	    "Algorithms",
+	    "Transforming",
+            "Strings"
+      ]
+		},
     {
       "slug": "hamming",
       "difficulty": 2,
@@ -158,6 +167,9 @@
       "slug": "roman-numerals",
       "difficulty": 1,
       "topics": [
+        "Sequences",
+        "Algorithms",
+        "Transforming"
       ]
 		},
     {

data/tracks/scala/exercises/acronym/example.scala

@@ -1,5 +1,5 @@
-case class Acronym(phrase: String) {
-  def abbreviate: String = {
+object Acronym {
+  def abbreviate(phrase: String): String = {
     "[A-Z]+[a-z]*|[a-z]+".r.findAllIn(phrase).map(s => s.head.toUpper).mkString
   }
 }

data/tracks/scala/exercises/acronym/src/main/scala/Acronym.scala

@@ -1,3 +1,3 @@
-case class Acronym(phrase: String) {
-  def abbreviate: String = ???
+object Acronym {
+  def abbreviate(phrase: String): String = ???
 }

data/tracks/scala/exercises/acronym/src/test/scala/AcronymTest.scala

@@ -10,6 +10,6 @@ class AcronymTest extends FlatSpec with Matchers {
     ("Complementary metal-oxide semiconductor", "CMOS"))
 
   it should "create acronyms" in {
-    acronyms.foreach{case (phrase, acronym) => Acronym(phrase).abbreviate should equal(acronym)}
+    acronyms.foreach{case (phrase, acronym) => Acronym.abbreviate(phrase) should equal(acronym)}
   }
 }

data/tracks/scala/exercises/roman-numerals/build.sbt

@@ -1,3 +1,3 @@
-scalaVersion := "2.11.7"
+scalaVersion := "2.12.1"
 
-libraryDependencies += "org.scalatest" % "scalatest_2.11" % "2.2.5" % "test"
+libraryDependencies += "org.scalatest" %% "scalatest" % "3.0.1" % "test"

data/tracks/scala/exercises/roman-numerals/example.scala

@@ -1,6 +1,7 @@
+import scala.annotation.tailrec
 import scala.collection.immutable.ListMap
 
-class RomanNumeral(n: Int) {
+object RomanNumeral {
   private def numeralValues = ListMap(
     1000 -> "M",
     900  -> "CM",
@@ -17,16 +18,13 @@ class RomanNumeral(n: Int) {
     1    -> "I"
   )
 
+  def toNumerals(n: Int) = fromNumber(n, "")
+
+  @tailrec
   private def fromNumber(n: Int, numerals: String): String = {
     numeralValues.find(_._1 <= n) match {
       case Some((threshold, numeral)) => fromNumber(n - threshold, numerals + numeral)
       case None => numerals
     }
   }
-
-  val value = fromNumber(n, "")
 }
-
-object RomanNumeral {
-  def apply(n: Int) = new RomanNumeral(n)
-}

data/tracks/scala/exercises/roman-numerals/src/test/scala/RomanNumeralsTest.scala

@@ -3,91 +3,91 @@ import org.scalatest._
 class RomanNumeralsSpecs extends FunSpec with Matchers {
 
   it ("0 equals empty string") {
-    RomanNumeral(0).value should be ("")
+    RomanNumeral.toNumerals(0) should be ("")
   }
 
   it ("1 equals I") {
     pending
-    RomanNumeral(1).value should be ("I")
+    RomanNumeral.toNumerals(1) should be ("I")
   }
 
   it ("2 equals II") {
     pending
-    RomanNumeral(2).value should be ("II")
+    RomanNumeral.toNumerals(2) should be ("II")
   }
 
   it ("3 equals III") {
     pending
-    RomanNumeral(3).value should be ("III")
+    RomanNumeral.toNumerals(3) should be ("III")
   }
 
   it ("4 equals IV") {
     pending
-    RomanNumeral(4).value should be ("IV")
+    RomanNumeral.toNumerals(4) should be ("IV")
   }
 
   it ("5 equals V") {
     pending
-    RomanNumeral(5).value should be ("V")
+    RomanNumeral.toNumerals(5) should be ("V")
   }
 
   it ("6 equals VI") {
     pending
-    RomanNumeral(6).value should be ("VI")
+    RomanNumeral.toNumerals(6) should be ("VI")
   }
 
   it ("9 equals IX") {
     pending
-    RomanNumeral(9).value should be ("IX")
+    RomanNumeral.toNumerals(9) should be ("IX")
   }
 
   it ("27 equals XXVII") {
     pending
-    RomanNumeral(27).value should be ("XXVII")
+    RomanNumeral.toNumerals(27) should be ("XXVII")
   }
 
   it ("48 equals XLVIII") {
     pending
-    RomanNumeral(48).value should be ("XLVIII")
+    RomanNumeral.toNumerals(48) should be ("XLVIII")
   }
 
   it ("59 equals LIX") {
     pending
-    RomanNumeral(59).value should be ("LIX")
+    RomanNumeral.toNumerals(59) should be ("LIX")
   }
 
   it ("93 equals XCIII") {
     pending
-    RomanNumeral(93).value should be ("XCIII")
+    RomanNumeral.toNumerals(93) should be ("XCIII")
   }
 
   it ("141 equals CXLI") {
     pending
-    RomanNumeral(141).value should be ("CXLI")
+    RomanNumeral.toNumerals(141) should be ("CXLI")
   }
 
   it ("402 equals CDII") {
     pending
-    RomanNumeral(402).value should be ("CDII")
+    RomanNumeral.toNumerals(402) should be ("CDII")
   }
 
   it ("575 equals DLXXV") {
     pending
-    RomanNumeral(575).value should be ("DLXXV")
+    RomanNumeral.toNumerals(575) should be ("DLXXV")
   }
 
   it ("911 equals CMXI") {
     pending
-    RomanNumeral(911).value should be ("CMXI")
+    RomanNumeral.toNumerals(911) should be ("CMXI")
   }
 
   it ("1024 equals MXXIV") {
     pending
-    RomanNumeral(1024).value should be ("MXXIV")
+    RomanNumeral.toNumerals(1024) should be ("MXXIV")
   }
 
   it ("3000 equals MMM") {
     pending
-    RomanNumeral(3000).value should be ("MMM")
+    RomanNumeral.toNumerals(3000) should be ("MMM")
   }
 }

data/tracks/scala/exercises/run-length-encoding/build.sbt

@@ -0,0 +1,3 @@
+scalaVersion := "2.12.1"
+
+libraryDependencies += "org.scalatest" %% "scalatest" % "3.0.1" % "test"

data/tracks/scala/exercises/run-length-encoding/example.scala

@@ -0,0 +1,32 @@
+object RunLengthEncoding {
+  type Plain = String
+  type Encoded = String
+
+  def encode(str: Plain): Encoded = {
+    def encodeGroup(xs: Seq[Char]): Seq[Char] =
+      if (xs.length > 1) s"${xs.length}${xs.head}"
+      else xs mkString
+
+    splitByEquals(str) flatMap encodeGroup mkString
+  }
+
+  def decode(str: Encoded): Plain = {
+    val nextChar: ((Int, Seq[Char]), Char) => (Int, Seq[Char]) = {
+      case ((n, xs), x) =>
+        if (x.isDigit) (n * 10 + x.asDigit, xs)
+        else if (n == 0) (0, x +: xs)
+        else (0, Seq.fill(n)(x) ++ xs)
+    }
+
+    val result = str.foldLeft((0, Seq.empty[Char]))(nextChar)
+    result._2.reverse mkString
+  }
+
+  private def splitByEquals[T](xs: Seq[T]): Seq[Seq[T]] =
+    xs match {
+      case Seq() => Seq()
+      case x +: xss =>
+        val fs = xs takeWhile (_ == x)
+        fs +: splitByEquals(xs drop fs.length)
+    }
+}

data/tracks/scala/exercises/run-length-encoding/src/main/scala/RunLengthEncoding.scala

@@ -0,0 +1,6 @@
+object RunLengthEncoding {
+
+  def encode(str: String): String = ???
+
+  def decode(str: String): String = ???
+}

data/tracks/scala/exercises/run-length-encoding/src/test/scala/RunLengthEncodingTests.scala

@@ -0,0 +1,52 @@
+import org.scalatest.FunSuite
+import org.scalatest.Matchers
+
+class RunLengthEncodingTests extends FunSuite with Matchers {
+
+  test("encode empty string") {
+    RunLengthEncoding.encode("") should be ("")
+  }
+
+  test("encode single characters only") {
+    pending
+    RunLengthEncoding.encode("XYZ") should be ("XYZ")
+  }
+
+  test("decode empty string") {
+    pending
+    RunLengthEncoding.decode("") should be ("")
+  }
+
+  test("decode single characters only") {
+    pending
+    RunLengthEncoding.decode("XYZ") should be ("XYZ")
+  }
+
+  test("encode simple") {
+    pending
+    RunLengthEncoding.encode("AABBBCCCC") should be ("2A3B4C")
+  }
+
+  test("decode simple") {
+    pending
+    RunLengthEncoding.decode("2A3B4C") should be ("AABBBCCCC")
+  }
+
+  test("encode with single values") {
+    pending
+    RunLengthEncoding.encode("WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB") should
+      be ("12WB12W3B24WB")
+  }
+
+  test("decode with single values") {
+    pending
+    RunLengthEncoding.decode("12WB12W3B24WB") should be ("WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB")
+  }
+
+  test("decode(encode(...)) combination") {
+    pending
+    RunLengthEncoding.decode(
+        RunLengthEncoding.encode("zzz ZZ  zZ")) should be ("zzz ZZ  zZ")
+  }
+
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trackler
 version: !ruby/object:Gem::Version
-  version: 2.0.6.3
+  version: 2.0.6.4
 platform: ruby
 authors:
 - Katrina Owen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-05 00:00:00.000000000 Z
+date: 2017-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -5305,6 +5305,9 @@ files:
 - tracks/perl6/exercises/allergies/cases.json
 - tracks/perl6/exercises/anagram/Example.pm
 - tracks/perl6/exercises/anagram/anagram.t
+- tracks/perl6/exercises/atbash-cipher/Example.p6
+- tracks/perl6/exercises/atbash-cipher/cases.json
+- tracks/perl6/exercises/atbash-cipher/cipher.t
 - tracks/perl6/exercises/binary/Example.pm
 - tracks/perl6/exercises/binary/binary.t
 - tracks/perl6/exercises/bob/Example.pm
@@ -6765,6 +6768,10 @@ files:
 - tracks/scala/exercises/roman-numerals/example.scala
 - tracks/scala/exercises/roman-numerals/src/main/scala/.keep
 - tracks/scala/exercises/roman-numerals/src/test/scala/RomanNumeralsTest.scala
+- tracks/scala/exercises/run-length-encoding/build.sbt
+- tracks/scala/exercises/run-length-encoding/example.scala
+- tracks/scala/exercises/run-length-encoding/src/main/scala/RunLengthEncoding.scala
+- tracks/scala/exercises/run-length-encoding/src/test/scala/RunLengthEncodingTests.scala
 - tracks/scala/exercises/saddle-points/build.sbt
 - tracks/scala/exercises/saddle-points/example.scala
 - tracks/scala/exercises/saddle-points/src/main/scala/.keep