trackler 2.1.0.48 → 2.1.0.49

data/tracks/scala/config.json

@@ -172,7 +172,6 @@
       "slug": "triangle",
       "difficulty": 3,
       "topics": [
-        "Enumerations",
         "Mathematics"
       ]
     },

data/tracks/scala/exercises/anagram/example.scala

@@ -1,10 +1,10 @@
-class Anagram(word: String) {
-  def matches(anagrams: Seq[String]) =
-    anagrams.filter(doesMatch).filterNot(isIdentical)
+object Anagram {
+  def anagrams(word: String, anagrams: Seq[String]) =
+    anagrams.filter(w => doesMatch(word, w)).filterNot(w => isIdentical(word, w))
 
-  private def doesMatch(anagram: String) =
-    anagram.toLowerCase.sorted == word.toLowerCase.sorted
+  private def doesMatch(word1: String, word2: String) =
+    word2.toLowerCase.sorted == word1.toLowerCase.sorted
 
-  private def isIdentical(anagram: String) =
-    anagram.toLowerCase == word.toLowerCase
+  private def isIdentical(word1: String, word2: String) =
+    word2.toLowerCase == word1.toLowerCase
 }

data/tracks/scala/exercises/anagram/src/test/scala/AnagramTest.scala

@@ -1,76 +1,103 @@
-import org.scalatest._
+import org.scalatest.{Matchers, FunSuite}
 
-class AnagramTest extends FlatSpec with Matchers {
-  it should "detect no matches" in {
-    val detector = new Anagram("diaper")
-    val anagrams = detector.matches(Seq("hello", "world", "zombies", "pants"))
-    anagrams should equal (Seq())
+/** @version 1.0.1 */
+class AnagramTest extends FunSuite with Matchers {
+
+  test("no matches") {
+    Anagram.anagrams("diaper", List("hello", "world", "zombies", "pants")) should be(
+      List())
+  }
+
+  test("detects simple anagram") {
+    pending
+    Anagram.anagrams("ant", List("tan", "stand", "at")) should be(List("tan"))
+  }
+
+  test("does not detect false positives") {
+    pending
+    Anagram.anagrams("galea", List("eagle")) should be(List())
+  }
+
+  test("detects two anagrams") {
+    pending
+    Anagram.anagrams("master", List("stream", "pigeon", "maters")) should be(
+      List("stream", "maters"))
+  }
+
+  test("does not detect anagram subsets") {
+    pending
+    Anagram.anagrams("good", List("dog", "goody")) should be(List())
+  }
+
+  test("detects anagram") {
+    pending
+    Anagram.anagrams("listen", List("enlists", "google", "inlets", "banana")) should be(
+      List("inlets"))
+  }
+
+  test("detects three anagrams") {
+    pending
+    Anagram.anagrams("allergy",
+                     List("gallery",
+                          "ballerina",
+                          "regally",
+                          "clergy",
+                          "largely",
+                          "leading")) should be(
+      List("gallery", "regally", "largely"))
   }
 
-  it should "detect simple anagrams" in {
+  test("does not detect identical words") {
     pending
-    val detector = new Anagram("ant")
-    val anagrams = detector.matches(Seq("tan", "stand", "at"))
-    anagrams should equal (Seq("tan"))
+    Anagram.anagrams(
+      "corn",
+      List("corn", "dark", "Corn", "rank", "CORN", "cron", "park")) should be(
+      List("cron"))
   }
 
-  it should "detect multiple anagrams" in {
+  test("does not detect non-anagrams with identical checksum") {
     pending
-    val detector = new Anagram("master")
-    val anagrams = detector.matches(Seq("stream", "pigeon", "maters"))
-    anagrams.sorted should equal (Seq("maters", "stream"))
+    Anagram.anagrams("mass", List("last")) should be(List())
   }
 
-  it should "not confuse different duplicates" in {
+  test("detects anagrams case-insensitively") {
     pending
-    val detector = new Anagram("galea")
-    val anagrams = detector.matches(Seq("eagle"))
-    anagrams should equal (Seq())
+    Anagram.anagrams("Orchestra",
+                     List("cashregister", "Carthorse", "radishes")) should be(
+      List("Carthorse"))
   }
 
-  it should "not include identical words" in {
+  test("detects anagrams using case-insensitive subject") {
     pending
-    val detector = new Anagram("corn")
-    val anagrams = detector.matches(Seq(
-      "corn", "dark", "Corn", "rank", "CORN", "cron", "park"
-    ))
-    anagrams should equal (Seq("cron"))
+    Anagram.anagrams("Orchestra",
+                     List("cashregister", "carthorse", "radishes")) should be(
+      List("carthorse"))
   }
 
-  it should "elimitate anagrams with same checksum" in {
+  test("detects anagrams using case-insensitive possible matches") {
     pending
-    val detector = new Anagram("mass")
-    detector.matches(Seq("last")) should equal (Seq())
+    Anagram.anagrams("orchestra",
+                     List("cashregister", "Carthorse", "radishes")) should be(
+      List("Carthorse"))
   }
 
-  it should "eliminate anagrams subsets" in {
+  test("does not detect a word as its own anagram") {
     pending
-    val detector = new Anagram("good")
-    detector.matches(Seq("dog", "goody")) should equal (Seq())
+    Anagram.anagrams("banana", List("Banana")) should be(List())
   }
 
-  it should "detect anagrams" in {
+  test("does not detect a anagram if the original word is repeated") {
     pending
-    val detector = new Anagram("listen")
-    val anagrams = detector.matches(Seq("enlists", "google", "inlets", "banana"))
-    anagrams should equal (Seq("inlets"))
+    Anagram.anagrams("go", List("go Go GO")) should be(List())
   }
 
-  it should "detect more anagrams" in {
+  test("anagrams must use all letters exactly once") {
     pending
-    val detector = new Anagram("allergy")
-    val anagrams = detector.matches(Seq(
-      "gallery", "ballerina", "regally", "clergy", "largely", "leading"
-    ))
-    anagrams.sorted should equal (Seq("gallery", "largely", "regally"))
+    Anagram.anagrams("tapper", List("patter")) should be(List())
   }
 
-  it should "treat anagrams as case insensitive" in {
+  test("capital word is not own anagram") {
     pending
-    val detector = new Anagram("Orchestra")
-    val anagrams = detector.matches(Seq(
-      "cashregister", "Carthorse", "radishes"
-    ))
-    anagrams should equal(Seq("Carthorse"))
+    Anagram.anagrams("BANANA", List("Banana")) should be(List())
   }
 }

data/tracks/scala/exercises/etl/example.scala

@@ -1,4 +1,4 @@
-object ETL {
+object Etl {
   def transform(m: Map[Int, Seq[String]]): Map[String, Int] = m.flatMap { case (key, strings) =>
     Map(strings.map(_.toLowerCase -> key): _*)
   }

data/tracks/scala/exercises/etl/src/test/scala/EtlTest.scala

@@ -1,46 +1,32 @@
-import org.scalatest._
+import org.scalatest.{Matchers, FunSuite}
 
-class TransformTest extends FunSuite with Matchers {
-  test ("transform one value") {
-    val old = Map(1 -> Seq("WORLD"))
+/** @version 1.0.0 */
+class EtlTest extends FunSuite with Matchers {
 
-    ETL.transform(old) should be (Map("world" -> 1))
+  test("a single letter") {
+    Etl.transform(Map(1 -> Seq("A"))) should be(Map("a" -> 1))
   }
 
-  test ("transform more values") {
+  test("single score with multiple letters") {
     pending
-    val old = Map(1 -> Seq("WORLD", "GSCHOOLERS"))
-    val expected = Map("world" -> 1, "gschoolers" -> 1)
-
-    ETL.transform(old) should be (expected)
+    Etl.transform(Map(1 -> Seq("A", "E", "I", "O", "U"))) should be(Map("a" -> 1,
+      "e" -> 1, "i" -> 1, "o" -> 1, "u" -> 1))
   }
 
-  test ("more keys") {
+  test("multiple scores with multiple letters") {
     pending
-    val old = Map(1 -> Seq("APPLE", "ARTICHOKE"), 2 -> Seq("BOAT", "BALLERINA"))
-    val expected = Map("apple" -> 1, "artichoke" -> 1, "boat" -> 2, "ballerina" -> 2)
-    ETL.transform(old) should be (expected)
+    Etl.transform(Map(1 -> Seq("A", "E"), 2 -> Seq("D", "G"))) should be(Map("a" -> 1,
+      "d" -> 2, "e" -> 1, "g" -> 2))
   }
 
-  test ("full dataset") {
+  test("multiple scores with differing numbers of letters") {
     pending
-    val old = Map(
-      1 -> Seq("A", "E", "I", "O", "U", "L", "N", "R", "S", "T"),
-      2 -> Seq("D", "G"),
-      3 -> Seq("B", "C", "M", "P"),
-      4 -> Seq("F", "H", "V", "W", "Y"),
-      5 -> Seq("K"),
-      8 -> Seq("J", "X"),
-      10 -> Seq("Q", "Z")
-    )
-    val expected = Map(
-      "a" -> 1, "b" -> 3, "c" -> 3, "d" -> 2, "e" -> 1,
-      "f" -> 4, "g" -> 2, "h" -> 4, "i" -> 1, "j" -> 8,
-      "k" -> 5, "l" -> 1, "m" -> 3, "n" -> 1, "o" -> 1,
-      "p" -> 3, "q" -> 10, "r" -> 1, "s" -> 1, "t" -> 1,
-      "u" -> 1, "v" -> 4, "w" -> 4, "x" -> 8, "y" -> 4,
-      "z" -> 10
-    )
-    ETL.transform(old) should be (expected)
+    Etl.transform(Map(1 -> Seq("A", "E", "I", "O", "U", "L", "N", "R", "S", "T"),
+      2 -> Seq("D", "G"), 3 -> Seq("B", "C", "M", "P"), 4 -> Seq("F", "H", "V", "W", "Y"),
+      5 -> Seq("K"), 8 -> Seq("J", "X"), 10 -> Seq("Q", "Z"))) should be(Map("a" -> 1,
+        "b" -> 3, "c" -> 3, "d" -> 2, "e" -> 1, "f" -> 4, "g" -> 2, "h" -> 4,
+        "i" -> 1, "j" -> 8, "k" -> 5, "l" -> 1, "m" -> 3, "n" -> 1, "o" -> 1, 
+        "p" -> 3, "q" -> 10, "r" -> 1, "s" -> 1, "t" -> 1, "u" -> 1, "v" -> 4,
+        "w" -> 4, "x" -> 8, "y" -> 4, "z" -> 10))
   }
-}
+}

data/tracks/scala/exercises/grains/src/test/scala/GrainsTest.scala

@@ -1,52 +1,59 @@
-import org.scalatest._
+import org.scalatest.{Matchers, FunSuite}
 
+/** @version 1.0.0 */
 class GrainsTest extends FunSuite with Matchers {
-  test ("square 1") {
+
+  test("1") {
     Grains.square(1) should be (Some(1))
   }
 
-  test ("square 2") {
+  test("2") {
     pending
     Grains.square(2) should be (Some(2))
   }
 
-  test ("square 3") {
+  test("3") {
     pending
     Grains.square(3) should be (Some(4))
   }
 
-  test ("square 4") {
+  test("4") {
     pending
     Grains.square(4) should be (Some(8))
   }
 
-  test ("square 16") {
+  test("16") {
     pending
     Grains.square(16) should be (Some(32768))
   }
 
-  test ("square 32") {
-    Grains.square(32) should be (Some(2147483648L))
+  test("32") {
+    pending
+    Grains.square(32) should be (Some(BigInt("2147483648")))
   }
 
-  test ("square 64") {
+  test("64") {
     pending
     Grains.square(64) should be (Some(BigInt("9223372036854775808")))
   }
 
-  test ("square negative") {
+  test("square 0 raises an exception") {
+    pending
+    Grains.square(0) should be (None)
+  }
+
+  test("negative square raises an exception") {
     pending
     Grains.square(-1) should be (None)
   }
 
-  test ("square bigger than 64") {
+  test("square greater than 64 raises an exception") {
     pending
     Grains.square(65) should be (None)
   }
 
-  test ("total grains") {
+  test("returns the total number of grains on the board") {
     pending
     Grains.total should be (BigInt("18446744073709551615"))
   }
-}
-
+}

data/tracks/scala/exercises/secret-handshake/example.scala

@@ -3,14 +3,14 @@ object SecretHandshake {
   private def gestures = List((1, "wink"), (2, "double blink"),
     (4, "close your eyes"), (8, "jump"))
 
-  def handshake(s: String): List[String] = {
+  def commands(s: String): List[String] = {
     def isValid = s.count(c => c != '0' && c != '1') == 0
 
     if (!isValid) List()
-    else handshake(Integer.parseInt(s, 2))
+    else commands(Integer.parseInt(s, 2))
   }
 
-  def handshake(n: Int): List[String] = {
+  def commands(n: Int): List[String] = {
     val result = gestures.filter {case (cmd, gesture) => (cmd & n) != 0} map
       {case (_, gesture) => gesture}
     if (shouldReverse(n)) result.reverse

data/tracks/scala/exercises/secret-handshake/src/test/scala/SecretHandshakeTest.scala

@@ -1,60 +1,59 @@
 import org.scalatest.{Matchers, FunSuite}
 
+/** @version 1.1.0 */
 class SecretHandshakeTest extends FunSuite with Matchers {
-  test("1 to wink") {
-    SecretHandshake.handshake(1) should be (List("wink"))
-    SecretHandshake.handshake("1") should be (List("wink"))
+
+  test("wink for 1") {
+    SecretHandshake.commands(1) should be (List("wink"))
+  }
+
+  test("double blink for 10") {
+    pending
+    SecretHandshake.commands(2) should be (List("double blink"))
   }
 
-  test("10 to double blink") { 
+  test("close your eyes for 100") {
     pending
-    SecretHandshake.handshake(2) should be (List("double blink"))
-    SecretHandshake.handshake("10") should be (List("double blink"))
+    SecretHandshake.commands(4) should be (List("close your eyes"))
   }
 
-  test("100 to close your eyes") { 
+  test("jump for 1000") {
     pending
-    SecretHandshake.handshake(4) should be (List("close your eyes"))
-    SecretHandshake.handshake("100") should be (List("close your eyes"))
+    SecretHandshake.commands(8) should be (List("jump"))
   }
 
-  test("1000 to jump") { 
+  test("combine two actions") {
     pending
-    SecretHandshake.handshake(8) should be (List("jump"))
-    SecretHandshake.handshake("1000") should be (List("jump"))
+    SecretHandshake.commands(3) should be (List("wink", "double blink"))
   }
 
-  test("11 to wink and double blink") { 
+  test("reverse two actions") {
     pending
-    SecretHandshake.handshake(3) should be (List("wink", "double blink"))
-    SecretHandshake.handshake("11") should be (List("wink", "double blink"))
+    SecretHandshake.commands(19) should be (List("double blink", "wink"))
   }
 
-  test("10011 to double blink and wink") { 
+  test("reversing one action gives the same action") {
     pending
-    SecretHandshake.handshake(19) should be (List("double blink", "wink"))
-    SecretHandshake.handshake("10011") should be (List("double blink", "wink"))
+    SecretHandshake.commands(24) should be (List("jump"))
   }
 
-  test("11111 to jump, close your eyes, double blink, and wink") { 
+  test("reversing no actions still gives no actions") {
     pending
-    SecretHandshake.handshake(31) should be (List("jump", "close your eyes", "double blink", "wink"))
-    SecretHandshake.handshake("11111") should be (List("jump", "close your eyes", "double blink", "wink"))
+    SecretHandshake.commands(16) should be (List())
   }
 
-  test("zero") { 
+  test("all possible actions") {
     pending
-    SecretHandshake.handshake(0) should be (List())
-    SecretHandshake.handshake("0") should be (List())
+    SecretHandshake.commands(15) should be (List("wink", "double blink", "close your eyes", "jump"))
   }
 
-  test("gibberish") { 
+  test("reverse all possible actions") {
     pending
-    SecretHandshake.handshake("piggies") should be (List())
+    SecretHandshake.commands(31) should be (List("jump", "close your eyes", "double blink", "wink"))
   }
 
-  test("partial gibberish") { 
+  test("do nothing for zero") {
     pending
-    SecretHandshake.handshake("1piggies") should be (List())
+    SecretHandshake.commands(0) should be (List())
   }
-}
+}

data/tracks/scala/exercises/sieve/example.scala

@@ -1,7 +1,7 @@
 import scala.collection.mutable
 
 object Sieve {
-  def primesUpTo(upperBound: Int): List[Int] = {
+  def primes(upperBound: Int): List[Int] = {
     // Start with set of all "possible" values that could be prime
     val primes = mutable.HashSet.empty ++ (2 to upperBound)
 

data/tracks/scala/exercises/sieve/src/test/scala/SieveTest.scala

@@ -1,39 +1,41 @@
 import org.scalatest.{Matchers, FunSuite}
 
+/** @version 1.0.0 */
 class SieveTest extends FunSuite with Matchers {
-  test("small primes") {
-    Sieve.primesUpTo(10) should be (List(2, 3, 5, 7))
+
+  test("no primes under two") {
+    Sieve.primes(1) should be(List())
   }
 
-  test("primes up to 11") { 
+  test("find first prime") {
     pending
-    Sieve.primesUpTo(11) should be (List(2, 3, 5, 7, 11))
+    Sieve.primes(2) should be(List(2))
   }
 
-  test("primes up to 1000") { 
+  test("find primes up to 10") {
     pending
-    Sieve.primesUpTo(1000) should be (List(
-      2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71,
-      73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151,
-      157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233,
-      239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317,
-      331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419,
-      421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503,
-      509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607,
-      613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701,
-      709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811,
-      821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911,
-      919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997))
+    Sieve.primes(10) should be(List(2, 3, 5, 7))
   }
 
-  test("first thousand primes") { 
+  test("limit is prime") {
     pending
-    Sieve.primesUpTo(7919).size should be (1000)
+    Sieve.primes(13) should be(List(2, 3, 5, 7, 11, 13))
   }
 
-  test("edge cases") { 
+  test("find primes up to 1000") {
     pending
-    Sieve.primesUpTo(1) should be (List())
-    Sieve.primesUpTo(2) should be (List(2))
+    Sieve.primes(1000) should be(
+      List(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61,
+        67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137,
+        139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211,
+        223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283,
+        293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379,
+        383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461,
+        463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563,
+        569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643,
+        647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739,
+        743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829,
+        839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937,
+        941, 947, 953, 967, 971, 977, 983, 991, 997))
   }
-}
+}