trackler 2.1.0.27 → 2.1.0.28

data/tracks/purescript/exercises/hamming/bower.json

@@ -0,0 +1,16 @@
+{
+  "name": "hamming",
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "bower_components",
+    "output"
+  ],
+  "dependencies": {
+    "purescript-prelude": "^3.0.0"
+  },
+  "devDependencies": {
+    "purescript-psci-support": "^3.0.0",
+    "purescript-test-unit": "^11.0.0"
+  }
+}

data/tracks/purescript/exercises/hamming/examples/src/Hamming.purs

@@ -0,0 +1,14 @@
+module Hamming
+  ( distance
+  ) where
+
+import Prelude
+import Data.Maybe (Maybe(Just, Nothing))
+import Data.Tuple (Tuple(..))
+import Data.String (uncons)
+
+distance :: String -> String -> Maybe Int
+distance dna1 dna2 = case Tuple (uncons dna1) (uncons dna2) of
+  Tuple (Just {head: h1, tail: t1}) (Just {head: h2, tail: t2}) -> (if h1 /= h2 then ((+) 1) else id) <$> distance t1 t2
+  Tuple Nothing Nothing -> Just 0
+  Tuple _ _ -> Nothing

data/tracks/purescript/exercises/hamming/test/Main.purs

@@ -0,0 +1,46 @@
+-- Test/exercise version: "1.0.0"
+
+module Test.Main where
+
+import Prelude
+import Control.Monad.Eff (Eff)
+import Test.Unit (suite, test)
+import Test.Unit.Main (runTest)
+import Test.Unit.Assert as Assert
+import Data.String as String
+import Data.Maybe (Maybe(Just, Nothing))
+import Hamming (distance)
+
+main :: Eff _ Unit
+main = runTest do
+  suite "hamming" do
+    test "identical strands" $
+      Assert.equal (Just 0) (distance "A" "A")
+    test "long identical strands" $
+      Assert.equal (Just 0) (distance "GGACTGA" "GGACTGA")
+    test "complete distance in single nucleotide strands" $
+      Assert.equal (Just 1) (distance "A" "G")
+    test "complete distance in small strands" $
+      Assert.equal (Just 2) (distance "AG" "CT")
+    test "small distance in small strands" $
+      Assert.equal (Just 1) (distance "AT" "CT")
+    test "small distance" $
+      Assert.equal (Just 1) (distance "GGACG" "GGTCG")
+    test "small distance in long strands" $
+      Assert.equal (Just 2) (distance "ACCAGGG" "ACTATGG")
+    test "non-unique character in first strand" $
+      Assert.equal (Just 1) (distance "AGA" "AGG")
+    test "non-unique character in second strand" $
+      Assert.equal (Just 1) (distance "AGG" "AGA")
+    test "same nucleotides in different positions" $
+      Assert.equal (Just 2) (distance "TAG" "GAT")
+    test "large distance" $
+      Assert.equal (Just 4) (distance "GATACA" "GCATAA")
+    test "large distance in off-by-one strand" $
+      Assert.equal (Just 9) (distance "GGACGGATTCTG" "AGGACGGATTCT")
+    test "empty strands" $
+      Assert.equal (Just 0) (distance "" "")
+    test "disallow first strand longer" $
+      Assert.equal Nothing (distance "AATG" "AAA")
+    test "disallow second strand longer" $
+      Assert.equal Nothing (distance "ATA" "AGTG")

data/tracks/scala/config.json

@@ -532,6 +532,13 @@
             "Dictionaries"
          ]
       },
