trackler 2.2.1.52 → 2.2.1.53

data/tracks/kotlin/exercises/nth-prime/.meta/version

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

data/tracks/kotlin/exercises/nth-prime/src/test/kotlin/PrimeTest.kt

@@ -1,11 +1,9 @@
 import org.junit.Test
 import org.junit.Ignore
 import kotlin.test.assertEquals
-import kotlin.test.fail
 
 class PrimeTest {
 
-
     @Test
     fun firstPrime() {
         assertEquals(2, Prime.nth(1))

data/tracks/kotlin/exercises/nucleotide-count/.meta/src/reference/kotlin/{DNA.kt → Dna.kt}

@@ -1,9 +1,10 @@
-class DNA(strand: String) {
+class Dna(strand: String) {
+
     init {
         require(strand.matches(Regex("^[$nucleotides]*$")), { "DNA sequence contains invalid nucleotides sequence." })
     }
 
-    companion object DNA {
+    companion object Dna {
         val nucleotides = "ATCG"
         val emptyNucleotideCounts = nucleotides.map { it to 0 }.toMap()
     }
@@ -12,10 +13,4 @@ class DNA(strand: String) {
         emptyNucleotideCounts + strand.groupBy { it }.mapValues { it.value.size }
     }
 
-    fun count(nucleotide: Char): Int {
-        require(nucleotide in nucleotides, { "$nucleotide is not a nucleotide" })
-
-        return nucleotideCounts[nucleotide] ?: 0
-    }
 }
-

data/tracks/kotlin/exercises/nucleotide-count/.meta/version

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

data/tracks/kotlin/exercises/nucleotide-count/src/test/kotlin/DnaTest.kt

@@ -0,0 +1,48 @@
+import org.junit.Test
+import org.junit.Ignore
+import kotlin.test.assertEquals
+
+class DnaTest {
+
+    @Test
+    fun emptyDnaStringHasNoNucleotides() {
+        val dna = Dna("")
+        val expected = mapOf('A' to 0, 'C' to 0, 'G' to 0, 'T' to 0)
+
+        assertEquals(expected, dna.nucleotideCounts)
+    }
+
+    @Ignore
+    @Test
+    fun canCountOneNucleotideInSingleCharacterInput() {
+        val dna = Dna("G")
+        val expected = mapOf('A' to 0, 'C' to 0, 'G' to 1, 'T' to 0)
+
+        assertEquals(expected, dna.nucleotideCounts)
+    }
+
+    @Ignore
+    @Test
+    fun canCountRepeatedNucleotide() {
+        val dna = Dna("GGGGGGG")
+        val expected = mapOf('A' to 0, 'C' to 0, 'G' to 7, 'T' to 0)
+
+        assertEquals(expected, dna.nucleotideCounts)
+    }
+
+    @Ignore
+    @Test
+    fun canCountMultipleNucleotides() {
+        val dna = Dna("AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC")
+        val expected = mapOf('A' to 20, 'C' to 12, 'G' to 17, 'T' to 21)
+
+        assertEquals(expected, dna.nucleotideCounts)
+    }
+
+    @Ignore
+    @Test(expected = IllegalArgumentException::class)
+    fun validatesNucleotides() {
+        Dna("AGXXACT")
+    }
+
+}

data/tracks/kotlin/exercises/pangram/.meta/src/reference/kotlin/{Pangrams.kt → Pangram.kt}

@@ -1,4 +1,4 @@
-object Pangrams {
+object Pangram {
     val alphaLength = 26
     fun isPangram(input: String) = input.toLowerCase().replace(Regex("[^a-z]"), "").toSet().size == alphaLength
 }

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

@@ -1 +1 @@
-1.1.0
+1.3.0

data/tracks/kotlin/exercises/pangram/src/test/kotlin/PangramTest.kt

@@ -7,55 +7,61 @@ class PangramTest {
 
     @Test
     fun emptySentence() {
-        assertFalse(Pangrams.isPangram(""))
+        assertFalse(Pangram.isPangram(""))
+    }
+
+    @Ignore
+    @Test
+    fun perfectLowercasePangram() {
+        assertTrue(Pangram.isPangram("abcdefghijklmnopqrstuvwxyz"))
     }
 
     @Ignore
     @Test
     fun lowercasePangram() {
-        assertTrue(Pangrams.isPangram("the quick brown fox jumps over the lazy dog"))
+        assertTrue(Pangram.isPangram("the quick brown fox jumps over the lazy dog"))
     }
 
     @Ignore
     @Test
     fun missingCharacterX() {
-        assertFalse(Pangrams.isPangram("a quick movement of the enemy will jeopardize five gunboats"))
+        assertFalse(Pangram.isPangram("a quick movement of the enemy will jeopardize five gunboats"))
     }
 
     @Ignore
     @Test
     fun anotherMissingCharacterX() {
-        assertFalse(Pangrams.isPangram("the quick brown fish jumps over the lazy dog"))
+        assertFalse(Pangram.isPangram("five boxing wizards jump quickly at it"))
     }
 
     @Ignore
     @Test
     fun withUnderscores() {
-        assertTrue(Pangrams.isPangram("the_quick_brown_fox_jumps_over_the_lazy_dog"))
+        assertTrue(Pangram.isPangram("the_quick_brown_fox_jumps_over_the_lazy_dog"))
     }
 
     @Ignore
     @Test
     fun withNumbers() {
-        assertTrue(Pangrams.isPangram("the 1 quick brown fox jumps over the 2 lazy dogs"))
+        assertTrue(Pangram.isPangram("the 1 quick brown fox jumps over the 2 lazy dogs"))
     }
 
     @Ignore
     @Test
     fun missingLettersReplacedByNumbers() {
-        assertFalse(Pangrams.isPangram("7h3 qu1ck brown fox jumps ov3r 7h3 lazy dog"))
+        assertFalse(Pangram.isPangram("7h3 qu1ck brown fox jumps ov3r 7h3 lazy dog"))
     }
 
     @Ignore
     @Test
     fun mixedCaseAndPunctuation() {
-        assertTrue(Pangrams.isPangram("\"Five quacking Zephyrs jolt my wax bed.\""))
+        assertTrue(Pangram.isPangram("\"Five quacking Zephyrs jolt my wax bed.\""))
     }
 
     @Ignore
     @Test
     fun mixedCaseDuplicatedCharacters() {
-        assertFalse(Pangrams.isPangram("the quick brown fox jumps over with lazy FX"))
+        assertFalse(Pangram.isPangram("the quick brown fox jumps over with lazy FX"))
     }
 
 }

data/tracks/kotlin/exercises/pascals-triangle/.meta/version

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

data/tracks/kotlin/exercises/pascals-triangle/src/test/kotlin/PascalsTriangleTest.kt

@@ -4,40 +4,57 @@ import kotlin.test.assertEquals
 
 class PascalsTriangleTest {
 
+    @Test
+    fun zeroRows() {
+        val expectedOutput = emptyList<List<Int>>()
+
+        assertEquals(expectedOutput, PascalsTriangle.computeTriangle(0))
+    }
+
+    @Ignore
+    @Test
+    fun oneRow() {
+        val expectedOutput = listOf(
+                listOf(1)
+        )
 
+        assertEquals(expectedOutput, PascalsTriangle.computeTriangle(1))
+    }
+
+    @Ignore
     @Test
-    fun triangleWithFourRows() {
+    fun twoRows() {
         val expectedOutput = listOf(
                 listOf(1),
-                listOf(1, 1),
-                listOf(1, 2, 1),
-                listOf(1, 3, 3, 1)
+                listOf(1, 1)
         )
 
-        assertEquals(expectedOutput, PascalsTriangle.computeTriangle(4))
+        assertEquals(expectedOutput, PascalsTriangle.computeTriangle(2))
     }
 
     @Ignore
     @Test
-    fun triangleWithSixRows() {
+    fun threeRows() {
         val expectedOutput = listOf(
                 listOf(1),
                 listOf(1, 1),
-                listOf(1, 2, 1),
-                listOf(1, 3, 3, 1),
-                listOf(1, 4, 6, 4, 1),
-                listOf(1, 5, 10, 10, 5, 1)
+                listOf(1, 2, 1)
         )
 
-        assertEquals(expectedOutput, PascalsTriangle.computeTriangle(6))
+        assertEquals(expectedOutput, PascalsTriangle.computeTriangle(3))
     }
 
     @Ignore
     @Test
-    fun expectEmptyTriangle() {
-        val expectedOutput = emptyList<List<Int>>()
+    fun fourRows() {
+        val expectedOutput = listOf(
+                listOf(1),
+                listOf(1, 1),
+                listOf(1, 2, 1),
+                listOf(1, 3, 3, 1)
+        )
 
-        assertEquals(expectedOutput, PascalsTriangle.computeTriangle(0))
+        assertEquals(expectedOutput, PascalsTriangle.computeTriangle(4))
     }
 
     @Ignore
@@ -45,4 +62,5 @@ class PascalsTriangleTest {
     fun validatesNotNegativeRows() {
         PascalsTriangle.computeTriangle(-1)
     }
+
 }

data/tracks/kotlin/exercises/perfect-numbers/.meta/src/reference/kotlin/NaturalNumber.kt

@@ -4,7 +4,7 @@ enum class Classification {
 }
 
 fun classify(naturalNumber: Int): Classification {
-    require(naturalNumber >= 0, { "$naturalNumber is not a natural number" })
+    require(naturalNumber > 0, { "$naturalNumber is not a natural number" })
 
     val aliquotSum = naturalNumber.aliquotSum()
     return when {

data/tracks/kotlin/exercises/perfect-numbers/.meta/version

@@ -0,0 +1 @@
+1.0.1

data/tracks/kotlin/exercises/perfect-numbers/src/test/kotlin/{PerfectNumbersTest.kt → NaturalNumberTest.kt}

@@ -31,7 +31,7 @@ class NaturalNumberTest {
     @Ignore
     @Test
     fun mediumAbundantNumberIsClassifiedCorrectly() {
-        assertEquals(Classification.ABUNDANT, classify(24))
+        assertEquals(Classification.ABUNDANT, classify(30))
     }
 
     @Ignore
@@ -42,14 +42,20 @@ class NaturalNumberTest {
 
     @Ignore
     @Test
-    fun smallDeficientNumberIsClassifiedCorrectly() {
-        assertEquals(Classification.DEFICIENT, classify(8))
+    fun smallestPrimeDeficientNumberIsClassifiedCorrectly() {
+        assertEquals(Classification.DEFICIENT, classify(2))
+    }
+
+    @Ignore
+    @Test
+    fun smallestNonPrimeDeficientNumberIsClassifiedCorrectly() {
+        assertEquals(Classification.DEFICIENT, classify(4))
     }
 
     @Ignore
     @Test
     fun mediumNumberIsClassifiedCorrectly() {
-        assertEquals(Classification.DEFICIENT, classify(31))
+        assertEquals(Classification.DEFICIENT, classify(32))
     }
 
     @Ignore
@@ -58,10 +64,22 @@ class NaturalNumberTest {
         assertEquals(Classification.DEFICIENT, classify(33550337))
     }
 
+    @Ignore
+    @Test
+    fun edgeCaseWithNoFactorsOtherThanItselfIsClassifiedCorrectly() {
+        assertEquals(Classification.DEFICIENT, classify(1))
+    }
+
+    @Ignore
+    @Test(expected = RuntimeException::class)
+    fun zeroIsNotANaturalNumber() {
+        classify(0)
+    }
+
     @Ignore
     @Test(expected = RuntimeException::class)
-    fun mustProvideNaturalNumber() {
-        assertEquals(Classification.DEFICIENT, classify(-1))
+    fun negativeNumberIsNotANaturalNumber() {
+        classify(-1)
     }
 
-}
+}

data/tracks/kotlin/exercises/phone-number/.meta/src/reference/kotlin/PhoneNumber.kt

@@ -1,13 +1,21 @@
 data class PhoneNumber(private val rawNumber: String) {
+
     companion object {
-        private val validationRegex = Regex("^1?([2-9]\\d{2}[2-9]\\d{6})$")
+        private val invalidChars = Regex("[^\\d() -.]")
+        private val digitsValidationRegex = Regex("^1?([2-9]\\d{2}[2-9]\\d{6})$")
     }
-    private val cleanedNumber = rawNumber.replace(Regex("[^\\d]"), "")
 
-    val number = validationRegex.matchEntire(cleanedNumber)?.groupValues?.last() ?: throw IllegalArgumentException()
-    val areaCode = number.substring(0, 3)
-    val exchangeCode = number.substring(3, 6)
-    val subscriberNumber = number.substring(6, 10)
+    val number: String?
+
+    init {
+        val containsInvalidChar = invalidChars.containsMatchIn(rawNumber)
+
+        if (containsInvalidChar) {
+            number = null
+        } else {
+            val digits = rawNumber.replace(Regex("[^\\d]"), "")
+            number = digitsValidationRegex.matchEntire(digits)?.groupValues?.last()
+        }
+    }
 
-    override fun toString() = "($areaCode) $exchangeCode-$subscriberNumber"
 }

data/tracks/kotlin/exercises/phone-number/.meta/version

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

data/tracks/kotlin/exercises/phone-number/src/test/kotlin/PhoneNumberTest.kt

@@ -1,11 +1,10 @@
-import org.junit.Test
 import org.junit.Ignore
+import org.junit.Test
 import kotlin.test.assertEquals
-import kotlin.test.fail
+import kotlin.test.assertNull
 
 class PhoneNumberTest {
 
-
     @Test
     fun cleansNumber() {
         val expectedNumber = "2234567890"
@@ -25,62 +24,80 @@ class PhoneNumberTest {
 
     @Ignore
     @Test
-    fun validWhen11DigitsAndFirstIs1() {
+    fun cleansNumberWithMultipleSpaces() {
         val expectedNumber = "2234567890"
-        val actualNumber = PhoneNumber("12234567890").number
+        val actualNumber = PhoneNumber("223 456   7890   ").number
 
         assertEquals(expectedNumber, actualNumber)
     }
 
     @Ignore
-    @Test(expected = IllegalArgumentException::class)
-    fun invalidWhen10DigitsAndFirstIs1() {
-        val actualNumber = PhoneNumber("1234567890")
+    @Test
+    fun invalidWhen9Digits() {
+        assertNull(PhoneNumber("123456789").number)
+    }
+
+    @Ignore
+    @Test
+    fun invalidWhen11DigitsAndFirstIsNot1() {
+        assertNull(PhoneNumber("22234567890").number)
+    }
+
+    @Ignore
+    @Test
+    fun validWhen11DigitsAndFirstIs1() {
+        val expectedNumber = "2234567890"
+        val actualNumber = PhoneNumber("12234567890").number
 
-        fail("IllegalArgumentException should have been thrown")
+        assertEquals(expectedNumber, actualNumber)
     }
 
     @Ignore
-    @Test(expected = IllegalArgumentException::class)
-    fun invalidWhenOnly11Digits() {
-        val actualNumber = PhoneNumber("21234567890")
+    @Test
+    fun validWhen11DigitsAndFirstIs1WithPunctuation() {
+        val expectedNumber = "2234567890"
+        val actualNumber = PhoneNumber("+1 (223) 456-7890").number
 
-        fail("IllegalArgumentException should have been thrown")
+        assertEquals(expectedNumber, actualNumber)
     }
 
     @Ignore
-    @Test(expected = IllegalArgumentException::class)
-    fun invalidWhen9Digits() {
-        val actualNumber = PhoneNumber("223456789")
+    @Test
+    fun invalidWhenMoreThan11Digits() {
+        val expectedNumber = null
+        val actualNumber = PhoneNumber("321234567890").number
 
-        fail("IllegalArgumentException should have been thrown")
+        assertEquals(expectedNumber, actualNumber)
     }
 
     @Ignore
     @Test
-    fun areaCode() {
-        val expectedAreaCode = "223"
-        val actualAreaCode = PhoneNumber("2234567890").areaCode
+    fun invalidWithLetters() {
+        val expectedNumber = null
+        val actualNumber = PhoneNumber("123-abc-7890").number
 
-        assertEquals(expectedAreaCode, actualAreaCode)
+        assertEquals(expectedNumber, actualNumber)
     }
 
     @Ignore
     @Test
-    fun toStringPrint() {
-        val expectedtoStringNumber = "(223) 456-7890"
-        val actualtoStringNumber = PhoneNumber("2234567890").toString()
+    fun invalidWithInvalidPunctuation() {
+        val expectedNumber = null
+        val actualNumber = PhoneNumber("123-@:!-7890").number
 
-        assertEquals(expectedtoStringNumber, actualtoStringNumber)
+        assertEquals(expectedNumber, actualNumber)
     }
 
     @Ignore
     @Test
-    fun toStringPrintWithFullUSPhoneNumber() {
-        val expectedtoStringNumber = "(223) 456-7890"
-        val actualtoStringNumber = PhoneNumber("12234567890").toString()
+    fun invalidWhenAreaCodeStartsWith0or1() {
+        assertNull(PhoneNumber("(123) 456-7890").number)
+    }
 
-        assertEquals(expectedtoStringNumber, actualtoStringNumber)
+    @Ignore
+    @Test
+    fun invalidWhenExchangeCodeStartsWith0or1() {
+        assertNull(PhoneNumber("(223) 056-7890").number)
     }
 
 }