trackler 2.2.1.104 → 2.2.1.105

data/tracks/scala/exercises/alphametics/example.scala

@@ -37,37 +37,37 @@ object ExpressionParser extends RegexParsers {
     parseAll(booleanExpression, str)
 
   private def booleanExpression: Parser[Expression[Boolean]] =
-    intExpression ~ "==" ~ intExpression ^^ {
+    longExpression ~ "==" ~ longExpression ^^ {
       case left ~ _ ~ right => Equals(left, right)
     }
 
-  private def intExpression: Parser[Expression[Int]] =
-    intOperation | nonOperator
+  private def longExpression: Parser[Expression[Long]] =
+    longOperation | nonOperator
 
-  private def intOperation: Parser[Expression[Int]] =
-    nonOperator ~ operator ~ intExpression ^^ {
+  private def longOperation: Parser[Expression[Long]] =
+    nonOperator ~ operator ~ longExpression ^^ {
       case left ~ op ~ right => op(left, right)
     }
 
-  private def operator: Parser[(Expression[Int], Expression[Int]) => Expression[Int]] =
+  private def operator: Parser[(Expression[Long], Expression[Long]) => Expression[Long]] =
     plus | mult | power
 
-  private def nonOperator: Parser[Expression[Int]] =
+  private def nonOperator: Parser[Expression[Long]] =
     word | number
 
   private val word: Parser[Word] =
     "[A-Z]+".r ^^ (Word(_))
 
   private val number: Parser[Number] =
-    "[0-9]+".r ^^ (n =>(Number(n.toInt)))
+    "[0-9]+".r ^^ (n =>(Number(n.toLong)))
 
-  private val plus: Parser[(Expression[Int], Expression[Int]) => Expression[Int]] =
+  private val plus: Parser[(Expression[Long], Expression[Long]) => Expression[Long]] =
     "+"  ^^ const(Plus(_, _))
 
-  private val mult: Parser[(Expression[Int], Expression[Int]) => Expression[Int]] =
+  private val mult: Parser[(Expression[Long], Expression[Long]) => Expression[Long]] =
     "*" ^^ const(Mult(_, _))
 
-  private val power: Parser[(Expression[Int], Expression[Int]) => Expression[Int]] =
+  private val power: Parser[(Expression[Long], Expression[Long]) => Expression[Long]] =
     "^" ^^ const(Power(_, _))
 
   private def const[A](a: A)(ignore: Any) = a
@@ -78,13 +78,13 @@ sealed trait Expression[T] {
   def eval(solution: Solution): Option[T]
 }
 
-case class Word(word: String) extends Expression[Int] {
+case class Word(word: String) extends Expression[Long] {
   override def eval(solution: Solution) =
     if (solution(word(0)) == 0) None
-    else Some((word map solution mkString) toInt)
+    else Some((word map solution mkString) toLong)
 }
 
-case class Number(number: Int) extends Expression[Int] {
+case class Number(number: Long) extends Expression[Long] {
   override def eval(solution: Solution) = Some(number)
 }
 
@@ -100,26 +100,26 @@ trait Operation[A,B] extends Expression[B] {
 }
 
 case class Equals[A](override val left: Expression[A],
-    override val right: Expression[A]) extends Operation[A, Boolean]
+                     override val right: Expression[A]) extends Operation[A, Boolean]
 {
-  override val op: (A, A) => Boolean = (_ == _)
+  override val op: (A, A) => Boolean = _ == _
 }
 
-case class Plus(override val left: Expression[Int],
-    override val right: Expression[Int]) extends Operation[Int, Int]
+case class Plus(override val left: Expression[Long],
+                override val right: Expression[Long]) extends Operation[Long, Long]
 {
-  override val op: (Int, Int) => Int = (_ + _)
+  override val op: (Long, Long) => Long = _ + _
 }
 
-case class Mult(override val left: Expression[Int],
-    override val right: Expression[Int]) extends Operation[Int, Int]
+case class Mult(override val left: Expression[Long],
+                override val right: Expression[Long]) extends Operation[Long, Long]
 {
-  override val op: (Int, Int) => Int = (_ * _)
+  override val op: (Long, Long) => Long = _ * _
 }
 
-case class Power(override val left: Expression[Int],
-    override val right: Expression[Int]) extends Operation[Int, Int]
+case class Power(override val left: Expression[Long],
+                 override val right: Expression[Long]) extends Operation[Long, Long]
 {
-  override val op: (Int, Int) => Int = math.pow(_, _).toInt
+  override val op: (Long, Long) => Long = math.pow(_, _).toLong
 }
 

data/tracks/scala/exercises/alphametics/src/test/scala/AlphameticsTest.scala

@@ -1,76 +1,92 @@
 import org.scalatest.{Matchers, FunSuite}
 
-/** @version 1.0.0 */
+/** @version 1.2.0 */
 class AlphameticsTest extends FunSuite with Matchers {
 
   test("puzzle with three letters") {
-    Alphametics.solve("I + BB == ILL") should be (Some(Map('B' -> 9,
-      'I' -> 1,
-      'L' -> 0)))
+    Alphametics.solve("I + BB == ILL") should be(
+      Some(Map('B' -> 9, 'I' -> 1, 'L' -> 0)))
   }
 
   test("solution must have unique value for each letter") {
     pending
-    Alphametics.solve("A == B") should be (None)
+    Alphametics.solve("A == B") should be(None)
   }
 
   test("leading zero solution is invalid") {
     pending
-    Alphametics.solve("ACA + DD == BD") should be (None)
+    Alphametics.solve("ACA + DD == BD") should be(None)
   }
 
   test("puzzle with four letters") {
     pending
-    Alphametics.solve("AS + A == MOM") should be (Some(Map('A' -> 9,
-      'M' -> 1,
-      'O' -> 0,
-      'S' -> 2)))
+    Alphametics.solve("AS + A == MOM") should be(
+      Some(Map('A' -> 9, 'M' -> 1, 'O' -> 0, 'S' -> 2)))
   }
 
   test("puzzle with six letters") {
     pending
-    Alphametics.solve("NO + NO + TOO == LATE") should be (Some(Map('A' -> 0,
-      'E' -> 2,
-      'L' -> 1,
-      'N' -> 7,
-      'O' -> 4,
-      'T' -> 9)))
+    Alphametics.solve("NO + NO + TOO == LATE") should be(
+      Some(Map('A' -> 0, 'E' -> 2, 'L' -> 1, 'N' -> 7, 'O' -> 4, 'T' -> 9)))
   }
 
   test("puzzle with seven letters") {
     pending
-    Alphametics.solve("HE + SEES + THE == LIGHT") should be (Some(Map('E' -> 4,
-      'G' -> 2,
-      'H' -> 5,
-      'I' -> 0,
-      'L' -> 1,
-      'S' -> 9,
-      'T' -> 7)))
+    Alphametics.solve("HE + SEES + THE == LIGHT") should be(
+      Some(
+        Map('E' -> 4,
+            'G' -> 2,
+            'H' -> 5,
+            'I' -> 0,
+            'L' -> 1,
+            'S' -> 9,
+            'T' -> 7)))
   }
 
   test("puzzle with eight letters") {
     pending
-    Alphametics.solve("SEND + MORE == MONEY") should be (Some(Map('D' -> 7,
-      'E' -> 5,
-      'M' -> 1,
-      'N' -> 6,
-      'O' -> 0,
-      'R' -> 8,
-      'S' -> 9,
-      'Y' -> 2)))
+    Alphametics.solve("SEND + MORE == MONEY") should be(
+      Some(
+        Map('D' -> 7,
+            'E' -> 5,
+            'M' -> 1,
+            'N' -> 6,
+            'O' -> 0,
+            'R' -> 8,
+            'S' -> 9,
+            'Y' -> 2)))
   }
 
   test("puzzle with ten letters") {
     pending
-    Alphametics.solve("AND + A + STRONG + OFFENSE + AS + A + GOOD == DEFENSE") should be (Some(Map('A' -> 5,
-      'D' -> 3,
-      'E' -> 4,
-      'F' -> 7,
-      'G' -> 8,
-      'N' -> 0,
-      'O' -> 2,
-      'R' -> 1,
-      'S' -> 6,
-      'T' -> 9)))
+    Alphametics.solve("AND + A + STRONG + OFFENSE + AS + A + GOOD == DEFENSE") should be(
+      Some(
+        Map('A' -> 5,
+            'D' -> 3,
+            'E' -> 4,
+            'F' -> 7,
+            'G' -> 8,
+            'N' -> 0,
+            'O' -> 2,
+            'R' -> 1,
+            'S' -> 6,
+            'T' -> 9)))
   }
-}
+
+  test("puzzle with ten letters and 199 addends") {
+    pending
+    Alphametics.solve(
+      "THIS + A + FIRE + THEREFORE + FOR + ALL + HISTORIES + I + TELL + A + TALE + THAT + FALSIFIES + ITS + TITLE + TIS + A + LIE + THE + TALE + OF + THE + LAST + FIRE + HORSES + LATE + AFTER + THE + FIRST + FATHERS + FORESEE + THE + HORRORS + THE + LAST + FREE + TROLL + TERRIFIES + THE + HORSES + OF + FIRE + THE + TROLL + RESTS + AT + THE + HOLE + OF + LOSSES + IT + IS + THERE + THAT + SHE + STORES + ROLES + OF + LEATHERS + AFTER + SHE + SATISFIES + HER + HATE + OFF + THOSE + FEARS + A + TASTE + RISES + AS + SHE + HEARS + THE + LEAST + FAR + HORSE + THOSE + FAST + HORSES + THAT + FIRST + HEAR + THE + TROLL + FLEE + OFF + TO + THE + FOREST + THE + HORSES + THAT + ALERTS + RAISE + THE + STARES + OF + THE + OTHERS + AS + THE + TROLL + ASSAILS + AT + THE + TOTAL + SHIFT + HER + TEETH + TEAR + HOOF + OFF + TORSO + AS + THE + LAST + HORSE + FORFEITS + ITS + LIFE + THE + FIRST + FATHERS + HEAR + OF + THE + HORRORS + THEIR + FEARS + THAT + THE + FIRES + FOR + THEIR + FEASTS + ARREST + AS + THE + FIRST + FATHERS + RESETTLE + THE + LAST + OF + THE + FIRE + HORSES + THE + LAST + TROLL + HARASSES + THE + FOREST + HEART + FREE + AT + LAST + OF + THE + LAST + TROLL + ALL + OFFER + THEIR + FIRE + HEAT + TO + THE + ASSISTERS + FAR + OFF + THE + TROLL + FASTS + ITS + LIFE + SHORTER + AS + STARS + RISE + THE + HORSES + REST + SAFE + AFTER + ALL + SHARE + HOT + FISH + AS + THEIR + AFFILIATES + TAILOR + A + ROOFS + FOR + THEIR + SAFE == FORTRESSES") should be(
+      Some(
+        Map('A' -> 1,
+            'E' -> 0,
+            'F' -> 5,
+            'H' -> 8,
+            'I' -> 7,
+            'L' -> 2,
+            'O' -> 6,
+            'R' -> 3,
+            'S' -> 4,
+            'T' -> 9)))
+  }
+}

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

@@ -1,6 +1,6 @@
 import org.scalatest.{Matchers, FunSuite}
 
-/** @version 1.0.1 */
+/** @version 1.2.0 */
 class AnagramTest extends FunSuite with Matchers {
 
   test("no matches") {
@@ -8,16 +8,6 @@ class AnagramTest extends FunSuite with Matchers {
       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(
@@ -47,14 +37,6 @@ class AnagramTest extends FunSuite with Matchers {
       List("gallery", "regally", "largely"))
   }
 
-  test("does not detect identical words") {
-    pending
-    Anagram.anagrams(
-      "corn",
-      List("corn", "dark", "Corn", "rank", "CORN", "cron", "park")) should be(
-      List("cron"))
-  }
-
   test("does not detect non-anagrams with identical checksum") {
     pending
     Anagram.anagrams("mass", List("last")) should be(List())
@@ -62,30 +44,22 @@ class AnagramTest extends FunSuite with Matchers {
 
   test("detects anagrams case-insensitively") {
     pending
-    Anagram.anagrams("Orchestra",
-                     List("cashregister", "Carthorse", "radishes")) should be(
+    Anagram.anagrams("Orchestra", List("cashregister", "Carthorse", "radishes")) should be(
       List("Carthorse"))
   }
 
   test("detects anagrams using case-insensitive subject") {
     pending
-    Anagram.anagrams("Orchestra",
-                     List("cashregister", "carthorse", "radishes")) should be(
+    Anagram.anagrams("Orchestra", List("cashregister", "carthorse", "radishes")) should be(
       List("carthorse"))
   }
 
   test("detects anagrams using case-insensitive possible matches") {
     pending
-    Anagram.anagrams("orchestra",
-                     List("cashregister", "Carthorse", "radishes")) should be(
+    Anagram.anagrams("orchestra", List("cashregister", "Carthorse", "radishes")) should be(
       List("Carthorse"))
   }
 
-  test("does not detect a word as its own anagram") {
-    pending
-    Anagram.anagrams("banana", List("Banana")) should be(List())
-  }
-
   test("does not detect a anagram if the original word is repeated") {
     pending
     Anagram.anagrams("go", List("go Go GO")) should be(List())

data/tracks/scala/exercises/atbash-cipher/README.md

@@ -9,7 +9,7 @@ letter, the second with the second-last, and so on.
 
 An Atbash cipher for the Latin alphabet would be as follows:
 
-```plain
+```text
 Plain:  abcdefghijklmnopqrstuvwxyz
 Cipher: zyxwvutsrqponmlkjihgfedcba
 ```
@@ -23,6 +23,7 @@ being 5 letters, and punctuation is excluded. This is to make it harder to guess
 things based on word boundaries.
 
 ## Examples
+
 - Encoding `test` gives `gvhg`
 - Decoding `gvhg` gives `test`
 - Decoding `gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt` gives `thequickbrownfoxjumpsoverthelazydog`

data/tracks/scala/exercises/atbash-cipher/src/test/scala/AtbashCipherTest.scala

@@ -1,64 +1,68 @@
 import org.scalatest.{Matchers, FunSuite}
 
-/** @version 1.0.0 */
+/** @version 1.1.0 */
 class AtbashCipherTest extends FunSuite with Matchers {
 
   test("encode yes") {
-    AtbashCipher.encode("yes") should be ("bvh")
+    AtbashCipher.encode("yes") should be("bvh")
   }
 
   test("encode no") {
     pending
-    AtbashCipher.encode("no") should be ("ml")
+    AtbashCipher.encode("no") should be("ml")
   }
 
   test("encode OMG") {
     pending
-    AtbashCipher.encode("OMG") should be ("lnt")
+    AtbashCipher.encode("OMG") should be("lnt")
   }
 
   test("encode spaces") {
     pending
-    AtbashCipher.encode("O M G") should be ("lnt")
+    AtbashCipher.encode("O M G") should be("lnt")
   }
 
   test("encode mindblowingly") {
     pending
-    AtbashCipher.encode("mindblowingly") should be ("nrmwy oldrm tob")
+    AtbashCipher.encode("mindblowingly") should be("nrmwy oldrm tob")
   }
 
   test("encode numbers") {
     pending
-    AtbashCipher.encode("Testing,1 2 3, testing.") should be ("gvhgr mt123 gvhgr mt")
+    AtbashCipher.encode("Testing,1 2 3, testing.") should be(
+      "gvhgr mt123 gvhgr mt")
   }
 
   test("encode deep thought") {
     pending
-    AtbashCipher.encode("Truth is fiction.") should be ("gifgs rhurx grlm")
+    AtbashCipher.encode("Truth is fiction.") should be("gifgs rhurx grlm")
   }
 
   test("encode all the letters") {
     pending
-    AtbashCipher.encode("The quick brown fox jumps over the lazy dog.") should be ("gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt")
+    AtbashCipher.encode("The quick brown fox jumps over the lazy dog.") should be(
+      "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt")
   }
 
   test("decode exercism") {
     pending
-    AtbashCipher.decode("vcvix rhn") should be ("exercism")
+    AtbashCipher.decode("vcvix rhn") should be("exercism")
   }
 
   test("decode a sentence") {
     pending
-    AtbashCipher.decode("zmlyh gzxov rhlug vmzhg vkkrm thglm v") should be ("anobstacleisoftenasteppingstone")
+    AtbashCipher.decode("zmlyh gzxov rhlug vmzhg vkkrm thglm v") should be(
+      "anobstacleisoftenasteppingstone")
   }
 
   test("decode numbers") {
     pending
-    AtbashCipher.decode("gvhgr mt123 gvhgr mt") should be ("testing123testing")
+    AtbashCipher.decode("gvhgr mt123 gvhgr mt") should be("testing123testing")
   }
 
   test("decode all the letters") {
     pending
-    AtbashCipher.decode("gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt") should be ("thequickbrownfoxjumpsoverthelazydog")
+    AtbashCipher.decode("gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt") should be(
+      "thequickbrownfoxjumpsoverthelazydog")
   }
-}
+}

data/tracks/scala/exercises/bank-account/README.md

@@ -49,6 +49,5 @@ For more detailed info about the Scala track see the [help
 page](http://exercism.io/languages/scala).
 
 
-
 ## Submitting Incomplete Solutions
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/scala/exercises/beer-song/README.md

@@ -1,10 +1,10 @@
 # Beer Song
 
-Produce the lyrics to that beloved classic, that field-trip favorite: 99 Bottles of Beer on the Wall.
+Recite the lyrics to that beloved classic, that field-trip favorite: 99 Bottles of Beer on the Wall.
 
 Note that not all verses are identical.
 
-```plain
+```text
 99 bottles of beer on the wall, 99 bottles of beer.
 Take one down and pass it around, 98 bottles of beer on the wall.
 

data/tracks/scala/exercises/binary/README.md

@@ -7,10 +7,12 @@ string, your program should produce a decimal output. The
 program should handle invalid inputs.
 
 ## Note
+
 - Implement the conversion yourself.
   Do not use something else to perform the conversion for you.
 
 ## About Binary (Base-2)
+
 Decimal is a base-10 system.
 
 A number 23 in base 10 notation can be understood