trackler 2.2.1.4 → 2.2.1.5

data/tracks/racket/exercises/roman-numerals/README.md

@@ -0,0 +1,74 @@
+# Roman Numerals
+
+Write a function to convert from normal numbers to Roman Numerals.
+
+The Romans were a clever bunch. They conquered most of Europe and ruled
+it for hundreds of years. They invented concrete and straight roads and
+even bikinis. One thing they never discovered though was the number
+zero. This made writing and dating extensive histories of their exploits
+slightly more challenging, but the system of numbers they came up with
+is still in use today. For example the BBC uses Roman numerals to date
+their programmes.
+
+The Romans wrote numbers using letters - I, V, X, L, C, D, M. (notice
+these letters have lots of straight lines and are hence easy to hack
+into stone tablets).
+
+```
+ 1  => I
+10  => X
+ 7  => VII
+```
+
+There is no need to be able to convert numbers larger than about 3000.
+(The Romans themselves didn't tend to go any higher)
+
+Wikipedia says: Modern Roman numerals ... are written by expressing each
+digit separately starting with the left most digit and skipping any
+digit with a value of zero.
+
+To see this in practice, consider the example of 1990.
+
+In Roman numerals 1990 is MCMXC:
+
+1000=M
+900=CM
+90=XC
+
+2008 is written as MMVIII:
+
+2000=MM
+8=VIII
+
+See also: http://www.novaroma.org/via_romana/numbers.html
+
+* * * *
+
+For installation and learning resources, refer to the
+[exercism Racket page](http://exercism.io/languages/racket).
+
+You can run the provided tests through DrRacket, or via the command line.
+
+To run the test through DrRacket, simply open the test file and click the 'Run' button in the upper right.
+
+To run the test from the command line, simply run the test from the exercise directory. For example, if the test suite is called `hello-world-test.rkt`, you can run the following command:
+
+```
+raco test hello-world-test.rkt
+```
+
+which will display the following:
+
+```
+raco test: (submod "hello-world-test.rkt" test)
+2 success(es) 0 failure(s) 0 error(s) 2 test(s) run
+0
+2 tests passed
+```
+
+## Source
+
+The Roman Numeral Kata [http://codingdojo.org/cgi-bin/index.pl?KataRomanNumerals](http://codingdojo.org/cgi-bin/index.pl?KataRomanNumerals)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/racket/exercises/say/README.md

@@ -0,0 +1,94 @@
+# Say
+
+Given a number from 0 to 999,999,999,999, spell out that number in English.
+
+## Step 1
+
+Handle the basic case of 0 through 99.
+
+If the input to the program is `22`, then the output should be
+`'twenty-two'`.
+
+Your program should complain loudly if given a number outside the
+blessed range.
+
+Some good test cases for this program are:
+
+- 0
+- 14
+- 50
+- 98
+- -1
+- 100
+
+### Extension
+
+If you're on a Mac, shell out to Mac OS X's `say` program to talk out
+loud.
+
+## Step 2
+
+Implement breaking a number up into chunks of thousands.
+
+So `1234567890` should yield a list like 1, 234, 567, and 890, while the
+far simpler `1000` should yield just 1 and 0.
+
+The program must also report any values that are out of range.
+
+## Step 3
+
+Now handle inserting the appropriate scale word between those chunks.
+
+So `1234567890` should yield `'1 billion 234 million 567 thousand 890'`
+
+The program must also report any values that are out of range.  It's
+fine to stop at "trillion".
+
+## Step 4
+
+Put it all together to get nothing but plain English.
+
+`12345` should give `twelve thousand three hundred forty-five`.
+
+The program must also report any values that are out of range.
+
+### Extensions
+
+Use _and_ (correctly) when spelling out the number in English:
+
+- 14 becomes "fourteen".
+- 100 becomes "one hundred".
+- 120 becomes "one hundred and twenty".
+- 1002 becomes "one thousand and two".
+- 1323 becomes "one thousand three hundred and twenty-three".
+
+* * * *
+
+For installation and learning resources, refer to the
+[exercism Racket page](http://exercism.io/languages/racket).
+
+You can run the provided tests through DrRacket, or via the command line.
+
+To run the test through DrRacket, simply open the test file and click the 'Run' button in the upper right.
+
+To run the test from the command line, simply run the test from the exercise directory. For example, if the test suite is called `hello-world-test.rkt`, you can run the following command:
+
+```
+raco test hello-world-test.rkt
+```
+
+which will display the following:
+
+```
+raco test: (submod "hello-world-test.rkt" test)
+2 success(es) 0 failure(s) 0 error(s) 2 test(s) run
+0
+2 tests passed
+```
+
+## Source
+
+A variation on JavaRanch CattleDrive, exercise 4a [http://www.javaranch.com/say.jsp](http://www.javaranch.com/say.jsp)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/racket/exercises/scrabble-score/README.md

@@ -0,0 +1,69 @@
+# Scrabble Score
+
+Given a word, compute the scrabble score for that word.
+
+## Letter Values
+
+You'll need these:
+
+```plain
+Letter                           Value
+A, E, I, O, U, L, N, R, S, T       1
+D, G                               2
+B, C, M, P                         3
+F, H, V, W, Y                      4
+K                                  5
+J, X                               8
+Q, Z                               10
+```
+
+## Examples
+"cabbage" should be scored as worth 14 points:
+
+- 3 points for C
+- 1 point for A, twice
+- 3 points for B, twice
+- 2 points for G
+- 1 point for E
+
+And to total:
+
+- `3 + 2*1 + 2*3 + 2 + 1`
+- = `3 + 2 + 6 + 3`
+- = `5 + 9`
+- = 14
+
+## Extensions
+- You can play a double or a triple letter.
+- You can play a double or a triple word.
+
+* * * *
+
+For installation and learning resources, refer to the
+[exercism Racket page](http://exercism.io/languages/racket).
+
+You can run the provided tests through DrRacket, or via the command line.
+
+To run the test through DrRacket, simply open the test file and click the 'Run' button in the upper right.
+
+To run the test from the command line, simply run the test from the exercise directory. For example, if the test suite is called `hello-world-test.rkt`, you can run the following command:
+
+```
+raco test hello-world-test.rkt
+```
+
+which will display the following:
+
+```
+raco test: (submod "hello-world-test.rkt" test)
+2 success(es) 0 failure(s) 0 error(s) 2 test(s) run
+0
+2 tests passed
+```
+
+## Source
+
+Inspired by the Extreme Startup game [https://github.com/rchatley/extreme_startup](https://github.com/rchatley/extreme_startup)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/racket/exercises/word-count/README.md

@@ -0,0 +1,44 @@
+# Word Count
+
+Given a phrase, count the occurrences of each word in that phrase.
+
+For example for the input `"olly olly in come free"`
+
+```plain
+olly: 2
+in: 1
+come: 1
+free: 1
+```
+
+
+* * * *
+
+For installation and learning resources, refer to the
+[exercism Racket page](http://exercism.io/languages/racket).
+
+You can run the provided tests through DrRacket, or via the command line.
+
+To run the test through DrRacket, simply open the test file and click the 'Run' button in the upper right.
+
+To run the test from the command line, simply run the test from the exercise directory. For example, if the test suite is called `hello-world-test.rkt`, you can run the following command:
+
+```
+raco test hello-world-test.rkt
+```
+
+which will display the following:
+
+```
+raco test: (submod "hello-world-test.rkt" test)
+2 success(es) 0 failure(s) 0 error(s) 2 test(s) run
+0
+2 tests passed
+```
+
+## Source
+
+This is a classic toy problem, but we were reminded of it by seeing it in the Go Tour.
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/ruby/exercises/binary-search-tree/.meta/solutions/binary_search_tree.rb

@@ -1,6 +1,4 @@
 class Bst
-  VERSION = 1
-
   attr_reader :data, :left, :right
   def initialize(data)
     @data = data
@@ -43,3 +41,7 @@ class Bst
     end
   end
 end
+
+module BookKeeping
+  VERSION = 1
+end

data/tracks/ruby/exercises/binary-search-tree/binary_search_tree_test.rb

@@ -99,16 +99,25 @@ class BstTest < Minitest::Test
     assert_raises(StopIteration) { each_enumerator.next }
   end
 
-  # Problems in exercism evolve over time,
-  # as we find better ways to ask questions.
+  # Problems in exercism evolve over time, as we find better ways to ask
+  # questions.
   # The version number refers to the version of the problem you solved,
   # not your solution.
   #
-  # Define a constant named VERSION inside of Bst.
+  # Define a constant named VERSION inside of the top level BookKeeping
+  # module, which may be placed near the end of your file.
+  #
+  # In your file, it will look like this:
+  #
+  # module BookKeeping
+  #   VERSION = 1 # Where the version number matches the one in the test.
+  # end
+  #
   # If you are curious, read more about constants on RubyDoc:
   # http://ruby-doc.org/docs/ruby-doc-bundle/UsersGuide/rg/constants.html
+
   def test_bookkeeping
     skip
-    assert_equal 1, Bst::VERSION
+    assert_equal 1, BookKeeping::VERSION
   end
 end

data/tracks/scala/config/maintainers.json

@@ -0,0 +1,29 @@
+{
+  "maintainers": [
+    {
+      "github_username": "ErikSchierboom",
+      "show_on_website": false,
+      "alumnus": false,
+      "name": null,
+      "bio": null,
+      "link_text": null,
+      "link_url": null,
+      "avatar_url": null
+    },
+    {
+      "github_username": "sgrif",
+      "alumnus": true
+    },
+    {
+      "github_username": "ricemery",
+      "show_on_website": false,
+      "alumnus": false,
+      "name": null,
+      "bio": null,
+      "link_text": null,
+      "link_url": null,
+      "avatar_url": null
+    }
+  ],
+  "docs_url": "https://github.com/exercism/docs/blob/master/maintaining-a-track/maintainer-configuration.md"
+}

data/tracks/scala/exercises/atbash-cipher/example.scala

@@ -1,4 +1,4 @@
-object Atbash {
+object AtbashCipher {
   private def substitute(c: Char) =
     if (c.isDigit) c.toString
     else if (c.isLetter) ('a' + ('z' - c.toLower)).toChar.toString
@@ -6,4 +6,7 @@ object Atbash {
 
   def encode(s: String): String =
     s.foldLeft("")((acc, c) => acc + substitute(c)).grouped(5).mkString(" ")
+
+  def decode(s: String): String =
+    s.foldLeft("")((acc, c) => acc + substitute(c))
 }

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

@@ -0,0 +1,64 @@
+import org.scalatest.{Matchers, FunSuite}
+
+/** @version 1.0.0 */
+class AtbashCipherTest extends FunSuite with Matchers {
+
+  test("encode yes") {
+    AtbashCipher.encode("yes") should be ("bvh")
+  }
+
+  test("encode no") {
+    pending
+    AtbashCipher.encode("no") should be ("ml")
+  }
+
+  test("encode OMG") {
+    pending
+    AtbashCipher.encode("OMG") should be ("lnt")
+  }
+
+  test("encode spaces") {
+    pending
+    AtbashCipher.encode("O M G") should be ("lnt")
+  }
+
+  test("encode mindblowingly") {
+    pending
+    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")
+  }
+
+  test("encode deep thought") {
+    pending
+    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")
+  }
+
+  test("decode exercism") {
+    pending
+    AtbashCipher.decode("vcvix rhn") should be ("exercism")
+  }
+
+  test("decode a sentence") {
+    pending
+    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")
+  }
+
+  test("decode all the letters") {
+    pending
+    AtbashCipher.decode("gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt") should be ("thequickbrownfoxjumpsoverthelazydog")
+  }
+}

data/tracks/scala/exercises/roman-numerals/example.scala

@@ -1,7 +1,7 @@
 import scala.annotation.tailrec
 import scala.collection.immutable.ListMap
 
-object RomanNumeral {
+object RomanNumerals {
   private def numeralValues = ListMap(
     1000 -> "M",
     900  -> "CM",
@@ -18,7 +18,7 @@ object RomanNumeral {
     1    -> "I"
   )
 
-  def toNumerals(n: Int) = fromNumber(n, "")
+  def roman(n: Int) = fromNumber(n, "")
 
   @tailrec
   private def fromNumber(n: Int, numerals: String): String = {

data/tracks/scala/exercises/roman-numerals/src/test/scala/RomanNumeralsTest.scala

@@ -1,93 +1,94 @@
-import org.scalatest._
+import org.scalatest.{Matchers, FunSuite}
 
-class RomanNumeralsSpecs extends FunSpec with Matchers {
+/** @version 1.0.0 */
+class RomanNumeralsTest extends FunSuite with Matchers {
 
-  it ("0 equals empty string") {
-    RomanNumeral.toNumerals(0) should be ("")
+  test("1 is a single I") {
+    RomanNumerals.roman(1) should be ("I")
   }
 
-  it ("1 equals I") {
+  test("2 is two I's") {
     pending
-    RomanNumeral.toNumerals(1) should be ("I")
+    RomanNumerals.roman(2) should be ("II")
   }
 
-  it ("2 equals II") {
+  test("3 is three I's") {
     pending
-    RomanNumeral.toNumerals(2) should be ("II")
+    RomanNumerals.roman(3) should be ("III")
   }
 
-  it ("3 equals III") {
+  test("4, being 5 - 1, is IV") {
     pending
-    RomanNumeral.toNumerals(3) should be ("III")
+    RomanNumerals.roman(4) should be ("IV")
   }
 
-  it ("4 equals IV") {
+  test("5 is a single V") {
     pending
-    RomanNumeral.toNumerals(4) should be ("IV")
+    RomanNumerals.roman(5) should be ("V")
   }
 
-  it ("5 equals V") {
+  test("6, being 5 + 1, is VI") {
     pending
-    RomanNumeral.toNumerals(5) should be ("V")
+    RomanNumerals.roman(6) should be ("VI")
   }
 
-  it ("6 equals VI") {
+  test("9, being 10 - 1, is IX") {
     pending
-    RomanNumeral.toNumerals(6) should be ("VI")
+    RomanNumerals.roman(9) should be ("IX")
   }
 
-  it ("9 equals IX") {
+  test("20 is two X's") {
     pending
-    RomanNumeral.toNumerals(9) should be ("IX")
+    RomanNumerals.roman(27) should be ("XXVII")
   }
 
-  it ("27 equals XXVII") {
+  test("48 is not 50 - 2 but rather 40 + 8") {
     pending
-    RomanNumeral.toNumerals(27) should be ("XXVII")
+    RomanNumerals.roman(48) should be ("XLVIII")
   }
 
-  it ("48 equals XLVIII") {
+  test("50 is a single L") {
     pending
-    RomanNumeral.toNumerals(48) should be ("XLVIII")
+    RomanNumerals.roman(59) should be ("LIX")
   }
 
-  it ("59 equals LIX") {
+  test("90, being 100 - 10, is XC") {
     pending
-    RomanNumeral.toNumerals(59) should be ("LIX")
+    RomanNumerals.roman(93) should be ("XCIII")
   }
 
-  it ("93 equals XCIII") {
+  test("100 is a single C") {
     pending
-    RomanNumeral.toNumerals(93) should be ("XCIII")
+    RomanNumerals.roman(141) should be ("CXLI")
   }
 
-  it ("141 equals CXLI") {
+  test("60, being 50 + 10, is LX") {
     pending
-    RomanNumeral.toNumerals(141) should be ("CXLI")
+    RomanNumerals.roman(163) should be ("CLXIII")
   }
 
-  it ("402 equals CDII") {
+  test("400, being 500 - 100, is CD") {
     pending
-    RomanNumeral.toNumerals(402) should be ("CDII")
+    RomanNumerals.roman(402) should be ("CDII")
   }
 
-  it ("575 equals DLXXV") {
+  test("500 is a single D") {
     pending
-    RomanNumeral.toNumerals(575) should be ("DLXXV")
+    RomanNumerals.roman(575) should be ("DLXXV")
   }
 
-  it ("911 equals CMXI") {
+  test("900, being 1000 - 100, is CM") {
     pending
-    RomanNumeral.toNumerals(911) should be ("CMXI")
+    RomanNumerals.roman(911) should be ("CMXI")
   }
 
-  it ("1024 equals MXXIV") {
+  test("1000 is a single M") {
     pending
-    RomanNumeral.toNumerals(1024) should be ("MXXIV")
+    RomanNumerals.roman(1024) should be ("MXXIV")
   }
 
-  it ("3000 equals MMM") {
+  test("3000 is three M's") {
     pending
-    RomanNumeral.toNumerals(3000) should be ("MMM")
+    RomanNumerals.roman(3000) should be ("MMM")
   }
-}
+}

data/tracks/scala/testgen/src/main/scala/AtbashCipherTestGenerator.scala

@@ -0,0 +1,16 @@
+import java.io.File
+
+import testgen.TestSuiteBuilder._
+import testgen._
+
+object AtbashCipherTestGenerator {
+  def main(args: Array[String]): Unit = {
+    val file = new File("src/main/resources/atbash-cipher.json")
+
+    val code = TestSuiteBuilder.build(file,
+        fromLabeledTestAlt("encode" -> Seq("phrase"), "decode" -> Seq("phrase")))
+    println(s"-------------")
+    println(code)
+    println(s"-------------")
+  }
+}

data/tracks/scala/testgen/src/main/scala/RomanNumeralsTestGenerator.scala

@@ -0,0 +1,15 @@
+import java.io.File
+
+import testgen.TestSuiteBuilder
+import testgen.TestSuiteBuilder.fromLabeledTest
+
+object RomanNumeralsTestGenerator {
+  def main(args: Array[String]): Unit = {
+    val file = new File("src/main/resources/roman-numerals.json")
+
+    val code = TestSuiteBuilder.build(file, fromLabeledTest("number"))
+    println(s"-------------")
+    println(code)
+    println(s"-------------")
+  }
+}

data/tracks/scheme/config/exercise_readme.go.tmpl

@@ -0,0 +1,16 @@
+# {{ .Spec.Name }}
+
+{{ .Spec.Description -}}
+{{- with .Hints }}
+{{ . }}
+{{ end }}
+{{- with .TrackInsert }}
+{{ . }}
+{{ end }}
+{{- with .Spec.Credits -}}
+## Source
+
+{{ . }}
+{{ end }}
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.