trackler 2.0.3.8 → 2.0.3.9

data/tracks/rust/problems.md

@@ -36,6 +36,7 @@ pascals-triangle | Math, Vec, Index (optional)
 scrabble-score |  chaining higher-order functions, HashMap (optional)
 pangram | filter, ascii (optional)
 nucleotide-count |  filter, entry api, mutablity, match
+largest-series-product | Result, windows, higher-order functions, char
 word-count |  hashmap, str vs string, chars, entry api
 atbash-cipher | str vs string, primitive types, iterators, chars, ascii
 etl |  btree

data/tracks/scala/.gitignore

@@ -1,6 +1,7 @@
 *.beam
 *.swp
 .DS_Store
+.idea
 tmp
 target/
 bin/configlet

data/tracks/scala/exercises/hello-world/src/test/scala/HelloWorldTest.scala

@@ -6,10 +6,12 @@ class HelloWorldTest extends FunSuite with Matchers {
   }
 
   test("with name") {
+    pending
     HelloWorld.hello("Jane") should be ("Hello, Jane!")
   }
 
   test("with umlaut name") {
+    pending
     HelloWorld.hello("Jürgen") should be ("Hello, Jürgen!")
   }
 }

data/tracks/scala/exercises/nth-prime/example.scala

@@ -4,5 +4,7 @@ object Prime {
   private lazy val primes: Stream[BigInt] =
     Stream.cons(BigInt(2), primes.map(b => new BigInt(b.bigInteger.nextProbablePrime)))
 
-  def nth(n: Int): Int = primes.drop(n - 1).head.toInt
+  def nth(n: Int): Option[Int] =
+    if (n < 1) None
+    else Some(primes.drop(n - 1).head.toInt)
 }

data/tracks/scala/exercises/nth-prime/src/test/scala/PrimeTest.scala

@@ -2,31 +2,36 @@ import org.scalatest.{Matchers, FlatSpec}
 
 class PrimeTest extends FlatSpec with Matchers {
   it should "calculate 1st prime" in {
-    Prime.nth(1) should be (2)
+    Prime.nth(1) should be (Some(2))
   }
 
   it should "calculate 2nd prime" in {
     pending
-    Prime.nth(2) should be (3)
+    Prime.nth(2) should be (Some(3))
   }
 
   it should "calculate 6th prime" in {
     pending
-    Prime.nth(6) should be (13)
+    Prime.nth(6) should be (Some(13))
   }
 
   it should "calculate 1000th prime" in {
     pending
-    Prime.nth(1000) should be (7919)
+    Prime.nth(1000) should be (Some(7919))
   }
 
   it should "calculate 10000th prime" in {
     pending
-    Prime.nth(10000) should be (104729)
+    Prime.nth(10000) should be (Some(104729))
   }
 
   it should "calculate 10001th prime" in {
     pending
-    Prime.nth(10001) should be (104743)
+    Prime.nth(10001) should be (Some(104743))
+  }
+
+  it should "not find zeroth prime" in {
+    pending
+    Prime.nth(0) should be (None)
   }
 }

data/tracks/scala/exercises/palindrome-products/src/test/scala/PalindromeProductsTest.scala

