trackler 2.2.1.52 → 2.2.1.53

data/tracks/kotlin/exercises/etl/.meta/src/reference/kotlin/ETL.kt

@@ -1,5 +1,11 @@
 object ETL {
+
     fun transform(old: Map<Int, Collection<Char>>): Map<Char, Int> {
-        return old.flatMap { mapEntry -> mapEntry.value.map { word -> Pair(word.toLowerCase(), mapEntry.key) } }.toMap()
+        return old.flatMap { mapEntry ->
+            mapEntry.value.map { word ->
+                Pair(word.toLowerCase(), mapEntry.key)
+            }
+        }.toMap()
     }
+
 }

data/tracks/kotlin/exercises/etl/.meta/version

@@ -0,0 +1 @@
+1.0.0

data/tracks/kotlin/exercises/etl/src/test/kotlin/ETLTest.kt

@@ -4,10 +4,9 @@ import kotlin.test.assertEquals
 
 class ETLTest {
 
-
     @Test
-    fun transformOneValue() {
-        val old = mapOf(1 to listOf('a'))
+    fun aSingleLetter() {
+        val old = mapOf(1 to listOf('A'))
         val expected = mapOf('a' to 1)
 
         assertEquals(expected, ETL.transform(old))
@@ -15,25 +14,25 @@ class ETLTest {
 
     @Ignore
     @Test
-    fun transformMoreValues() {
-        val old = mapOf(1 to listOf('A', 'E', 'I'))
-        val expected = mapOf('a' to 1, 'e' to 1, 'i' to 1)
+    fun singleScoreWithMultipleLetters() {
+        val old = mapOf(1 to listOf('A', 'E', 'I', 'O', 'U'))
+        val expected = mapOf('a' to 1, 'e' to 1, 'i' to 1, 'o' to 1, 'u' to 1)
 
         assertEquals(expected, ETL.transform(old))
     }
 
     @Ignore
     @Test
-    fun moreKeys() {
-        val old = mapOf(1 to listOf('A', 'E', 'I'), 2 to listOf('D', 'G'))
-        val expected = mapOf('a' to 1, 'e' to 1, 'i' to 1, 'd' to 2, 'g' to 2)
+    fun multipleScoresWithMultipleLetters() {
+        val old = mapOf(1 to listOf('A', 'E'), 2 to listOf('D', 'G'))
+        val expected = mapOf('a' to 1, 'd' to 2, 'e' to 1, 'g' to 2)
 
         assertEquals(expected, ETL.transform(old))
     }
 
     @Ignore
     @Test
-    fun fullDataset() {
+    fun multipleScoresWithDifferingNumbersOfLetters() {
         val old = mapOf(
                 1 to listOf('A', 'E', 'I', 'O', 'U', 'L', 'N', 'R', 'S', 'T'),
                 2 to listOf('D', 'G'),
@@ -54,4 +53,5 @@ class ETLTest {
 
         assertEquals(expected, ETL.transform(old))
     }
+
 }

data/tracks/kotlin/exercises/flatten-array/.meta/version

@@ -0,0 +1 @@
+1.1.0

data/tracks/kotlin/exercises/flatten-array/src/test/kotlin/FlattenerTest.kt

@@ -4,24 +4,16 @@ import kotlin.test.assertEquals
 
 class FlattenerTest {
 
-
     @Test
-    fun flattensANestedList() {
-        val nestedList = listOf<Any>(emptyList<Any>())
-        assertEquals(emptyList<Any>(), Flattener.flatten(nestedList))
+    fun flatListIsUnchanged() {
+        val flatList = listOf(0, 1, 2)
+        assertEquals(listOf(0, 1, 2), Flattener.flatten(flatList))
     }
 
     @Ignore
     @Test
     fun flattens2LevelNestedList() {
-        val nestedList = listOf(1, listOf(2, 3, 4), 5)
-        assertEquals(listOf(1, 2, 3, 4, 5), Flattener.flatten(nestedList))
-    }
-
-    @Ignore
-    @Test
-    fun flattens3LevelNestedList() {
-        val nestedList = listOf(1, listOf(2, 3, 4), 5, listOf(6, listOf(7, 8)))
+        val nestedList = listOf(1, listOf(2, 3, 4, 5, 6, 7), 8)
         assertEquals(listOf(1, 2, 3, 4, 5, 6, 7, 8), Flattener.flatten(nestedList))
     }
 
@@ -42,15 +34,15 @@ class FlattenerTest {
     @Ignore
     @Test
     fun flattens6LevelNestedListWithNulls() {
-        val nestedList = listOf(1, listOf(2, null, listOf(listOf(3), null), listOf(4, listOf(listOf(5))), 6, 7, listOf(listOf(null))), 8, null)
-        assertEquals(listOf(1, 2, 3, 4, 5, 6, 7, 8), Flattener.flatten(nestedList))
+        val nestedList = listOf(0, 2, listOf(listOf(2, 3), 8, listOf(listOf(100)), null, listOf(listOf(null))), -2)
+        assertEquals(listOf(0, 2, 2, 3, 8, 100, -2), Flattener.flatten(nestedList))
     }
 
     @Ignore
     @Test
     fun allNullNestedListReturnsEmptyList() {
-        val nestedList = listOf(null, listOf(null, listOf(null), listOf(listOf(listOf(null)))), null)
+        val nestedList = listOf(null, listOf(listOf(listOf(null))), null, null, listOf(listOf(null, null), null), null)
         assertEquals(emptyList<Any>(), Flattener.flatten(nestedList))
     }
-}
 
+}

data/tracks/kotlin/exercises/gigasecond/.meta/version

@@ -0,0 +1 @@
+1.0.0

data/tracks/kotlin/exercises/gigasecond/src/test/kotlin/GigasecondTest.kt

@@ -7,7 +7,6 @@ import kotlin.test.assertEquals
 
 class GigasecondTest {
 
-
     @Test
     fun modernTime() {
         val gigaSecond = Gigasecond(LocalDate.of(2011, Month.APRIL, 25))
@@ -46,4 +45,5 @@ class GigasecondTest {
 
         assertEquals(LocalDateTime.of(2046, Month.OCTOBER, 3, 1, 46, 39), gigaSecond.date)
     }
+
 }

data/tracks/kotlin/exercises/hamming/.meta/src/reference/kotlin/Hamming.kt

@@ -1,7 +1,7 @@
 object Hamming {
 
     fun compute(leftStrand: String, rightStrand: String): Int {
-        require(leftStrand.length == rightStrand.length, {"leftStrand and rightStrand must be of equal length."})
+        require(leftStrand.length == rightStrand.length, {"left and right strands must be of equal length."})
 
         val commonPairs = leftStrand.zip(rightStrand)
         return commonPairs.count { it.first != it.second }

data/tracks/kotlin/exercises/hamming/.meta/version

@@ -1 +1 @@
-1.1.0
+2.0.1

data/tracks/kotlin/exercises/hamming/src/test/kotlin/HammingTest.kt

@@ -60,13 +60,13 @@ class HammingTest {
     @Ignore
     @Test
     fun nonUniqueCharacterInFirstStrand() {
-        assertEquals(1, Hamming.compute("AGA", "AGG"))
+        assertEquals(1, Hamming.compute("AAG", "AAA"))
     }
 
     @Ignore
     @Test
     fun nonUniqueCharacterInSecondStrand() {
-        assertEquals(1, Hamming.compute("AGG", "AGA"))
+        assertEquals(1, Hamming.compute("AAA", "AAG"))
     }
 
     @Ignore
@@ -91,7 +91,7 @@ class HammingTest {
     @Test
     fun validatesFirstStrandNotLonger() {
         expectedException.expect(IllegalArgumentException::class.java)
-        expectedException.expectMessage("leftStrand and rightStrand must be of equal length.")
+        expectedException.expectMessage("left and right strands must be of equal length.")
 
         Hamming.compute("AATG", "AAA")
     }
@@ -100,7 +100,7 @@ class HammingTest {
     @Test
     fun validatesSecondStrandNotLonger() {
         expectedException.expect(IllegalArgumentException::class.java)
-        expectedException.expectMessage("leftStrand and rightStrand must be of equal length.")
+        expectedException.expectMessage("left and right strands must be of equal length.")
 
         Hamming.compute("ATA", "AGTG")
     }

data/tracks/kotlin/exercises/hello-world/.meta/version

@@ -0,0 +1 @@
+1.0.0

data/tracks/kotlin/exercises/hello-world/src/test/kotlin/HelloWorldTest.kt

@@ -1,11 +1,11 @@
 import org.junit.Test
 import kotlin.test.assertEquals
 
-
 class HelloWorldTest {
 
     @Test
     fun helloWorldTest() {
         assertEquals("Hello, World!", hello())
     }
+
 }

data/tracks/kotlin/exercises/isogram/.meta/version

@@ -0,0 +1 @@
+1.2.0

data/tracks/kotlin/exercises/isogram/src/test/kotlin/IsogramTest.kt

@@ -1,6 +1,4 @@
-
 import org.junit.Test
-import org.junit.Ignore
 import org.junit.runner.RunWith
 import org.junit.runners.Parameterized
 import kotlin.test.assertEquals
@@ -12,22 +10,21 @@ class IsogramTest(val input: String, val expectedOutput: Boolean) {
         @JvmStatic
         @Parameterized.Parameters(name = "{index}: isogram({0})={1}")
         fun data() = listOf(
-                arrayOf("duplicates", true),
+                arrayOf("", true),
+                arrayOf("isogram", true),
                 arrayOf("eleven", false),
                 arrayOf("subdermatoglyphic", true),
                 arrayOf("Alphabet", false),
                 arrayOf("thumbscrew-japingly", true),
-                arrayOf("Hjelmqvist-Gryb-Zock-Pfund-Wax", true),
-                arrayOf("Heizölrückstoßabdämpfung", true),
-                arrayOf("the quick brown fox", false),
+                arrayOf("six-year-old", true),
                 arrayOf("Emily Jung Schwartzkopf", true),
-                arrayOf("éléphant", false)
+                arrayOf("accentor", false)
         )
     }
 
-
     @Test
     fun test() {
         assertEquals(expectedOutput, Isogram.isIsogram(input))
     }
+
 }

data/tracks/kotlin/exercises/largest-series-product/.meta/src/reference/kotlin/Series.kt

@@ -1,6 +1,6 @@
 import java.lang.Math.max
 
-class Series(val digits: String) {
+class Series(private val digits: String) {
 
     init {
         require(digits.all { it.isDigit() })
@@ -14,7 +14,6 @@ class Series(val digits: String) {
             return 1
         }
 
-
         return calculateRec(digits.map { it.intValue() }, span, 0)
     }
 
@@ -42,4 +41,4 @@ fun Char.intDiff(other: Char) = this.toInt() - other.toInt()
 
 fun List<Int>.prod() : Long = this.fold(1L) {productSoFar, item -> item*productSoFar}
 
-fun <T> List<T>.tail() = this.subList(1, this.size)
+fun <T> List<T>.tail() = this.subList(1, this.size)

data/tracks/kotlin/exercises/largest-series-product/.meta/version

@@ -0,0 +1 @@
+1.0.0

data/tracks/kotlin/exercises/largest-series-product/src/test/kotlin/SeriesTest.kt

@@ -0,0 +1,97 @@
+
+import org.junit.Test
+import org.junit.Ignore
+import kotlin.test.assertEquals
+
+class SeriesTest {
+
+    @Test
+    fun findsTheLargestProductIfSpanEqualsLength() {
+        assertEquals(18, Series("29").getLargestProduct(2))
+    }
+
+    @Ignore
+    @Test
+    fun findsTheLargestProductOf2WithNumbersInOrder() {
+        assertEquals(72, Series("0123456789").getLargestProduct(2))
+    }
+
+    @Ignore
+    @Test
+    fun findsTheLargestProductOf2() {
+        assertEquals(48, Series("576802143").getLargestProduct(2))
+    }
+
+    @Ignore
+    @Test
+    fun findsTheLargestProductOf3WithNumbersInOrder() {
+        assertEquals(504, Series("0123456789").getLargestProduct(3))
+    }
+
+    @Ignore
+    @Test
+    fun findsTheLargestProductOf3() {
+        assertEquals(270, Series("1027839564").getLargestProduct(3))
+    }
+
+    @Ignore
+    @Test
+    fun findsTheLargestProductOf5WithNumbersInOrder() {
+        assertEquals(15120, Series("0123456789").getLargestProduct(5))
+    }
+
+    @Ignore
+    @Test
+    fun findsTheLargestProductWithinABigNumber() {
+        assertEquals(23520, Series("73167176531330624919225119674426574742355349194934").getLargestProduct(6))
+    }
+
+    @Ignore
+    @Test
+    fun reports0IfAllDigitsAre0() {
+        assertEquals(0, Series("0000").getLargestProduct(2))
+    }
+
+    @Ignore
+    @Test
+    fun reports0IfAllSpansInclude0() {
+        assertEquals(0, Series("99099").getLargestProduct(3))
+    }
+
+    @Ignore
+    @Test(expected = IllegalArgumentException::class)
+    fun rejectsSpanLongerThanStringLength() {
+        Series("123").getLargestProduct(4)
+    }
+
+    @Ignore
+    @Test
+    fun reports1ForEmptyStringAndEmptyProduct() {
+        assertEquals(1, Series("").getLargestProduct(0))
+    }
+
+    @Ignore
+    @Test
+    fun reports1ForNonEmptyStringAndEmptyProduct() {
+        assertEquals(1, Series("123").getLargestProduct(0))
+    }
+
+    @Ignore
+    @Test(expected = IllegalArgumentException::class)
+    fun rejectsEmptyStringAndNonZeroSpan() {
+        Series("").getLargestProduct(1)
+    }
+
+    @Ignore
+    @Test(expected = IllegalArgumentException::class)
+    fun rejectsInvalidCharacterInDigits() {
+        Series("1234a5")
+    }
+
+    @Ignore
+    @Test(expected = IllegalArgumentException::class)
+    fun rejectsNegativeSpan() {
+        Series("12345").getLargestProduct(-1)
+    }
+
+}

data/tracks/kotlin/exercises/leap/.meta/version

@@ -0,0 +1 @@
+1.1.0

data/tracks/kotlin/exercises/leap/src/test/kotlin/LeapTest.kt

@@ -5,45 +5,27 @@ import kotlin.test.assertTrue
 
 class LeapTest {
 
-
-    @Test
-    fun leapYear() {
-        assertTrue(Year(1996).isLeap)
-    }
-
-    @Ignore
-    @Test
-    fun standardOddYear() {
-        assertFalse(Year(1997).isLeap)
-    }
-
-    @Ignore
     @Test
-    fun standardEvenYear() {
-        assertFalse(Year(1998).isLeap)
+    fun yearNotDivisibleBy4() {
+        assertFalse(Year(2015).isLeap)
     }
 
     @Ignore
     @Test
-    fun standardNineteenthCentury() {
-        assertFalse(Year(1900).isLeap)
+    fun yearDivisibleBy4NotDivisibleBy100() {
+        assertTrue(Year(2020).isLeap)
     }
 
     @Ignore
     @Test
-    fun standardEighteenthCentury() {
-        assertFalse(Year(1800).isLeap)
+    fun yearDivisibleBy100NotDivisibleBy400() {
+        assertFalse(Year(2100).isLeap)
     }
 
     @Ignore
     @Test
-    fun leapTwentyFourthCentury() {
-        assertTrue(Year(2400).isLeap)
-    }
-
-    @Ignore
-    @Test
-    fun leapY2K() {
+    fun yearDivisibleBy400() {
         assertTrue(Year(2000).isLeap)
     }
+
 }

data/tracks/kotlin/exercises/list-ops/.meta/version

@@ -1 +1 @@
-1.0.0
+2.0.0

data/tracks/kotlin/exercises/luhn/.meta/version

@@ -0,0 +1 @@
+1.0.0

data/tracks/kotlin/exercises/luhn/src/test/kotlin/LuhnTest.kt

@@ -5,7 +5,6 @@ import kotlin.test.assertTrue
 
 class LuhnTest {
 
-
     @Test
     fun singleDigitStringsCannotBeValid() {
         assertFalse(Luhn.isValid("1"))
@@ -21,14 +20,12 @@ class LuhnTest {
     @Test
     fun simpleValidSINThatRemainsValidIfReversed() {
         assertTrue(Luhn.isValid("059"))
-        assertTrue(Luhn.isValid("950"))
     }
 
     @Ignore
     @Test
     fun simpleValidSINThatBecomesInvalidIfReversed() {
         assertTrue(Luhn.isValid("59"))
-        assertFalse(Luhn.isValid("95"))
     }
 
     @Ignore