trackler 2.2.1.52 → 2.2.1.53

data/tracks/java/scripts/canonical_data_check.sh

@@ -62,6 +62,7 @@ then
 fi
 
 track_exercise_slugs=$(jq '.exercises[] | select(has("deprecated") | not) | .slug' $config_file_path | tr -d "\"")
+update_needed_count=0
 
 for slug in $track_exercise_slugs
 do
@@ -88,6 +89,7 @@ do
     if ! [ -f "$track_exercise_version_file_path" ]
     then
         echo "$slug: needs update or version file (v$canonical_data_version)."
+        update_needed_count=$((update_needed_count + 1))
         continue
     fi
 
@@ -98,7 +100,13 @@ do
         # echo "$slug: up-to-date."
         continue
     else
+        update_needed_count=$((update_needed_count + 1))
         echo "$slug: needs update (v$track_data_version -> v$canonical_data_version)."
     fi
 
 done
+
+if [ $update_needed_count -eq 1 ]
+then
+    echo "All exercises are up to date!"
+fi

data/tracks/kotlin/.gitignore

@@ -7,3 +7,4 @@ build
 .gradle
 .idea
 *.iml
+out/

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

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

data/tracks/kotlin/exercises/acronym/src/test/kotlin/AcronymTest.kt

@@ -4,7 +4,6 @@ import kotlin.test.assertEquals
 
 class AcronymTest {
 
-
     @Test
     fun fromTitleCasedPhrases() {
         val phrase = "Portable Network Graphics"
@@ -20,14 +19,6 @@ class AcronymTest {
         assertEquals(expected, Acronym.generate(phrase))
     }
 
-    @Ignore
-    @Test
-    fun fromInconsistentlyCasedPhrases() {
-        val phrase = "HyperText Markup Language"
-        val expected = "HTML"
-        assertEquals(expected, Acronym.generate(phrase))
-    }
-
     @Ignore
     @Test
     fun fromPhrasesWithPunctuation() {
@@ -38,12 +29,20 @@ class AcronymTest {
 
     @Ignore
     @Test
-    fun fromOtherPhrasesWithPunctuation() {
+    fun fromAllCapsWord() {
         val phrase = "PHP: Hypertext Preprocessor"
         val expected = "PHP"
         assertEquals(expected, Acronym.generate(phrase))
     }
 
+    @Ignore
+    @Test
+    fun fromNonAcronymAllCapsWord() {
+        val phrase = "GNU Image Manipulation Program"
+        val expected = "GIMP"
+        assertEquals(expected, Acronym.generate(phrase))
+    }
+
     @Ignore
     @Test
     fun fromPhrasesWithPunctuationAndSentenceCasing() {

data/tracks/kotlin/exercises/all-your-base/.meta/version

@@ -1 +1 @@
-1.0.0
+1.1.0

data/tracks/kotlin/exercises/all-your-base/src/test/kotlin/BaseConverterTest.kt

@@ -168,69 +168,69 @@ class BaseConverterTest {
 
     @Ignore
     @Test
-    fun testNegativeDigit() {
+    fun testFirstBaseIsOne() {
         expectedException.expect(IllegalArgumentException::class.java)
-        expectedException.expectMessage("Digits may not be negative.")
+        expectedException.expectMessage("Bases must be at least 2.")
 
-        BaseConverter(2, intArrayOf(1, -1, 1, 0, 1, 0))
+        BaseConverter(1, intArrayOf())
     }
 
     @Ignore
     @Test
-    fun testInvalidPositiveDigit() {
+    fun testFirstBaseIsZero() {
         expectedException.expect(IllegalArgumentException::class.java)
-        expectedException.expectMessage("All digits must be strictly less than the base.")
+        expectedException.expectMessage("Bases must be at least 2.")
 
-        BaseConverter(2, intArrayOf(1, 2, 1, 0, 1, 0))
+        BaseConverter(0, intArrayOf())
     }
 
     @Ignore
     @Test
-    fun testFirstBaseIsOne() {
+    fun testFirstBaseIsNegative() {
         expectedException.expect(IllegalArgumentException::class.java)
         expectedException.expectMessage("Bases must be at least 2.")
 
-        BaseConverter(1, intArrayOf())
+        BaseConverter(-2, intArrayOf())
     }
 
     @Ignore
     @Test
-    fun testSecondBaseIsOne() {
-        val baseConverter = BaseConverter(2, intArrayOf(1, 0, 1, 0, 1, 0))
-
+    fun testNegativeDigit() {
         expectedException.expect(IllegalArgumentException::class.java)
-        expectedException.expectMessage("Bases must be at least 2.")
+        expectedException.expectMessage("Digits may not be negative.")
 
-        baseConverter.convertToBase(1)
+        BaseConverter(2, intArrayOf(1, -1, 1, 0, 1, 0))
     }
 
     @Ignore
     @Test
-    fun testFirstBaseIsZero() {
+    fun testInvalidPositiveDigit() {
         expectedException.expect(IllegalArgumentException::class.java)
-        expectedException.expectMessage("Bases must be at least 2.")
+        expectedException.expectMessage("All digits must be strictly less than the base.")
 
-        BaseConverter(0, intArrayOf())
+        BaseConverter(2, intArrayOf(1, 2, 1, 0, 1, 0))
     }
 
     @Ignore
     @Test
-    fun testSecondBaseIsZero() {
+    fun testSecondBaseIsOne() {
         val baseConverter = BaseConverter(2, intArrayOf(1, 0, 1, 0, 1, 0))
 
         expectedException.expect(IllegalArgumentException::class.java)
         expectedException.expectMessage("Bases must be at least 2.")
 
-        baseConverter.convertToBase(0)
+        baseConverter.convertToBase(1)
     }
 
     @Ignore
     @Test
-    fun testFirstBaseIsNegative() {
+    fun testSecondBaseIsZero() {
+        val baseConverter = BaseConverter(2, intArrayOf(1, 0, 1, 0, 1, 0))
+
         expectedException.expect(IllegalArgumentException::class.java)
         expectedException.expectMessage("Bases must be at least 2.")
 
-        BaseConverter(-2, intArrayOf())
+        baseConverter.convertToBase(0)
     }
 
     @Ignore

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

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

data/tracks/kotlin/exercises/allergies/src/test/kotlin/AllergiesTest.kt

@@ -1,18 +1,18 @@
 import org.junit.Test
 import org.junit.Ignore
 import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
 
 class AllergiesTest {
 
-
     @Test
     fun noAllergiesMeansNotAllergicToAnything() {
         val allergies = Allergies(0)
 
-        assertEquals(false, allergies.isAllergicTo(Allergen.EGGS))
-        assertEquals(false, allergies.isAllergicTo(Allergen.PEANUTS))
-        assertEquals(false, allergies.isAllergicTo(Allergen.STRAWBERRIES))
-        assertEquals(false, allergies.isAllergicTo(Allergen.CATS))
+        assertFalse(allergies.isAllergicTo(Allergen.PEANUTS))
+        assertFalse(allergies.isAllergicTo(Allergen.CATS))
+        assertFalse(allergies.isAllergicTo(Allergen.STRAWBERRIES))
     }
 
     @Ignore
@@ -20,71 +20,17 @@ class AllergiesTest {
     fun allergicToEggs() {
         val allergies = Allergies(1)
 
-        assertEquals(true, allergies.isAllergicTo(Allergen.EGGS))
-    }
-
-    @Ignore
-    @Test
-    fun allergicToPeanuts() {
-        val allergies = Allergies(2)
-
-        assertEquals(true, allergies.isAllergicTo(Allergen.PEANUTS))
-    }
-
-    @Ignore
-    @Test
-    fun allergicToShellfish() {
-        val allergies = Allergies(4)
-
-        assertEquals(true, allergies.isAllergicTo(Allergen.SHELLFISH))
-    }
-
-    @Ignore
-    @Test
-    fun allergicToStrawberries() {
-        val allergies = Allergies(8)
-
-        assertEquals(true, allergies.isAllergicTo(Allergen.STRAWBERRIES))
+        assertTrue(allergies.isAllergicTo(Allergen.EGGS))
     }
 
     @Ignore
     @Test
-    fun allergicToTomatoes() {
-        val allergies = Allergies(16)
-
-        assertEquals(true, allergies.isAllergicTo(Allergen.TOMATOES))
-    }
-
-    @Ignore
-    @Test
-    fun allergicToChocolate() {
-        val allergies = Allergies(32)
-
-        assertEquals(true, allergies.isAllergicTo(Allergen.CHOCOLATE))
-    }
-
-    @Ignore
-    @Test
-    fun allergicToPollen() {
-        val allergies = Allergies(64)
-
-        assertEquals(true, allergies.isAllergicTo(Allergen.POLLEN))
-    }
-
-    @Ignore
-    @Test
-    fun allergicToCats() {
-        val allergies = Allergies(128)
-
-        assertEquals(true, allergies.isAllergicTo(Allergen.CATS))
-    }
-
-    @Ignore
-    @Test
-    fun isAllergicToEggsInAdditionToOtherStuff() {
+    fun allergicToEggsAndOtherThings() {
         val allergies = Allergies(5)
 
-        assertEquals(true, allergies.isAllergicTo(Allergen.EGGS))
+        assertTrue(allergies.isAllergicTo(Allergen.EGGS))
+        assertTrue(allergies.isAllergicTo(Allergen.SHELLFISH))
+        assertFalse(allergies.isAllergicTo(Allergen.STRAWBERRIES))
     }
 
     @Ignore
@@ -92,12 +38,12 @@ class AllergiesTest {
     fun noAllergies() {
         val allergies = Allergies(0)
 
-        assertEquals(0, allergies.getList().size)
+        assertTrue(allergies.getList().isEmpty())
     }
 
     @Ignore
     @Test
-    fun isAllergicToJustEggs() {
+    fun allergicToJustEggs() {
         val allergies = Allergies(1)
         val expectedAllergens = listOf(Allergen.EGGS)
 
@@ -106,7 +52,7 @@ class AllergiesTest {
 
     @Ignore
     @Test
-    fun isAllergicToJustPeanuts() {
+    fun allergicToJustPeanuts() {
         val allergies = Allergies(2)
         val expectedAllergens = listOf(Allergen.PEANUTS)
 
@@ -115,7 +61,7 @@ class AllergiesTest {
 
     @Ignore
     @Test
-    fun isAllergicToJustStrawberries() {
+    fun allergicToJustStrawberries() {
         val allergies = Allergies(8)
         val expectedAllergens = listOf(Allergen.STRAWBERRIES)
 
@@ -124,7 +70,7 @@ class AllergiesTest {
 
     @Ignore
     @Test
-    fun isAllergicToEggsAndPeanuts() {
+    fun allergicToEggsAndPeanuts() {
         val allergies = Allergies(3)
         val expectedAllergens = listOf(
                 Allergen.EGGS,
@@ -136,7 +82,7 @@ class AllergiesTest {
 
     @Ignore
     @Test
-    fun isAllergicToEggsAndShellfish() {
+    fun allergicToEggsAndShellfish() {
         val allergies = Allergies(5)
         val expectedAllergens = listOf(
                 Allergen.EGGS,
@@ -148,7 +94,7 @@ class AllergiesTest {
 
     @Ignore
     @Test
-    fun isAllergicToLotsOfStuff() {
+    fun allergicToLotsOfStuff() {
         val allergies = Allergies(248)
         val expectedAllergens = listOf(
                 Allergen.STRAWBERRIES,
@@ -163,7 +109,7 @@ class AllergiesTest {
 
     @Ignore
     @Test
-    fun isAllergicToEverything() {
+    fun allergicToEverything() {
         val allergies = Allergies(255)
         val expectedAllergens = listOf(
                 Allergen.EGGS,
@@ -195,4 +141,5 @@ class AllergiesTest {
 
         assertEquals(expectedAllergens, allergies.getList())
     }
+
 }

data/tracks/kotlin/exercises/anagram/.meta/src/reference/kotlin/Anagram.kt

@@ -1,8 +1,11 @@
-class Anagram(val word: String) {
+class Anagram(private val word: String) {
+
     fun match(anagrams: Collection<String>) =
-            anagrams.filter({ doesMatch(it) }).filterNot({ it.equals(word, ignoreCase = true) })
+            anagrams.filter { containSameChars(it.toLowerCase()) }
+                    .filterNot { it.equals(word, ignoreCase = true) }
+                    .toSet()
 
-    private fun doesMatch(anagram: String) =
-            anagram.toLowerCase().toCharArray().sorted() == word.toLowerCase().toCharArray().sorted()
+    private fun containSameChars(candidate: String) =
+            candidate.toLowerCase().toCharArray().sorted() == word.toLowerCase().toCharArray().sorted()
 
 }

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

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

data/tracks/kotlin/exercises/anagram/src/test/kotlin/AnagramTest.kt

@@ -4,81 +4,128 @@ import kotlin.test.assertEquals
 
 class AnagramTest {
 
-
     @Test
     fun noMatches() {
         val detector = Anagram("diaper")
-        assertEquals(listOf(), detector.match(listOf("hello", "world", "zombies", "pants")))
+        assertEquals(emptySet(), detector.match(listOf("hello", "world", "zombies", "pants")))
     }
 
     @Ignore
     @Test
-    fun simpleAnagram() {
+    fun detectsSimpleAnagram() {
         val detector = Anagram("ant")
         val anagram = detector.match(listOf("tan", "stand", "at"))
-        assertEquals(listOf("tan"), anagram)
+        assertEquals(setOf("tan"), anagram)
+    }
+
+    @Ignore
+    @Test
+    fun doesNotDetectFalsePositives() {
+        val detector = Anagram("galea")
+        val anagrams = detector.match(listOf("eagle"))
+        assertEquals(emptySet(), anagrams)
     }
 
     @Ignore
     @Test
-    fun detectMultipleAnagrams() {
+    fun detectsTwoAnagrams() {
         val detector = Anagram("master")
         val anagrams = detector.match(listOf("stream", "pigeon", "maters"))
-        assertEquals(listOf("maters", "stream"), anagrams.sorted())
+        assertEquals(setOf("maters", "stream"), anagrams)
     }
 
     @Ignore
     @Test
-    fun doesNotConfuseDifferentDuplicates() {
-        val detector = Anagram("galea")
-        val anagrams = detector.match(listOf("eagle"))
-        assertEquals(listOf(), anagrams)
+    fun doesNotDetectAnagramSubsets() {
+        val detector = Anagram("good")
+        assertEquals(emptySet(), detector.match(listOf("dog", "goody")))
     }
 
     @Ignore
     @Test
-    fun identicalWordIsNotAnagram() {
+    fun detectsLongerAnagram() {
+        val detector = Anagram("listen")
+        val anagrams = detector.match(listOf("enlists", "google", "inlets", "banana"))
+        assertEquals(setOf("inlets"), anagrams)
+    }
+
+    @Ignore
+    @Test
+    fun detectsThreeAnagrams() {
+        val detector = Anagram("allergy")
+        val anagrams = detector.match(listOf("gallery", "ballerina", "regally", "clergy", "largely", "leading"))
+        assertEquals(setOf("gallery", "largely", "regally"), anagrams)
+    }
+
+    @Ignore
+    @Test
+    fun doesNotDetectIdenticalWordAsAnagram() {
         val detector = Anagram("corn")
         val anagrams = detector.match(listOf("corn", "dark", "Corn", "rank", "CORN", "cron", "park"))
-        assertEquals(listOf("cron"), anagrams)
+        assertEquals(setOf("cron"), anagrams)
     }
 
     @Ignore
     @Test
-    fun eliminateAnagramsWithSameChecksum() {
+    fun doesNotDetectNonAnagramsWithIdenticalChecksums() {
         val detector = Anagram("mass")
-        assertEquals(listOf(), detector.match(listOf("last")))
+        assertEquals(emptySet(), detector.match(listOf("last")))
     }
 
     @Ignore
     @Test
-    fun eliminateAnagramSubsets() {
-        val detector = Anagram("good")
-        assertEquals(listOf(), detector.match(listOf("dog", "goody")))
+    fun detectsAnagramsCaseInsensitively() {
+        val detector = Anagram("Orchestra")
+        val anagrams = detector.match(listOf("cashregister", "Carthorse", "radishes"))
+        assertEquals(setOf("Carthorse"), anagrams)
     }
 
     @Ignore
     @Test
-    fun detectAnagrams() {
-        val detector = Anagram("listen")
-        val anagrams = detector.match(listOf("enlists", "google", "inlets", "banana"))
-        assertEquals(listOf("inlets"), anagrams)
+    fun detectsAnagramsUsingCaseInsensitiveSubject() {
+        val detector = Anagram("Orchestra")
+        val anagrams = detector.match(listOf("cashregister", "carthorse", "radishes"))
+        assertEquals(setOf("carthorse"), anagrams)
     }
 
     @Ignore
     @Test
-    fun multipleAnagrams() {
-        val detector = Anagram("allergy")
-        val anagrams = detector.match(listOf("gallery", "ballerina", "regally", "clergy", "largely", "leading"))
-        assertEquals(listOf("gallery", "largely", "regally"), anagrams.sorted())
+    fun detectsAnagramsUsingCaseInsensitiveCandidates() {
+        val detector = Anagram("orchestra")
+        val anagrams = detector.match(listOf("cashregister", "Carthorse", "radishes"))
+        assertEquals(setOf("Carthorse"), anagrams)
     }
 
     @Ignore
     @Test
-    fun anagramsAreCaseInsensitive() {
-        val detector = Anagram("Orchestra")
-        val anagrams = detector.match(listOf("cashregister", "Carthorse", "radishes"))
-        assertEquals(listOf("Carthorse"), anagrams)
+    fun doesNotDetectIdenticalWordWithMixedCasingAsAnagram() {
+        val detector = Anagram("banana")
+        val anagrams = detector.match(listOf("Banana"))
+        assertEquals(emptySet(), anagrams)
+    }
+
+    @Ignore
+    @Test
+    fun doesNotDetectAnAnagramIfTheOriginalWordIsRepeated() {
+        val detector = Anagram("go")
+        val anagrams = detector.match(listOf("go Go GO"))
+        assertEquals(emptySet(), anagrams)
+    }
+
+    @Ignore
+    @Test
+    fun anagramsMustUseAllLettersExactlyOnce() {
+        val detector = Anagram("tapper")
+        val anagrams = detector.match(listOf("patter"))
+        assertEquals(emptySet(), anagrams)
+    }
+
+    @Ignore
+    @Test
+    fun doesNotDetectIdenticalUppercasedWordAsAnagram() {
+        val detector = Anagram("BANANA")
+        val anagrams = detector.match(listOf("Banana"))
+        assertEquals(emptySet(), anagrams)
     }
 
 }