@@ -9,42 +9,49 @@ class PalindromeProductsTest extends FlatSpec with Matchers {
   }
 
   it should "find largest palindrome from a single digit factors" in {
+    pending
     val (value, factors) = PalindromeProducts(0, 9).largest
     value should be (9)
     factors should be (Set((1, 9), (3, 3)))
   }
 
   it should "find smallest palindrome from a double digit factors" in {
+    pending
     val (value, factors) = PalindromeProducts(10, 99).smallest
     value should be (121)
     factors should be (Set((11, 11)))
   }
 
   it should "find largest palindrome from a double digit factors" in {
+    pending
     val (value, factors) = PalindromeProducts(10, 99).largest
     value should be (9009)
     factors should be (Set((91, 99)))
   }
 
   it should "find smallest palindrome from a triple digit factors" in {
+    pending
     val (value, factors) = PalindromeProducts(100, 999).smallest
     value should be (10201)
     factors should be (Set((101, 101)))
   }
 
   it should "find largest palindrome from a triple digit factors" in {
+    pending
     val (value, factors) = PalindromeProducts(100, 999).largest
     value should be (906609)
     factors should be (Set((913, 993)))
   }
 
   it should "find smallest palindrome from a four digit factors" in {
+    pending
     val (value, factors) = PalindromeProducts(1000, 9999).smallest
     value should be (1002001)
     factors should be (Set((1001, 1001)))
   }
 
   it should "find largest palindrome from a four digit factors" in {
+    pending
     val (value, factors) = PalindromeProducts(1000, 9999).largest
     value should be (99000099)
     factors should be (Set((9901, 9999)))

data/tracks/scala/exercises/parallel-letter-frequency/HINTS.md

@@ -0,0 +1,26 @@
+## Hints
+According to [this terminology](http://chimera.labs.oreilly.com/books/1230000000929/ch01.html#sec_terminology) you should write a *parallel* and *deterministic*
+program and (by all means!) let Scala deal with the *concurrency* aspect.
+Or else your code could quickly get messy and error-prone with all kinds of nasty
+concurrency bugs. In particular your program could become indeterministic
+which spells in practice: very (in fact, VERY) hard to debug, test and reason about.
+
+Having said that it might be a good idea to first write a sequential solution (and
+use the test suite to verify it).
+Only then should you try to parallelize it while keeping the sequential and parallel
+portions of your code as separate as possible.
+
+A first iteration could be using Scala's [parallel collections](http://docs.scala-lang.org/overviews/parallel-collections/overview.html). You might find
+that this is almost too simple (especially if you have followed our advice and
+already have a sequential solution).
+
+For the second iteration we recommend you try a solution with [scala.concurrent.Future](http://www.scala-lang.org/api/current/scala/concurrent/Future$.html).
+You can consult [this tutorial](http://danielwestheide.com/blog/2013/01/09/the-neophytes-guide-to-scala-part-8-welcome-to-the-future.html) and [its sequel](http://danielwestheide.com/blog/2013/01/16/the-neophytes-guide-to-scala-part-9-promises-and-futures-in-practice.html) for some help.
+Make sure that you
+- have only one single blocking call to wait for the result
+- that it is at the very end of your program, and
+- that it has a timeout.
+
+`scala.concurrent.Future` is used in many libraries and the doctor's advice for
+parallel and asynchronous programming in Scala. So it is essential for mastering
+the language and it should become part of your Scala armory.

data/tracks/scala/exercises/prime-factors/src/test/scala/{primefactors_test.scala → PrimefactorsTest.scala}

@@ -6,42 +6,52 @@ class PrimeFactorsTest extends FlatSpec with Matchers {
   }
 
   it should "calc prime factors of 2" in {
+    pending
     PrimeFactors.forNumber(2) should be (List(2))
   }
 
   it should "calc prime factors of 3" in {
+    pending
     PrimeFactors.forNumber(3) should be (List(3))
   }
 
   it should "calc prime factors of 4" in {
+    pending
     PrimeFactors.forNumber(4) should be (List(2, 2))
   }
 
   it should "calc prime factors of 6" in {
+    pending
     PrimeFactors.forNumber(6) should be (List(2, 3))
   }
 
   it should "calc prime factors of 8" in {
+    pending
     PrimeFactors.forNumber(8) should be (List(2, 2, 2))
   }
 
   it should "calc prime factors of 9" in {
+    pending
     PrimeFactors.forNumber(9) should be (List(3, 3))
   }
 
   it should "calc prime factors of 27" in {
+    pending
     PrimeFactors.forNumber(27) should be (List(3, 3, 3))
   }
 
   it should "calc prime factors of 625" in {
+    pending
     PrimeFactors.forNumber(625) should be (List(5, 5, 5, 5))
   }
 
   it should "calc prime factors of 901255" in {
+    pending
     PrimeFactors.forNumber(901255) should be (List(5, 17, 23, 461))
   }
 
   it should "calc prime factors of 93819012551" in {
+    pending
     PrimeFactors.forNumber(Long.MaxValue) should be (List(7, 7, 73, 127, 337, 92737, 649657))
   }
 }

data/tracks/scala/exercises/raindrops/src/test/scala/{raindrops_test.scala → RaindropsTest.scala}

@@ -6,62 +6,77 @@ class RaindropsTest extends FlatSpec with Matchers {
   }
 
   it should "convert 3" in {
+    pending
     Raindrops().convert(3) should equal("Pling")
   }
 
   it should "convert 5" in {
+    pending
     Raindrops().convert(5) should equal("Plang")
   }
 
   it should "convert 7" in {
+    pending
     Raindrops().convert(7) should equal("Plong")
   }
 
   it should "convert 6" in {
+    pending
     Raindrops().convert(6) should equal("Pling")
   }
 
   it should "convert 9" in {
+    pending
     Raindrops().convert(9) should equal("Pling")
   }
 
   it should "convert 10" in {
+    pending
     Raindrops().convert(10) should equal("Plang")
   }
 
   it should "convert 14" in {
+    pending
     Raindrops().convert(14) should equal("Plong")
   }
 
   it should "convert 15" in {
+    pending
     Raindrops().convert(15) should equal("PlingPlang")
   }
 
   it should "convert 21" in {
+    pending
     Raindrops().convert(21) should equal("PlingPlong")
   }
 
   it should "convert 25" in {
+    pending
     Raindrops().convert(25) should equal("Plang")
   }
 
   it should "convert 35" in {
+    pending
     Raindrops().convert(35) should equal("PlangPlong")
   }
 
   it should "convert 49" in {
+    pending
     Raindrops().convert(49) should equal("Plong")
   }
 
   it should "convert 52" in {
+    pending
     Raindrops().convert(52) should equal("52")
   }
 
   it should "convert 105" in {
+    pending
     Raindrops().convert(105) should equal("PlingPlangPlong")
   }
 
   it should "convert 12121" in {
+    pending
     Raindrops().convert(12121) should equal("12121")
   }
 }

data/tracks/scala/exercises/rna-transcription/src/test/scala/{transcription_test.scala → RnaTranscriptionTest.scala}

@@ -6,34 +6,42 @@ class DnaTest extends FunSuite with Matchers {
   }
 
   test("transcribes cytidine to guanine") {
+    pending
     Dna.toRna("C") should be (Some("G"))
   }
 
   test("transcribes guanosine to cytosine") {
+    pending
     Dna.toRna("G") should be (Some("C"))
   }
 
   test("transcribes adenosine to uracil") {
+    pending
     Dna.toRna("A") should be (Some("U"))
   }
 
   test("transcribes thymidine to adenine") {
+    pending
     Dna.toRna("T") should be (Some("A"))
   }
 
   test("transcribes all ACGT to UGCA") {
+    pending
     Dna.toRna("ACGTGGTCTTAA") should be (Some("UGCACCAGAAUU"))
   }
 
   test("transcribes RNA only nucleotide uracil to None") {
+    pending
     Dna.toRna("U") should be (None)
   }
 
   test("transcribes completely invalid DNA to None") {
+    pending
     Dna.toRna("XXX") should be (None)
   }
 
   test("transcribes partially invalid DNA to None") {
+    pending
     Dna.toRna("ACGTXXXCTTAA") should be (None)
   }
 }

data/tracks/scala/exercises/roman-numerals/src/test/scala/{roman_numerals_test.scala → RomanNumeralsTest.scala}

@@ -7,70 +7,87 @@ class RomanNumeralsSpecs extends FunSpec with Matchers {
   }
 
   it ("1 equals I") {
+    pending
     RomanNumeral(1).value should be ("I")
   }
 
   it ("2 equals II") {
+    pending
     RomanNumeral(2).value should be ("II")
   }
 
   it ("3 equals III") {
+    pending
     RomanNumeral(3).value should be ("III")
   }
 
   it ("4 equals IV") {
+    pending
     RomanNumeral(4).value should be ("IV")
   }
 
   it ("5 equals V") {
+    pending
     RomanNumeral(5).value should be ("V")
   }
 
   it ("6 equals VI") {
+    pending
     RomanNumeral(6).value should be ("VI")
   }
 
   it ("9 equals IX") {
+    pending
     RomanNumeral(9).value should be ("IX")
   }
 
   it ("27 equals XXVII") {
+    pending
     RomanNumeral(27).value should be ("XXVII")
   }
 
   it ("48 equals XLVIII") {
+    pending
     RomanNumeral(48).value should be ("XLVIII")
   }
 
   it ("59 equals LIX") {
+    pending
     RomanNumeral(59).value should be ("LIX")
   }
 
   it ("93 equals XCIII") {
+    pending
     RomanNumeral(93).value should be ("XCIII")
   }
 
   it ("141 equals CXLI") {
+    pending
     RomanNumeral(141).value should be ("CXLI")
   }
 
   it ("402 equals CDII") {
+    pending
     RomanNumeral(402).value should be ("CDII")
   }
 
   it ("575 equals DLXXV") {
+    pending
     RomanNumeral(575).value should be ("DLXXV")
   }
 
   it ("911 equals CMXI") {
+    pending
     RomanNumeral(911).value should be ("CMXI")
   }
 
   it ("1024 equals MXXIV") {
+    pending
     RomanNumeral(1024).value should be ("MXXIV")
   }
 
   it ("3000 equals MMM") {
+    pending
     RomanNumeral(3000).value should be ("MMM")
   }
 }