trackler 1.0.4.0 → 1.0.4.1

data/tracks/scala/docs/RESOURCES.md

@@ -6,6 +6,7 @@ Exercism provides exercises and feedback but can be difficult to jump into for t
 * [Programming Scala](http://www.oreilly.com/ofps/)
 * [StackOverflow](http://stackoverflow.com/)
 * [Scala Exercises](https://www.scala-exercises.org/std_lib)
+* [The Neophyte's Guide to Scala](http://danielwestheide.com/scala/neophytes.html)
 
 ## Linting
 

data/tracks/scala/exercises/bracket-push/build.sbt

@@ -0,0 +1,4 @@
+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/bracket-push/example.scala

@@ -0,0 +1,23 @@
+import scala.util.parsing.combinator.RegexParsers
+
+object Brackets extends RegexParsers {
+  lazy val t = "[^\\[\\]\\(\\)\\{\\}]+".r
+
+  private def paren: Parser[String] =
+    ("(" ~ rep1(t | paren) ~ ")" |
+      "[" ~ rep1(t | paren) ~ "]" |
+      "{" ~ rep1(t | paren) ~ "}" |
+      "(" ~ ")" |
+      "[" ~ "]" |
+      "{" ~ "}" |
+      t) ^^ {
+      case _ => ""
+    }
+
+  private def all = rep(paren)
+
+  def areBalanced(s: String) = this.parseAll(all, s) match {
+    case NoSuccess(_, _) => false
+    case Success(_, _) => true
+  }
+}

data/tracks/scala/exercises/bracket-push/src/test/scala/BracketsTest.scala

@@ -0,0 +1,68 @@
+import org.scalatest.{FunSuite, Matchers}
+
+class BracketsTest extends FunSuite with Matchers {
+  test("paired square brackets") {
+    pending
+    Brackets.areBalanced("""[]""") should be (true)
+  }
+
+  test("empty string") {
+    pending
+    Brackets.areBalanced("""""") should be (true)
+  }
+
+  test("unpaired brackets") {
+    pending
+    Brackets.areBalanced("""[[""") should be (false)
+  }
+
+  test("wrong ordered brackets") {
+    pending
+    Brackets.areBalanced("""}{""") should be (false)
+  }
+
+  test("paired with whitespace") {
+    pending
+    Brackets.areBalanced("""{ }""") should be (true)
+  }
+
+  test("simple nested brackets") {
+    pending
+    Brackets.areBalanced("""{[]}""") should be (true)
+  }
+
+  test("several paired brackets") {
+    pending
+    Brackets.areBalanced("""{}[]""") should be (true)
+  }
+
+  test("paired and nested brackets") {
+    pending
+    Brackets.areBalanced("""([{}({}[])])""") should be (true)
+  }
+
+  test("unopened closing brackets") {
+    pending
+    Brackets.areBalanced("""{[)][]}""") should be (false)
+  }
+
+  test("unpaired and nested brackets") {
+    pending
+    Brackets.areBalanced("""([{])""") should be (false)
+  }
+
+  test("paired and wrong nested brackets") {
+    pending
+    Brackets.areBalanced("""[({]})""") should be (false)
+  }
+
+  test("math expression") {
+    pending
+    Brackets.areBalanced("""(((185 + 223.85) * 15) - 543)/2""") should be (true)
+  }
+
+  test("complex latex expression") {
+    pending
+    Brackets.areBalanced("""\left(\begin{array}{cc} \frac{1}{3} & x\\ \mathrm{e}^{x} &... x^2 \end{array}\right)""") should be (true)
+  }
+}

data/tracks/scala/exercises/change/src/test/scala/ChangeTest.scala

@@ -6,31 +6,38 @@ class ChangeTest extends FunSuite with Matchers {
   }
 
   test("multiple coin change") {
+    pending
     Change.findFewestCoins(15, List(1, 5, 10, 25, 100)) should be (Some(List(5, 10)))
   }
 
   test("change with Lilliputian Coins") {
+    pending
     Change.findFewestCoins(23, List(1, 4, 15, 20, 50)) should be (Some(List(4, 4, 15)))
   }
 
   test("change with Lower Elbonia Coins") {
+    pending
     Change.findFewestCoins(63, List(1, 5, 10, 21, 25)) should be (Some(List(21, 21, 21)))
   }
 
   test("large target values") {
+    pending
     Change.findFewestCoins(999, List(1, 2, 5, 10, 20, 50, 100)) should
       be (Some(List(2, 2, 5, 20, 20, 50, 100, 100, 100, 100, 100, 100, 100, 100, 100)))
   }
 
   test("no coins make 0 change") {
+    pending
     Change.findFewestCoins(0, List(1, 5, 10, 21, 25)) should be (Some(List()))
   }
 
   test("error testing for change smaller than the smallest of coins") {
+    pending
     Change.findFewestCoins(3, List(5, 10)) should be (None)
   }
 
   test("cannot find negative change values") {
+    pending
     Change.findFewestCoins(-5, List(1, 2, 5)) should be (None)
   }
 }

data/tracks/scala/exercises/sgf-parsing/build.sbt

@@ -0,0 +1,7 @@
+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/sgf-parsing/example.scala

@@ -0,0 +1,66 @@
+import scala.util.parsing.combinator.RegexParsers
+
+object Sgf extends RegexParsers {
+
+  type Tree[A] = Node[A] // to separate the type from the constructor, cf. Haskell's Data.Tree
+  type Forest[A] = List[Tree[A]]
+  case class Node[A](rootLabel: A, subForest: Forest[A] = List())
+
+  // A tree of nodes.
+  type SgfTree = Tree[SgfNode]
+
+  // A node is a property list, each key can only occur once.
+  // Keys may have multiple values associated with them.
+  type SgfNode = Map[String, List[String]]
+
+  override val skipWhitespace = false
+
+  private implicit def parseResultToOption[T](parseResult: ParseResult[T]): Option[T] =
+    parseResult map (Some(_)) getOrElse None
+
+  def parseSgf(text: String): Option[SgfTree] =
+    parseAll(sgfGameTree, text)
+
+  private val sgfGameTree: Parser[SgfTree] =
+    ("(" ~ rep1(sgfNode) ~ rep(sgfGameTree) ~ ")") ^^ {
+      case _ ~ (rootNode::subNodes) ~ subTrees ~ _ =>
+        val subNodeForest: List[SgfTree] = subNodes map (Node(_))
+        Node(rootNode, subNodeForest ++ subTrees)
+    } named "sgfGameTree"
+
+  private val sgfNode: Parser[SgfNode] =
+    ";" ~ (sgfProperty | emptySgfNode) ^^ {
+      case _ ~ sgfNode => sgfNode
+    } named "sgfNode"
+
+  private val emptySgfNode: Parser[SgfNode] =
+    "" ^^ const(Map())
+
+  private def sgfProperty: Parser[SgfNode] =
+    propIdent ~ propValues ^^ {
+      case identifier ~ values => Map(identifier -> values)
+    } named "sgfProperty"
+
+  private val propIdent: Parser[String] = "[A-Z]".r named "propIdent"
+
+  private val propValues: Parser[List[String]] = rep1(propValue)
+
+  private val propValue: Parser[String] =
+    "[" ~ rep1(propValuePart) ~ "]" ^^ {
+      case _ ~ values ~ _ => values mkString
+    } named "propValue"
+
+  private val propValuePart: Parser[String] = {
+    implicit class AsStringParser(self: String) { def p: Parser[String] = self }
+    val ignore = const("") _
+
+    val escapedNewline: Parser[String] = "\\\n".p ^^ ignore
+    val escapedChar: Parser[String] = """\\.""".r ^^ (_.takeRight(1))
+    val whitespace: Parser[String] = """\s""".r ^^ const(" ")
+    val ident: Parser[String] = "[^]]".r
+
+    escapedNewline | escapedChar | whitespace | ident
+  }
+
+  private def const[A](a: A)(ignore: Any) = a
+}

data/tracks/scala/exercises/sgf-parsing/src/main/scala/Sgf.scala

@@ -0,0 +1,17 @@
+import scala.util.parsing.combinator.RegexParsers
+
+object Sgf extends RegexParsers {
+
+  type Tree[A] = Node[A] // to separate the type from the constructor, cf. Haskell's Data.Tree
+  type Forest[A] = List[Tree[A]]
+  case class Node[A](rootLabel: A, subForest: Forest[A] = List())
+
+  // A tree of nodes.
+  type SgfTree = Tree[SgfNode]
+
+  // A node is a property list, each key can only occur once.
+  // Keys may have multiple values associated with them.
+  type SgfNode = Map[String, List[String]]
+
+  def parseSgf(text: String): Option[SgfTree] = ???
+}

data/tracks/scala/exercises/sgf-parsing/src/test/scala/SgfTest.scala

@@ -0,0 +1,66 @@
+import org.scalatest.{FunSuite, Matchers}
+import Sgf._
+
+class SgfTest extends FunSuite with Matchers {
+  test("parse \"\"") {
+    Sgf.parseSgf("") should be (None)
+  }
+
+  test("parse \"()\"") {
+    pending
+    Sgf.parseSgf("()") should be (None)
+  }
+
+  test("parse \";\"") {
+    pending
+    Sgf.parseSgf(";") should be (None)
+  }
+
+  test("parse \"(;)\"") {
+    pending
+    Sgf.parseSgf("(;)") should be (Some(Node(Map())))
+  }
+
+  test("parse \"(;A[B])\"") {
+    Sgf.parseSgf("(;A[B])") should be (Some(Node(Map("A" -> List("B")))))
+  }
+
+  test("parse \"(;a)\"") {
+    pending
+    Sgf.parseSgf("(;a)") should be (None)
+  }
+
+  test("parse \"(;a[b])\"") {
+    pending
+    Sgf.parseSgf("(;a[b])") should be (None)
+  }
+
+  test("parse \"(;Aa[b])\"") {
+    pending
+    Sgf.parseSgf("(;Aa[b])") should be (None)
+  }
+
+  test("parse \"(;A[B];B[C])\"") {
+    pending
+    Sgf.parseSgf("(;A[B];B[C])") should be (
+        Some(Node(Map("A" -> List("B")), List(Node(Map("B" -> List("C")))))))
+  }
+
+  test("parse \"(;A[B](;B[C])(;C[D]))\"") {
+    pending
+    Sgf.parseSgf("(;A[B](;B[C])(;C[D]))") should be (
+        Some(Node(Map("A" -> List("B")), List(Node(Map("B" -> List("C"))),
+                                              Node(Map("C" -> List("D")))))))
+  }
+
+  test("parse \"(;A[b][c][d])\"") {
+    pending
+    Sgf.parseSgf("(;A[b][c][d])") should be (Some(Node(Map("A" -> List("b", "c", "d")))))
+  }
+
+  test("""parse "(;A[\\]b\nc\\\nd\t\te\\\\ \\\n\\]])"""") {
+    pending
+    Sgf.parseSgf("(;A[\\]b\nc\\\nd\t\te\\\\ \\\n\\]])") should be (
+        Some(Node(Map("A" -> List("]b cd  e\\ ]")))))
+  }
+}

data/tracks/scala/exercises/zebra-puzzle/build.sbt

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

data/tracks/scala/exercises/zebra-puzzle/example.scala

@@ -0,0 +1,152 @@
+object ZebraPuzzle {
+
+  trait HousePart
+
+  sealed trait Color extends HousePart
+  case object Red extends Color
+  case object Green extends Color
+  case object Yellow extends Color
+  case object Blue extends Color
+  case object Ivory extends Color
+  object Color { val values: List[Color] = List(Red, Green, Yellow, Blue, Ivory) }
+
+  sealed trait Resident extends HousePart
+  case object Englishman extends Resident
+  case object Spaniard extends Resident
+  case object Ukrainian extends Resident
+  case object Norwegian extends Resident
+  case object Japanese extends Resident
+  object Resident {
+    val values: List[Resident] =
+      List(Englishman, Spaniard, Ukrainian, Norwegian, Japanese)
+  }
+
+  sealed trait Pet extends HousePart
+  case object Dog extends Pet
+  case object Snails extends Pet
+  case object Fox extends Pet
+  case object Horse extends Pet
+  case object Zebra extends Pet
+  object Pet { val values: List[Pet] = List(Dog, Snails, Fox, Horse, Zebra) }
+
+  sealed trait Beverage extends HousePart
+  case object Coffee extends Beverage
+  case object Tea extends Beverage
+  case object Milk extends Beverage
+  case object OrangeJuice extends Beverage
+  case object Water extends Beverage
+  object Beverage {
+    val values: List[Beverage] = List(Coffee, Tea, Milk, OrangeJuice, Water)
+  }
+
+  sealed trait Cigarette extends HousePart
+  case object OldGold extends Cigarette
+  case object Kools extends Cigarette
+  case object Chesterfields extends Cigarette
+  case object LuckyStrike extends Cigarette
+  case object Parliaments extends Cigarette
+  object Cigarette {
+    val values: List[Cigarette] = List(OldGold, Kools, Chesterfields, LuckyStrike, Parliaments)
+  }
+
+  sealed trait Position extends HousePart { def fromEnum: Int }
+  case object One extends Position { override val fromEnum = 0 }
+  case object Two extends Position { override val fromEnum = 1 }
+  case object Three extends Position { override val fromEnum = 2 }
+  case object Four extends Position { override val fromEnum = 3 }
+  case object Five extends Position { override val fromEnum = 4 }
+  object Position { val values: List[Position] = List(One, Two, Three, Four, Five) }
+
+  case class House(position: Position, color: Color, resident : Resident,
+      beverage: Beverage, cigarette: Cigarette, pet: Pet)
+  {
+    def toTheRight(other: House): Boolean = 
+      this.position.fromEnum == other.position.fromEnum + 1
+
+    def nextTo(other: House): Boolean =
+      math.abs(this.position.fromEnum - other.position.fromEnum) == 1
+  }
+
+  case class Solution(waterDrinker: Resident, zebraOwner: Resident)
+
+  lazy val solve: Solution = {
+    def residentWith(what: House => HousePart, value: HousePart): Resident =
+      houseWith(what, value, fiveHouses).resident
+
+    val waterDrinker = residentWith((_.beverage), Water)
+    val zebraOwner = residentWith((_.pet), Zebra)
+
+    Solution(waterDrinker = waterDrinker, zebraOwner = zebraOwner)
+  }
+
+  lazy val fiveHouses: List[House] = {
+    def housesAtPosition(position: Position): List[House] =
+      validHouses filter (_.position == position)
+
+    val candidates = for {
+      one   <- housesAtPosition(One)
+      two   <- housesAtPosition(Two)   if uniqueHouses(List(one, two))
+      three <- housesAtPosition(Three) if uniqueHouses(List(one, two, three))
+      four  <- housesAtPosition(Four)  if uniqueHouses(List(one, two, three, four))
+      five  <- housesAtPosition(Five)  if uniqueHouses(List(one, two, three, four, five))
+      candidates = List(one, two, three, four, five) if validPositions(candidates)
+    } yield candidates
+
+    candidates head
+  }
+
+  private lazy val validHouses: List[House] =
+    for {
+      position <- Position.values
+      color <- Color.values
+      resident <- Resident.values
+      beverage <- Beverage.values
+      cigarette <- Cigarette.values
+      pet <- Pet.values
+      house = House(position, color, resident, beverage, cigarette, pet) if validHouse(house)
+    } yield house
+
+  def validHouse(house: House): Boolean = {
+    val House(position, color, resident, beverage, cigarette, pet) = house
+    List(
+      (color == Red, resident == Englishman),
+      (resident == Spaniard, pet == Dog),
+      (color == Green, beverage == Coffee),
+      (resident == Ukrainian, beverage == Tea),
+      (cigarette == OldGold, pet == Snails),
+      (color == Yellow, cigarette == Kools),
+      (position == Three, beverage == Milk),
+      (position == One, resident == Norwegian),
+      (beverage == OrangeJuice, cigarette == LuckyStrike),
+      (resident == Japanese, cigarette == Parliaments)) forall (iff _).tupled
+  }
+
+  private def iff(p1: Boolean, p2: Boolean): Boolean =
+    (p1, p2) match {
+      case (true, true) => true
+      case (false, false) => true
+      case _ => false
+    }
+
+  private def uniqueHouses(houses: List[House]): Boolean = {
+    def unique(what: House => HousePart): Boolean =
+      (houses map what distinct).length == houses.length
+
+    unique (_.color) && unique (_.resident) && unique (_.beverage) &&
+    unique (_.cigarette) && unique (_.pet)
+  }
+
+  private def houseWith(what: House => HousePart, value: HousePart, houses: List[House]): House =
+    houses find (what(_) == value) getOrElse(throw new Exception(s"could not find house with $value"))
+
+  private def validPositions(houses: List[House]): Boolean = {
+    def _houseWith(what: House => HousePart, value: HousePart): House =
+      houseWith(what, value, houses)
+
+    (_houseWith(_.color,  Green) toTheRight _houseWith(_.color, Ivory)) &&
+    (_houseWith(_.cigarette, Chesterfields) nextTo _houseWith(_.pet, Fox)) &&
+    (_houseWith(_.cigarette, Kools) nextTo _houseWith(_.pet, Horse)) &&
+    (_houseWith(_.resident, Norwegian) nextTo _houseWith(_.color, Blue))
+  }
+}
+