trackler 2.2.0.4 → 2.2.0.5

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

@@ -0,0 +1,72 @@
+# 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".
+
+
+
+## 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/kotlin/exercises/say/build.gradle

@@ -0,0 +1,28 @@
+buildscript {
+  ext.kotlin_version = '1.1.1'
+  repositories {
+    mavenCentral()
+  }
+  dependencies {
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
+}
+
+apply plugin: 'kotlin'
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+  testCompile 'junit:junit:4.12'
+  testCompile "org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version"
+}
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

data/tracks/kotlin/exercises/say/src/example/kotlin/NumberSpeller.kt

@@ -0,0 +1,88 @@
+class NumberSpeller {
+
+    companion object {
+        val wordMap = mapOf<Long, String>(
+                Pair( 0, "zero"     ),
+                Pair( 1, "one"      ),
+                Pair( 2, "two"      ),
+                Pair( 3, "three"    ),
+                Pair( 4, "four"     ),
+                Pair( 5, "five"     ),
+                Pair( 6, "six"      ),
+                Pair( 7, "seven"    ),
+                Pair( 8, "eight"    ),
+                Pair( 9, "nine"     ),
+                Pair(10, "ten"      ),
+                Pair(11, "eleven"   ),
+                Pair(12, "twelve"   ),
+                Pair(13, "thirteen" ),
+                Pair(14, "fourteen" ),
+                Pair(15, "fifteen"  ),
+                Pair(16, "sixteen"  ),
+                Pair(17, "seventeen"),
+                Pair(18, "eighteen" ),
+                Pair(19, "nineteen" ),
+                Pair(20, "twenty"   ),
+                Pair(30, "thirty"   ),
+                Pair(40, "forty"    ),
+                Pair(50, "fifty"    ),
+                Pair(60, "sixty"    ),
+                Pair(70, "seventy"  ),
+                Pair(80, "eighty"   ),
+                Pair(90, "ninety"   )
+        )
+
+        val te = 10
+        val hu = 100
+        val th = 1000
+        val mi = 1000000
+        val bi = 1000000000
+        val tr = 1000000000000
+    }
+
+    fun say(input: Long): String {
+        require(input >= 0) { "Input must be non-negative" }
+        require(input < tr)  { "Input must be less than $tr" }
+
+        if (input < 20) return wordMap[input]!!
+
+        if (input < hu) {
+            return if (input % te == 0L) {
+                wordMap[input]!!
+            } else {
+                "${wordMap[input / te * te]}-${wordMap[input % te]!!}"
+            }
+        }
+
+        if (input < th) {
+            return if (input % hu == 0L) {
+                "${wordMap[input / hu]!!} hundred"
+            } else {
+                "${wordMap[input / hu]!!} hundred ${say(input % hu)}"
+            }
+        }
+
+        if (input < mi) {
+            return if (input % th == 0L) {
+                "${say(input / th)} thousand"
+            } else {
+                "${say(input / th)} thousand ${say(input % th)}"
+            }
+        }
+
+        if (input < bi) {
+            return if (input % mi == 0L) {
+                "${say(input / mi)} million"
+            } else {
+                "${say(input / mi)} million ${say(input % mi)}"
+            }
+        }
+
+        return if (input % bi == 0L) {
+            "${say(input / bi)} billion"
+        } else {
+            "${say(input / bi)} billion ${say(input % bi)}"
+        }
+    }
+
+}

data/tracks/kotlin/exercises/say/src/test/kotlin/NumberSpellerTest.kt

