trackler 2.0.0.1 → 2.0.0.2

data/tracks/scala/exercises/allergies/src/test/scala/allergies_test.scala

@@ -8,49 +8,60 @@ class AllergiesTest extends FlatSpec with Matchers {
   }
 
   it should "handle is allergic to eggs" in {
+    pending
     Allergies().isAllergicTo(Allergen.Eggs, 1) should equal (true)
   }
 
   it should "handle is allergic to eggs in addition to other stuff" in {
+    pending
     Allergies().isAllergicTo(Allergen.Eggs, 5) should equal (true)
   }
 
   it should "handle no allergies" in {
+    pending
     Allergies().allergies(0) should equal (List())
   }
 
   it should "handle allergic to just eggs" in {
+    pending
     Allergies().allergies(1) should equal (List(Allergen.Eggs))
   }
 
   it should "handle allergic to just peanuts" in {
+    pending
     Allergies().allergies(2) should equal (List(Allergen.Peanuts))
   }
 
   it should "handle allergic to just strawberries" in {
+    pending
     Allergies().allergies(8) should equal (List(Allergen.Strawberries))
   }
 
   it should "handle allergic to eggs and peanuts" in {
+    pending
     Allergies().allergies(3) should equal (List(Allergen.Eggs, Allergen.Peanuts))
   }
 
   it should "handle allergic to more than eggs but not peanuts" in {
+    pending
     Allergies().allergies(5) should equal (List(Allergen.Eggs, Allergen.Shellfish))
   }
 
   it should "handle allergic to lots of stuff" in {
+    pending
     Allergies().allergies(248) should equal (List(Allergen.Strawberries, Allergen.Tomatoes,
       Allergen.Chocolate, Allergen.Pollen, Allergen.Cats))
   }
 
   it should "handle allergic to everything" in {
+    pending
     Allergies().allergies(255) should equal (List(Allergen.Eggs, Allergen.Peanuts,
       Allergen.Shellfish, Allergen.Strawberries, Allergen.Tomatoes,
       Allergen.Chocolate, Allergen.Pollen, Allergen.Cats))
   }
 
   it should "ignore non allergen score parts" in {
+    pending
     Allergies().allergies(509) should equal (List(Allergen.Eggs,
       Allergen.Shellfish, Allergen.Strawberries, Allergen.Tomatoes,
       Allergen.Chocolate, Allergen.Pollen, Allergen.Cats))

data/tracks/scala/exercises/alphametics/build.sbt

@@ -0,0 +1,6 @@
+scalaVersion := "2.11.8"
+
+libraryDependencies += "org.scalatest" % "scalatest_2.11" % "2.2.5" % "test"
+
+libraryDependencies += "org.scala-lang.modules" %% "scala-parser-combinators" % "1.0.4"
+

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

@@ -0,0 +1,125 @@
+import scala.util.parsing.combinator.RegexParsers
+import Alphametics.Solution
+
+object Alphametics {
+  type Puzzle = String
+  type Solution = Map[Char, Int]
+
+  def solve(puzzle: Puzzle): Option[Solution] = {
+    val expression = parse(puzzle)
+    val uniqueLetters = puzzle filter (_.isLetter) distinct
+
+    expression flatMap solveExpression(uniqueLetters)
+  }
+
+  private def parse(str: String): Option[Expression[Boolean]] =
+    ExpressionParser.parse(str)
+
+  private def solveExpression(uniqueLetters: String)(boolExpr: Expression[Boolean]): Option[Solution] = {
+    def isSolution(solution: Solution): Boolean =
+      boolExpr.eval(solution) getOrElse false
+
+    def toSolution(tenChars: String): Solution =
+      tenChars.zipWithIndex.toMap filterKeys (_.isLetter)
+
+    val tenChars = uniqueLetters ++ Seq.fill(10 - uniqueLetters.size)('.')
+    tenChars.permutations map toSolution find isSolution
+  }
+}
+
+
+object ExpressionParser extends RegexParsers {
+
+  private implicit def parseResultToOption[T](parseResult: ParseResult[T]): Option[T] =
+    parseResult map (Some(_)) getOrElse None
+
+  def parse(str: String): Option[Expression[Boolean]] =
+    parseAll(booleanExpression, str)
+
+  private def booleanExpression: Parser[Expression[Boolean]] =
+    intExpression ~ "==" ~ intExpression ^^ {
+      case left ~ _ ~ right => Equals(left, right)
+    }
+
+  private def intExpression: Parser[Expression[Int]] =
+    intOperation | nonOperator
+
+  private def intOperation: Parser[Expression[Int]] =
+    nonOperator ~ operator ~ intExpression ^^ {
+      case left ~ op ~ right => op(left, right)
+    }
+
+  private def operator: Parser[(Expression[Int], Expression[Int]) => Expression[Int]] =
+    plus | mult | power
+
+  private def nonOperator: Parser[Expression[Int]] =
+    word | number
+
+  private val word: Parser[Word] =
+    "[A-Z]+".r ^^ (Word(_))
+
+  private val number: Parser[Number] =
+    "[0-9]+".r ^^ (n =>(Number(n.toInt)))
+
+  private val plus: Parser[(Expression[Int], Expression[Int]) => Expression[Int]] =
+    "+"  ^^ const(Plus(_, _))
+
+  private val mult: Parser[(Expression[Int], Expression[Int]) => Expression[Int]] =
+    "*" ^^ const(Mult(_, _))
+
+  private val power: Parser[(Expression[Int], Expression[Int]) => Expression[Int]] =
+    "^" ^^ const(Power(_, _))
+
+  private def const[A](a: A)(ignore: Any) = a
+}
+
+
+sealed trait Expression[T] {
+  def eval(solution: Solution): Option[T]
+}
+
+case class Word(word: String) extends Expression[Int] {
+  override def eval(solution: Solution) =
+    if (solution(word(0)) == 0) None
+    else Some((word map solution mkString) toInt)
+}
+
+case class Number(number: Int) extends Expression[Int] {
+  override def eval(solution: Solution) = Some(number)
+}
+
+trait Operation[A,B] extends Expression[B] {
+  val op: (A, A) => B
+  val left: Expression[A]
+  val right: Expression[A]
+  override def eval(solution: Solution) =
+    for {
+      l <- left.eval(solution)
+      r <- right.eval(solution)
+    } yield op(l, r)
+}
+
+case class Equals[A](override val left: Expression[A],
+    override val right: Expression[A]) extends Operation[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]
+{
+  override val op: (Int, Int) => Int = (_ + _)
+}
+
+case class Mult(override val left: Expression[Int],
+    override val right: Expression[Int]) extends Operation[Int, Int]
+{
+  override val op: (Int, Int) => Int = (_ * _)
+}
+
+case class Power(override val left: Expression[Int],
+    override val right: Expression[Int]) extends Operation[Int, Int]
+{
+  override val op: (Int, Int) => Int = math.pow(_, _).toInt
+}
+

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

@@ -0,0 +1,62 @@
+import org.scalatest.{FunSuite, Matchers}
+
+class AlphameticsTest extends FunSuite with Matchers {
+  test("puzzle with three letters") {
+    Alphametics.solve("I + BB == ILL") should
+      be (Some(Map('I' -> 1, 'B' -> 9, 'L' -> 0)))
+  }
+
+  test("solution must have unique value for each letter") {
+    pending
+    Alphametics.solve("A == B") should be (None)
+  }
+
+  test("leading zero solution is invalid") {
+    pending
+    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, 'S' -> 2, 'M' -> 1, 'O' -> 0)))
+  }
+
+  test("puzzle with six letters") {
+    pending
+    Alphametics.solve("NO + NO + TOO == LATE") should
+      be (Some(Map('N' -> 7, 'O' -> 4, 'T' -> 9, 'L' -> 1, 'A' -> 0, 'E' -> 2)))
+  }
+
+  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)))
+  }
+
+  test("puzzle with eight letters") {
+    pending
+    Alphametics.solve("SEND + MORE == MONEY") should
+      be (Some(Map('S' -> 9, 'E' -> 5, 'N' -> 6, 'D' -> 7, 'M' -> 1,
+            'O' -> 0, 'R' -> 8, '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)))
+  }
+
+  test("solve puzzle with multiplication") {
+    pending
+    Alphametics.solve("IF * DR == DORI") should
+      be (Some(Map('I' -> 8, 'F' -> 2, 'D' -> 3, 'R' -> 9, 'O' -> 1)))
+  }
+
+  test("solve puzzle with exponents") {
+    pending
+    Alphametics.solve("PI * R ^ 2 == AREA") should
+      be (Some(Map('P' -> 9, 'I' -> 6, 'R' -> 7, 'A' -> 4, 'E' -> 0)))
+  }
+}

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

@@ -6,34 +6,42 @@ class AtbashTest extends FlatSpec with Matchers {
   }
 
   it should "encode yes" in {
+    pending
     Atbash().encode("yes") should equal("bvh")
   }
 
   it should "encode OMG" in {
+    pending
     Atbash().encode("OMG") should equal("lnt")
   }
 
   it should "encode lowercase omg" in {
+    pending
     Atbash().encode("omg") should equal("lnt")
   }
 
   it should "encode O M G" in {
+    pending
     Atbash().encode("O M G ") should equal("lnt")
   }
 
   it should "encode and group string " in {
+    pending
     Atbash().encode("mindblowingly") should equal("nrmwy oldrm tob")
   }
 
   it should "encode string with digits and punctuation" in {
+    pending
     Atbash().encode("Testing, 1 2 3, testing. ") should equal("gvhgr mt123 gvhgr mt")
   }
 
   it should "encode \"Truth is fiction.\"" in {
+    pending
     Atbash().encode("Truth is fiction.") should equal("gifgs rhurx grlm")
   }
 
   it should "encode a long string" in {
+    pending
     Atbash().encode("The quick brown fox jumps over the lazy dog.") should
       equal("gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt")
   }

data/tracks/scala/exercises/bank-account/src/test/scala/BankAccountTest.scala

@@ -7,6 +7,7 @@ class BankAccountTest extends FunSuite with Matchers with Conductors with Integr
   }
 
   test("incrementing and checking balance") {
+    pending
     val acct = BankAccount()
     acct.getBalance should be (Some(0))
     acct.incrementBalance(10) should be (Some(10))
@@ -16,6 +17,7 @@ class BankAccountTest extends FunSuite with Matchers with Conductors with Integr
   }
 
   test("closed account should hold no balance") {
+    pending
     val acct = BankAccount()
     acct.closeAccount()
     acct.incrementBalance(10)
@@ -24,6 +26,7 @@ class BankAccountTest extends FunSuite with Matchers with Conductors with Integr
   }
 
   test("incrementing balance from multiple threads") {
+    pending
     val conductor = new Conductor
     import conductor._
 
@@ -47,6 +50,7 @@ class BankAccountTest extends FunSuite with Matchers with Conductors with Integr
   }
 
   test("incrementing balance from multiple threads - concurrent updates") {
+    pending
     val conductor = new Conductor
     import conductor._
 

data/tracks/scala/exercises/binary/src/test/scala/binary_test.scala

@@ -6,54 +6,67 @@ class BinaryTest extends FunSuite with Matchers {
   }
 
   test("invalid string - all chars invalid") {
+    pending
     Binary("carrot").toDecimal should be (0)
   }
 
   test("invalid string - leading char invalid") {
+    pending
     Binary("a1111").toDecimal should be (0)
   }
 
   test("invalid string - trailing char invalid") {
+    pending
     Binary("1111a").toDecimal should be (0)
   }
 
   test("invalid string - middle char invalid") {
+    pending
     Binary("0101F0").toDecimal should be (0)
   }
 
   test("invalid string - invalid digits") {
+    pending
     Binary("22").toDecimal should be (0)
   }
 
   test("1") {
+    pending
     Binary("1").toDecimal should be (1)
   }
 
   test("2") {
+    pending
     Binary("10").toDecimal should be (2)
   }
 
   test("3") {
+    pending
     Binary("11").toDecimal should be (3)
   }
 
   test("4") {
+    pending
     Binary("100").toDecimal should be (4)
   }
 
   test("9") {
+    pending
     Binary("1001").toDecimal should be (9)
   }
 
   test("26") {
+    pending
     Binary("11010").toDecimal should be (26)
   }
 
   test("Ultimate answer to everything") {
+    pending
     Binary("101010").toDecimal should be (42)
   }
 
   test("1128") {
+    pending
     Binary("10001101000").toDecimal should be (1128)
   }
 }

data/tracks/scala/exercises/binary-search-tree/src/test/scala/BstTest.scala

@@ -8,26 +8,32 @@ class BstTest extends FlatSpec with Matchers {
   }
 
   it should "retain data - char" in {
+    pending
     Bst('d').value should equal('d')
   }
 
   it should "insert less" in {
+    pending
     bst4.insert(2).left.get.value should equal(2)
   }
 
   it should "insert less - char" in {
+    pending
     Bst('d').insert('a').left.get.value should equal('a')
   }
 
   it should "insert same" in {
+    pending
     bst4.insert(4).left.get.value should equal(4)
   }
 
   it should "insert greater than" in {
+    pending
     bst4.insert(5).right.get.value should equal(5)
   }
 
   it should "handle complex tree - sort out of order list" in {
+    pending
     val bst = Bst.fromList(List(4, 2, 6, 1, 3, 7, 5))
     Bst.toList(bst) should equal((1 to 7).toList)
 
@@ -41,22 +47,27 @@ class BstTest extends FlatSpec with Matchers {
   }
 
   it should "iterating one element" in {
+    pending
     Bst.toList(bst4) should equal(List(4))
   }
 
   it should "iterating over smaller element" in {
+    pending
     Bst.toList(Bst.fromList(List(4, 2))) should equal(List(2, 4))
   }
 
   it should "iterating over larger element" in {
+    pending
     Bst.toList(Bst.fromList(List(4, 5))) should equal(List(4, 5))
   }
 
   it should "iterating over complex tree" in {
+    pending
     Bst.toList(Bst.fromList(List(4, 2, 1, 3, 6, 7, 5))) should equal((1 to 7).toList)
   }
 
   it should "iterating over complex tree - chars" in {
+    pending
     Bst.toList(Bst.fromList(List('d', 'b', 'a', 'c', 'f', 'g', 'e'))) should
       equal(('a' to 'g').toList)
   }

data/tracks/scala/exercises/bowling/Example.scala

@@ -0,0 +1,116 @@
+import scala.annotation.tailrec
+
+sealed trait Bowling {
+  def roll(pins: Int): Bowling
+
+  def score(): Either[Error, Int]
+}
+
+object Bowling {
+  def apply(): Bowling = new BowlingImpl(List.empty)
+
+  private class BowlingImpl(rolls: List[Int]) extends Bowling {
+    override def roll(pins: Int): Bowling = new BowlingImpl(rolls ++ List(pins))
+
+    override def score(): Either[Error, Int] =
+      if (rolls.isEmpty) {
+        Left(Error("Unstarted game cannot be scored"))
+      } else {
+        val fs = frames(rolls, 1)
+        if (fs.length != 10) {
+          Left(Error("Invalid number of frames - 10 expected"))
+        } else {
+          score(fs, 0)
+        }
+      }
+
+    @tailrec
+    private def score(frames: List[List[Int]], acc: Int): Either[Error, Int] =
+      frames match {
+        case x::xs => val frameScore = scoreFrame(x, xs, acc)
+          frameScore match {
+            case Right(sum) => score(xs, sum)
+            case error => error
+          }
+        case _ => Right(acc)
+      }
+
+    private def scoreFrame(frame: List[Int], remainingFrames: List[List[Int]], acc: Int): Either[Error, Int] = {
+      if (frame.exists(s => s < 0)) {
+        Left(Error("rolls can not score negative points"))
+      } else if (frame.exists(s => s > 10)) {
+        Left(Error("a roll can not score more than 10 points"))
+      } else if (remainingFrames.nonEmpty && frame.sum > 10) {
+        Left(Error("two rolls in a frame can not score more than 10 points"))
+      } else if (remainingFrames.isEmpty && !isValidFinalFrame(frame)) {
+        Left(Error("invalid final frame"))
+      } else {
+        val score = if (strike(frame)) {
+          acc + frame.sum + strikeBonus(remainingFrames)
+        } else if (spare(frame)) {
+          acc + frame.sum + spareBonus(remainingFrames)
+        } else {
+          acc + frame.sum
+        }
+
+        Right(score)
+      }
+    }
+
+    private def frames(rolls: List[Int], i: Int): List[List[Int]] = {
+      if (rolls.isEmpty) {
+        List.empty
+      }
+      else {
+        val throws = numThrows(rolls, i)
+        rolls.take(throws)::frames(rolls.drop(throws), i + 1)
+      }
+    }
+
+    private def numThrows(rolls: List[Int], frameNum: Int): Int = {
+      if (frameNum == 10) {
+        if (strike(rolls) || spare(rolls)) 3
+        else 2
+      } else if (strike(rolls)) {
+        1
+      } else {
+        2
+      }
+    }
+
+    private def strike(rolls: List[Int]): Boolean =
+      rolls.headOption.getOrElse(0) == 10
+
+    private def spare(rolls: List[Int]): Boolean =
+      rolls.take(2).sum == 10
+
+    private def strikeBonus(frames: List[List[Int]]): Int =
+      frames.take(2).flatten.take(2).sum
+
+    private def spareBonus(frames: List[List[Int]]): Int =
+      frames match {
+        case x::xs => x.head
+        case _ => 0
+      }
+
+    private def isValidFinalFrame(rolls: List[Int]): Boolean = {
+      val isStrike = strike(rolls)
+      val isSpare = spare(rolls)
+
+      if (rolls.length == 2) {
+        !isStrike && !isSpare
+      } else if (rolls.length == 3) {
+        (isStrike || isSpare) &&
+          (if (isStrike) {
+            rolls(1) == 10 || (rolls(1) + rolls(2) <= 10)
+          } else {
+            isSpare || rolls(1) + rolls(2) <= 10
+          })
+      } else {
+        false
+      }
+    }
+  }
+}
+
+case class Error(errorText: String)

data/tracks/scala/exercises/bowling/build.sbt

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

data/tracks/scala/exercises/bowling/src/main/scala/Bowling.scala

@@ -0,0 +1,11 @@
+sealed trait Bowling {
+  def roll(pins: Int): Bowling
+
+  def score(): Either[Error, Int]
+}
+
+object Bowling {
+  def apply(): Bowling = ???
+}
+
+case class Error(errorText: String)