+      {
+         "slug":"book-store",
+         "difficulty":5,
+         "topics":[
+            "Recursion"
+         ]
+      },
       {
          "slug":"nth-prime",
          "difficulty":6,

data/tracks/scala/exercises/bob/example.scala

@@ -1,5 +1,5 @@
-class Bob {
-  def hey(statement: String): String = statement match {
+object Bob {
+  def response(statement: String): String = statement match {
     case Shouting() => "Whoa, chill out!"
     case Question() => "Sure."
     case Silence() => "Fine. Be that way!"
@@ -16,7 +16,7 @@ class Bob {
   }
 
   case object Question {
-    def unapply(statement: String) = statement.endsWith("?")
+    def unapply(statement: String) = statement.trim.endsWith("?")
   }
 
   case object Silence {

data/tracks/scala/exercises/bob/src/main/scala/Bob.scala

@@ -1,3 +1,3 @@
-class Bob {
-  def hey(statement: String): String = ???
+object Bob {
+  def response(statement: String): String = ???
 }

data/tracks/scala/exercises/bob/src/test/scala/BobTest.scala

@@ -1,102 +1,132 @@
-import org.scalatest._
+import org.scalatest.{Matchers, FunSuite}
 
-class BobTest extends FlatSpec with Matchers {
-  def teenager = new Bob
+/** @version 1.0.0 */
+class BobTest extends FunSuite with Matchers {
 
-  it should "respond to a statement" in {
-    val response = teenager.hey("Tom-ay-to, tom-aaaah-to.")
-    response should be ("Whatever.")
+  test("stating something") {
+    Bob.response("Tom-ay-to, tom-aaaah-to.") should be ("Whatever.")
   }
 
-  it should "respond to shouting" in {
+  test("shouting") {
     pending
-    val response = teenager.hey("WATCH OUT!")
-    response should be ("Whoa, chill out!")
+    Bob.response("WATCH OUT!") should be ("Whoa, chill out!")
   }
 
-  it should "respond to questions" in {
+  test("shouting gibberish") {
     pending
-    val response = teenager.hey("Does this cryogenic chamber make me look fat?")
-    response should be ("Sure.")
+    Bob.response("FCECDFCAAB") should be ("Whoa, chill out!")
   }
 
-  it should "allow questions to end with numbers" in {
+  test("asking a question") {
     pending
-    val response = teenager.hey("You are what, like 15?")
-    response should be ("Sure.")
+    Bob.response("Does this cryogenic chamber make me look fat?") should be ("Sure.")
   }
 
-  it should "respond to talking forcefully" in {
+  test("asking a numeric question") {
     pending
-    val response = teenager.hey("Let's go work out at the gym!")
-    response should be ("Whatever.")
+    Bob.response("You are, what, like 15?") should be ("Sure.")
   }
 
-  it should "allow acroynms in regular speech" in {
+  test("asking gibberish") {
     pending
-    val response = teenager.hey("It's OK if you don't want to go to the DMV.")
-    response should be ("Whatever.")
+    Bob.response("fffbbcbeab?") should be ("Sure.")
   }
 
-  it should "see forceful questions as shouting" in {
+  test("talking forcefully") {
     pending
-    val response = teenager.hey("WHAT THE HELL WERE YOU THINKING?")
-    response should be ("Whoa, chill out!")
+    Bob.response("Let's go make out behind the gym!") should be ("Whatever.")
   }
 
-  it should "allow numbers when shouting" in {
+  test("using acronyms in regular speech") {
     pending
-    val response = teenager.hey("1, 2, 3, GO!")
-    response should be ("Whoa, chill out!")
+    Bob.response("It's OK if you don't want to go to the DMV.") should be ("Whatever.")
   }
 
-  it should "see only numbers as speech" in {
+  test("forceful question") {
     pending
-    val response = teenager.hey("1, 2, 3")
-    response should be ("Whatever.")
+    Bob.response("WHAT THE HELL WERE YOU THINKING?") should be ("Whoa, chill out!")
   }
 
-  it should "respond to questions with only numbers" in {
+  test("shouting numbers") {
     pending
-    val response = teenager.hey("4?")
-    response should be ("Sure.")
+    Bob.response("1, 2, 3 GO!") should be ("Whoa, chill out!")
   }
 
-  it should "respond to shouting with no exclamation mark" in {
+  test("only numbers") {
     pending
-    val response = teenager.hey("I HATE YOU")
-    response should be ("Whoa, chill out!")
+    Bob.response("1, 2, 3") should be ("Whatever.")
   }
 
-  it should "respond to statements with ? in the middle" in {
+  test("question with only numbers") {
     pending
-    val response = teenager.hey("Ending with ? means a question.")
-    response should be ("Whatever.")
+    Bob.response("4?") should be ("Sure.")
   }
 
-  it should "respond to prattling on" in {
+  test("shouting with special characters") {
     pending
-    val response = teenager.hey("Wait! Hang on. Are you going to be OK?")
-    response should be ("Sure.")
+    Bob.response("ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!") should be ("Whoa, chill out!")
   }
 
-  it should "respond to silence" in {
+  test("shouting with no exclamation mark") {
     pending
-    val response = teenager.hey("")
-    response should be ("Fine. Be that way!")
+    Bob.response("I HATE YOU") should be ("Whoa, chill out!")
   }
 
-  it should "respond to prolonged silence" in {
+  test("statement containing question mark") {
     pending
-    val response = teenager.hey("       ")
-    response should be ("Fine. Be that way!")
+    Bob.response("Ending with ? means a question.") should be ("Whatever.")
   }
 
-  it should "respond to multiple line questions" in {
+  test("non-letters with question") {
     pending
-    val response = teenager.hey("""
+    Bob.response(":) ?") should be ("Sure.")
+  }
+
+  test("prattling on") {
+    pending
+    Bob.response("Wait! Hang on. Are you going to be OK?") should be ("Sure.")
+  }
+
+  test("silence") {
+    pending
+    Bob.response("") should be ("Fine. Be that way!")
+  }
+
+  test("prolonged silence") {
+    pending
+    Bob.response("          ") should be ("Fine. Be that way!")
+  }
+
+  test("alternate silence") {
+    pending
+    Bob.response("										") should be ("Fine. Be that way!")
+  }
+
+  test("multiple line question") {
+    pending
+    Bob.response("""
 Does this cryogenic chamber make me look fat?
-no""")
-    response should be ("Whatever.")
+no""") should be ("Whatever.")
+  }
+
+  test("starting with whitespace") {
+    pending
+    Bob.response("         hmmmmmmm...") should be ("Whatever.")
+  }
+
+  test("ending with whitespace") {
+    pending
+    Bob.response("Okay if like my  spacebar  quite a bit?   ") should be ("Sure.")
+  }
+
+  test("other whitespace") {
+    pending
+    Bob.response("""
+                 	""") should be ("Fine. Be that way!")
+  }
+
+  test("non-question ending with whitespace") {
+    pending
+    Bob.response("This is a statement ending with whitespace      ") should be ("Whatever.")
   }
-}
+}

data/tracks/scala/exercises/book-store/build.sbt

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

data/tracks/scala/exercises/book-store/example.scala

@@ -0,0 +1,49 @@
+object BookStore {
+  private val bookPrice = 8
+  private val discounts =
+    Map((1, 0.0),
+      (2, 5.0),
+      (3, 10.0),
+      (4, 20.0),
+      (5, 25.0))
+
+  def total(books: List[Int]): Double = total(books, 0)
+
+  private def total(books: List[Int], acc: Double): Double = {
+    if (books.isEmpty) {
+      acc
+    } else {
+      val bookNums = books.distinct
+
+      (1 to bookNums.size).foldLeft(Double.MaxValue)((minPrice, groupSize) => {
+        val itemsToRemove = bookNums.take(groupSize)
+        val remainingBooks = getRemainingBooks(books, itemsToRemove)
+        val price = total(remainingBooks, acc + groupCost(groupSize))
+        scala.math.min(price, minPrice)
+      })
+    }
+  }
+
+  private def groupCost(groupSize: Int): Double = {
+    discounts get groupSize match {
+      case Some(discount) => bookPrice * groupSize * (100.0 - discount) / 100.0
+      case _ => bookPrice * groupSize
+    }
+  }
+
+  private def getRemainingBooks(books: List[Int], itemsToRemove: List[Int]): List[Int] = {
+    var remainingBooks = books
+
+    for (item <- itemsToRemove) {
+      remainingBooks = removeFirst(remainingBooks)(_ == item)
+    }
+
+    remainingBooks
+  }
+
+  // drops the first item in the passed in list that matches the predicate.
+  private def removeFirst[T](list: List[T])(pred: (T) => Boolean): List[T] = {
+    val (before, atAndAfter) = list span (x => !pred(x))
+    before ::: atAndAfter.drop(1)
+  }
+}

data/tracks/scala/exercises/book-store/src/test/scala/BookStoreTest.scala

@@ -0,0 +1,70 @@
+
+import org.scalatest.{Matchers, FunSuite}
+
+/** @version 1.0.1 */
+class BookStoreTest extends FunSuite with Matchers {
+
+  test("Only a single book") {
+    BookStore.total(List(1)) should be (8)
+  }
+
+  test("Two of the same book") {
+    pending
+    BookStore.total(List(2, 2)) should be (16)
+  }
+
+  test("Empty basket") {
+    pending
+    BookStore.total(List()) should be (0)
+  }
+
+  test("Two different books") {
+    pending
+    BookStore.total(List(1, 2)) should be (15.2)
+  }
+
+  test("Three different books") {
+    pending
+    BookStore.total(List(1, 2, 3)) should be (21.6)
+  }
+
+  test("Four different books") {
+    pending
+    BookStore.total(List(1, 2, 3, 4)) should be (25.6)
+  }
+
+  test("Five different books") {
+    pending
+    BookStore.total(List(1, 2, 3, 4, 5)) should be (30)
+  }
+
+  test("Two groups of four is cheaper than group of five plus group of three") {
+    pending
+    BookStore.total(List(1, 1, 2, 2, 3, 3, 4, 5)) should be (51.2)
+  }
+
+  test("Group of four plus group of two is cheaper than two groups of three") {
+    pending
+    BookStore.total(List(1, 1, 2, 2, 3, 4)) should be (40.8)
+  }
+
+  test("Two each of first 4 books and 1 copy each of rest") {
+    pending
+    BookStore.total(List(1, 1, 2, 2, 3, 3, 4, 4, 5)) should be (55.6)
+  }
+
+  test("Two copies of each book") {
+    pending
+    BookStore.total(List(1, 1, 2, 2, 3, 3, 4, 4, 5, 5)) should be (60)
+  }
+
+  test("Three copies of first book and 2 each of remaining") {
+    pending
+    BookStore.total(List(1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1)) should be (68)
+  }
+
+  test("Three each of first 2 books and 2 each of remaining books") {
+    pending
+    BookStore.total(List(1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1, 2)) should be (75.2)
+  }
+}

data/tracks/scala/exercises/difference-of-squares/example.scala

@@ -1,10 +1,10 @@
 import scala.math.pow
 
-object Squares {
+object DifferenceOfSquares {
 
   def sumOfSquares(n: Int): Int = n * (n + 1) * (2 * n + 1) / 6
 
-  def squareOfSums(n: Int): Int = pow((n * (n + 1) / 2), 2).toInt
+  def squareOfSum(n: Int): Int = pow((n * (n + 1) / 2), 2).toInt
 
-  def difference(n: Int): Int = squareOfSums(n) - sumOfSquares(n)
+  def differenceOfSquares(n: Int): Int = squareOfSum(n) - sumOfSquares(n)
 }