@@ -0,0 +1,138 @@
+import org.junit.Ignore
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.ExpectedException
+import java.math.BigInteger
+import kotlin.test.assertEquals
+
+/*
+ * version: 1.0.0
+ */
+class NumberSpellerTest {
+
+    @Rule
+    @JvmField
+    var expectedException: ExpectedException = ExpectedException.none()
+
+    @Test
+    fun test0IsSpelledCorrectly() {
+        assertEquals(
+                "zero",
+                NumberSpeller().say(0))
+    }
+
+    @Ignore
+    @Test
+    fun test1IsSpelledCorrectly() {
+        assertEquals(
+                "one",
+                NumberSpeller().say(1))
+    }
+
+    @Ignore
+    @Test
+    fun test14IsSpelledCorrectly() {
+        assertEquals(
+                "fourteen",
+                NumberSpeller().say(14))
+    }
+
+    @Ignore
+    @Test
+    fun test20IsSpelledCorrectly() {
+        assertEquals(
+                "twenty",
+                NumberSpeller().say(20))
+    }
+
+    @Ignore
+    @Test
+    fun test22IsSpelledCorrectly() {
+        assertEquals(
+                "twenty-two",
+                NumberSpeller().say(22))
+    }
+
+    @Ignore
+    @Test
+    fun test100IsSpelledCorrectly() {
+        assertEquals(
+                "one hundred",
+                NumberSpeller().say(100))
+    }
+
+    @Ignore
+    @Test
+    fun test123IsSpelledCorrectly() {
+        assertEquals(
+                "one hundred twenty-three",
+                NumberSpeller().say(123))
+    }
+
+    @Ignore
+    @Test
+    fun test1000IsSpelledCorrectly() {
+        assertEquals(
+                "one thousand",
+                NumberSpeller().say(1000))
+    }
+
+    @Ignore
+    @Test
+    fun test1234IsSpelledCorrectly() {
+        assertEquals(
+                "one thousand two hundred thirty-four",
+                NumberSpeller().say(1234))
+    }
+
+    @Ignore
+    @Test
+    fun test1000000IsSpelledCorrectly() {
+        assertEquals(
+                "one million",
+                NumberSpeller().say(1000000))
+    }
+
+    @Ignore
+    @Test
+    fun test1002345IsSpelledCorrectly() {
+        assertEquals(
+                "one million two thousand three hundred forty-five",
+                NumberSpeller().say(1002345))
+    }
+
+    @Ignore
+    @Test
+    fun test1000000000IsSpelledCorrectly() {
+        assertEquals(
+                "one billion",
+                NumberSpeller().say(1000000000))
+    }
+
+    @Ignore
+    @Test
+    fun test987654321123IsSpelledCorrectly() {
+        assertEquals(
+                "nine hundred eighty-seven billion six hundred fifty-four million three hundred twenty-one thousand one hundred twenty-three",
+                NumberSpeller().say(987654321123))
+    }
+
+    @Ignore
+    @Test
+    fun testNegativeNumbersAreOutOfRange() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("Input must be non-negative")
+
+        NumberSpeller().say(-1)
+    }
+
+    @Ignore
+    @Test
+    fun testNumbersAbove1000000000000AreOutOfRange() {
+        expectedException.expect(IllegalArgumentException::class.java)
+        expectedException.expectMessage("Input must be less than 1000000000000")
+
+        NumberSpeller().say(1000000000000)
+    }
+
+}

data/tracks/kotlin/exercises/settings.gradle

@@ -18,6 +18,7 @@ include 'diamond'
 include 'difference-of-squares'
 include 'etl'
 include 'flatten-array'
+include 'forth'
 include 'gigasecond'
 include 'grade-school'
 include 'grains'
@@ -30,6 +31,7 @@ include 'leap'
 include 'linked-list'
 include 'list-ops'
 include 'luhn'
+include 'meetup'
 include 'minesweeper'
 include 'nth-prime'
 include 'nucleotide-count'
@@ -47,6 +49,7 @@ include 'robot-simulator'
 include 'roman-numerals'
 include 'rotational-cipher'
 include 'saddle-points'
+include 'say'
 include 'scrabble-score'
 include 'secret-handshake'
 include 'series'

data/tracks/lua/config.json

@@ -1,7 +1,5 @@
 {
-  "slug": "lua",
   "language": "Lua",
-  "repository": "https://github.com/exercism/lua",
   "active": true,
   "test_pattern": ".*spec[.]lua$",
   "exercises": [

data/tracks/mips/config.json

@@ -1,7 +1,5 @@
 {
-  "slug": "mips",
   "language": "MIPS Assembly",
-  "repository": "https://github.com/exercism/mips",
   "active": true,
   "test_pattern": "runner.mips",
   "foregone": [

data/tracks/ocaml/config.json

@@ -1,7 +1,5 @@
 {
-  "slug": "ocaml",
   "language": "OCaml",
-  "repository": "https://github.com/exercism/ocaml",
   "active": true,
   "exercises": [
     {