Day 19

Author: cluddles

aoc-secret

@@ -17,5 +17,7 @@ data class Int2d(val x: Int, val y: Int) {
 
     /** Manhattan distance: sum of absolute [x] and [y] */
     fun manhattan(): Int = x.absoluteValue + y.absoluteValue
+    /** Manhattan distance: absolute [x] and [y] difference */
+    fun manhattan(o: Int2d): Int = (o.x - x).absoluteValue + (o.y - y).absoluteValue
 
 }

src/main/kotlin/com/cluddles/aoc/util/Int2d.kt

@@ -9,20 +9,7 @@ import com.cluddles.aoc.util.Int2d
 import com.cluddles.aoc.util.IntGrid
 import java.util.*
 
-/**
- * RAM Run
- *
- * Thought I was smart by noticing that the grid size (from `0,0` to `70,70`) is actually 71x71
- *
- * The myriad of mistakes I made after this might suggest otherwise:
- * * Reading is hard. We don't just want to add all the interruptions to the grid immediately.
- * * Reading is hard again. For a moment I thought we wanted to have the interruptions appear as we traverse.
- * * `x = x + d.y` was a painful typo that took me a while to spot
- *
- * Initial implementation as quick and easy depth-first search, which is good enough to get the answers.
- *
- * Input grid contains the "tick" that each cell becomes obstructed.
- */
+/** RAM Run */
 object Day18: Solver<Grid<Int>, String> {
 
     override fun prepareInput(src: SolverInput): Grid<Int> {
@@ -41,10 +28,8 @@ object Day18: Solver<Grid<Int>, String> {
     // A* to find lowest cost path from start to end
     private fun lowestCost(start: Int2d, end: Int2d, grid: Grid<Int>, tick: Int): Int? {
         val g = mutableMapOf<Int2d, Int>()
-        val f = mutableMapOf<Int2d, Int>()
-        val open = PriorityQueue<Int2d>(Comparator.comparingInt { f[it]!! })
+        val open = PriorityQueue<Int2d>(Comparator.comparingInt { g[it]!! + it.manhattan(end) })
         g[start] = 0
-        f[start] = (end - start).manhattan()
         open += start
         while (open.isNotEmpty()) {
             val current = open.remove()
@@ -59,7 +44,6 @@ object Day18: Solver<Grid<Int>, String> {
                 }
                 .forEach {
                     g[it] = gNext
-                    f[it] = gNext + (end - it).manhattan()
                     open += it
                 }
         }
@@ -82,11 +66,7 @@ object Day18: Solver<Grid<Int>, String> {
         while (max - min > 1) {
             val current = (min + max) / 2
             val valid = (solvePart1(input, current) != Int.MAX_VALUE)
-            if (valid) {
-                min = current
-            } else {
-                max = current
-            }
+            if (valid) min = current else max = current
         }
         return with (input.iterableWithPos().first { it.data == min }) { "$x,$y" }
     }

src/main/kotlin/com/cluddles/aoc/y2024/Day18.kt

@@ -0,0 +1,53 @@
+package com.cluddles.aoc.y2024
+
+import com.cluddles.aoc.core.Harness
+import com.cluddles.aoc.core.Solver
+import com.cluddles.aoc.core.SolverInput
+import kotlin.collections.mutableMapOf
+
+/** Linen Layout */
+object Day19: Solver<Day19.Input, Long> {
+
+    data class Input(val patterns: List<String>, val towels: List<String>)
+
+    override fun prepareInput(src: SolverInput): Input {
+        return Input(src.lines().first().split(", "), src.lines().drop(1).toList())
+    }
+
+    /** Can [towel] be constructed from given [patterns]. Store known results in [cache]. */
+    fun isPossible(
+        towel: String,
+        patterns: List<String>,
+        cache: MutableMap<String, Boolean> = mutableMapOf()
+    ): Boolean {
+        return cache[towel] ?: patterns
+            .filter { p -> towel.startsWith(p) }
+            .any { p -> if (p == towel) true else isPossible(towel.substring(p.length), patterns, cache) }
+            .also { cache[towel] = it }
+    }
+
+    /** Count ways [towel] can be constructed from [patterns]. Store known results in [cache]. */
+    fun countPossibilities(
+        towel: String,
+        patterns: List<String>,
+        cache: MutableMap<String, Long> = mutableMapOf()
+    ): Long {
+        return cache[towel] ?: patterns
+            .filter { p -> towel.startsWith(p) }
+            .sumOf { p -> if (p == towel) 1L else countPossibilities(towel.substring(p.length), patterns, cache) }
+            .also { cache[towel] = it }
+    }
+
+    override fun solvePart1(input: Input): Long {
+        return input.towels.count { isPossible(it, input.patterns) }.toLong()
+    }
+
+    override fun solvePart2(input: Input): Long {
+        return input.towels.sumOf { countPossibilities(it, input.patterns) }
+    }
+
+}
+
+fun main() {
+    Harness.run(Day19)
+}

src/main/kotlin/com/cluddles/aoc/y2024/Day19.kt

@@ -0,0 +1,21 @@
+package com.cluddles.aoc.y2024
+
+import com.cluddles.aoc.core.SolverInput
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.Test
+
+class Day19Test {
+
+    val solver = Day19
+
+    val input = solver.prepareInput(SolverInput.fromPath(solver.examplePath))
+
+    @Test fun part1() {
+        assertThat(solver.solvePart1(input)).isEqualTo(6)
+    }
+
+    @Test fun part2() {
+        assertThat(solver.solvePart2(input)).isEqualTo(16)
+    }
+
+}

src/test/kotlin/com/cluddles/aoc/y2024/Day19Test.kt

@@ -0,0 +1,10 @@
+r, wr, b, g, bwu, rb, gb, br
+
+brwrr
+bggr
+gbbr
+rrbgbr
+ubwu
+bwurrg
+brgr
+bbrgwb