Solution Day 19, part one (Linen Layout)

* Just check if the word can be constructed with the given tokens and don't
  construct a prefix tree in memory.
* Use memoize() to exploit information of already examined sub-trees.

Author: rhaendel

src/main/kotlin/Day19.kt

@@ -0,0 +1,45 @@
+import de.ronny_h.extensions.PrefixTree
+
+fun main() {
+    val day = "Day19"
+
+    fun part1(input: List<String>): Int {
+        val towels = input.first().split(", ")
+        val designs = input.drop(2)
+
+        println("${towels.size} towels, ${designs.size} designs")
+
+        return designs.count { it.isPossibleWith(towels) }
+    }
+
+    fun part2(input: List<String>): Int {
+        return input.size
+    }
+
+    println("$day part 1")
+
+    val testInput = """
+        r, wr, b, g, bwu, rb, gb, br
+
+        brwrr
+        bggr
+        gbbr
+        rrbgbr
+        ubwu
+        bwurrg
+        brgr
+        bbrgwb
+    """.trimIndent().split('\n')
+    printAndCheck(testInput, ::part1, 6)
+
+    val input = readInput(day)
+    printAndCheck(input, ::part1, 251)
+
+
+    println("$day part 2")
+
+    printAndCheck(testInput, ::part2, 0)
+    printAndCheck(input, ::part2, 0)
+}
+
+private fun String.isPossibleWith(towels: List<String>) = PrefixTree().insert(this, towels)

src/main/kotlin/de/ronny_h/extensions/PrefixTree.kt

@@ -0,0 +1,29 @@
+package de.ronny_h.extensions
+
+class PrefixTree {
+
+    fun insert(word: String, tokens: List<String>): Boolean {
+
+        lateinit var insertRec: (String) -> Boolean
+
+        insertRec = { word: String ->
+            if (word.isEmpty()) {
+                true
+            } else {
+                var success = false
+                for (token in tokens) {
+                    if (!word.startsWith(token)) {
+                        continue
+                    }
+                    if (insertRec(word.substring(token.length))) {
+                        success = true
+                        break
+                    }
+                }
+                success
+            }
+        }.memoize()
+
+        return insertRec(word)
+    }
+}

src/test/kotlin/de/ronny_h/extensions/PrefixTreeTest.kt

@@ -0,0 +1,37 @@
+package de.ronny_h.extensions
+
+import io.kotlintest.shouldBe
+import io.kotlintest.specs.StringSpec
+
+class PrefixTreeTest : StringSpec({
+
+    "an empty word always can be inserted" {
+        val tree = PrefixTree()
+        tree.insert("", listOf("a", "b", "c")) shouldBe true
+    }
+
+    "a word equal to a token can be inserted" {
+        val tree = PrefixTree()
+        tree.insert("abc", listOf("abc")) shouldBe true
+    }
+
+    "a word consisting of single-character tokens can be inserted" {
+        val tree = PrefixTree()
+        tree.insert("abc", listOf("a", "b", "c")) shouldBe true
+    }
+
+    "a word consisting with a missing token can not be inserted" {
+        val tree = PrefixTree()
+        tree.insert("abc", listOf("a", "c")) shouldBe false
+    }
+
+    "a word constructed from token of different lengths can be inserted" {
+        val tree = PrefixTree()
+        tree.insert("abc", listOf("ab", "c")) shouldBe true
+    }
+
+    "a word constructed from multiple combinations of tokens can be inserted" {
+        val tree = PrefixTree()
+        tree.insert("abc", listOf("a", "ab", "bc", "c")) shouldBe true
+    }
+})