Solution Day 19, part two (Linen Layout)

Author: rhaendel

src/main/kotlin/Day19.kt

@@ -3,17 +3,23 @@ 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)
+    fun List<String>.parseTowels(): List<String> = this.first().split(", ")
+    fun List<String>.parseDesigns(): List<String> = drop(2)
 
+    fun part1(input: List<String>): Int {
+        val towels = input.parseTowels()
+        val designs = input.parseDesigns()
         println("${towels.size} towels, ${designs.size} designs")
 
         return designs.count { it.isPossibleWith(towels) }
     }
 
-    fun part2(input: List<String>): Int {
-        return input.size
+    fun part2(input: List<String>): Long {
+        val towels = input.parseTowels()
+        val designs = input.parseDesigns()
+        println("${towels.size} towels, ${designs.size} designs")
+
+        return designs.sumOf { it.countPossibilitiesWith(towels) }
     }
 
     println("$day part 1")
@@ -38,8 +44,9 @@ fun main() {
 
     println("$day part 2")
 
-    printAndCheck(testInput, ::part2, 0)
-    printAndCheck(input, ::part2, 0)
+    printAndCheck(testInput, ::part2, 16)
+    printAndCheck(input, ::part2, 616957151871345)
 }
 
-private fun String.isPossibleWith(towels: List<String>) = PrefixTree().insert(this, towels)
+private fun String.isPossibleWith(towels: List<String>): Boolean = (this.countPossibilitiesWith(towels) > 0)
+private fun String.countPossibilitiesWith(towels: List<String>): Long = PrefixTree().insert(this, towels)

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

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

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

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