Day 13 2024 (#272)

Author: peckb1

README.md

@@ -103,6 +103,8 @@ as the value which passed the given day/phase combination
 #### 2024
 * Day 03
   * Regex shining today! Sorting by the match location made the single list of all matches easy to scan through.
+* Day 12
+  * Not a day where I had the best solution; but a solution nonetheless. Slow scan of each field's border; ain't much, but it's honest work. 
 
 ### Interesting approaches:
 
@@ -153,7 +155,11 @@ as the value which passed the given day/phase combination
 #### 2023
 * Day 05 The fact that the numbers are "small" meant just starting at 0 and iterating over every location until we found one that matches a seed helps avoid the "forever" brute force solutions
 * Day 14 Rather than trying to make sure you found the right indices for tilting rocks east, west, or south just rotate the mirror and keep tilting north
-* Day 18 Learning about the Minkowski Sum for thick edge convex hull areas 
+* Day 18 Learning about the Minkowski Sum for thick edge convex hull areas
+
+#### 2024
+* Day 11 The fact that the order of stones didn't actually matter helped to allow us to just keep a list of how many we had.
+* Day 13 Being able to solve the basic with shortest path while needing math for part two is always fun re-learning linear algebra.
 
 ## Takeaways
 

src/main/kotlin/me/peckb/aoc/_2024/calendar/day13/Day13.kt

@@ -0,0 +1,121 @@
+package me.peckb.aoc._2024.calendar.day13
+
+import com.microsoft.z3.BitVecNum
+import com.microsoft.z3.BitVecSort
+import com.microsoft.z3.Context
+import com.microsoft.z3.Expr
+import com.microsoft.z3.Status
+import me.peckb.aoc._2024.calendar.day13.ClawGameDijkstra.GameNode
+import javax.inject.Inject
+import me.peckb.aoc.generators.InputGenerator.InputGeneratorFactory
+import me.peckb.aoc.pathing.GenericIntDijkstra
+
+class Day13 @Inject constructor(
+  private val generatorFactory: InputGeneratorFactory,
+) {
+  fun partOne(filename: String) = generatorFactory.forFile(filename).read { input ->
+    input.chunked(4)
+      .mapNotNull { (a, b, p, _) ->
+        val aSpeed = parse(a.split("A: ").last()).let{ (x, y) -> Speed(x, y)    }
+        val bSpeed = parse(b.split("B: ").last()).let{ (x, y) -> Speed(x, y)    }
+        val prize = parse(p.split(": ").last()).let{ (x, y) -> GameNode(x, y) }
+
+        val game = ClawGameDijkstra(aSpeed, bSpeed, prize)
+
+        val solutions = game.solve(GameNode(0, 0).withGame(game), prize.withGame(game))
+
+        solutions[prize]
+      }
+      .sum()
+  }
+
+  fun partTwo(filename: String) = generatorFactory.forFile(filename).read { input ->
+    input.chunked(4)
+      .mapNotNull { (a, b, p, _) ->
+        val aSpeed = parse(a.split("A: ").last()).let{ (x, y) -> Speed(x, y)    }
+        val bSpeed = parse(b.split("B: ").last()).let{ (x, y) -> Speed(x, y)    }
+        val prize = parse(p.split(": ").last()).let{ (x, y) -> x + BUFFER to y + BUFFER }
+
+        Context().use { ctx ->
+          val solver = ctx.mkSolver()
+
+          val longType = ctx.mkBitVecSort(64)
+          fun variableOf(name: String) = ctx.mkConst(name, longType)
+          fun valueOf(value: Long) = ctx.mkNumeral(value, longType) as BitVecNum
+          operator fun Expr<BitVecSort>.times(t: Expr<BitVecSort>) = ctx.mkBVMul(this, t)
+          operator fun Expr<BitVecSort>.plus(t: Expr<BitVecSort>) = ctx.mkBVAdd(this, t)
+          infix fun Expr<BitVecSort>.equalTo(t: Expr<BitVecSort>) = ctx.mkEq(this, t)
+          infix fun Expr<BitVecSort>.greaterThan(t: Expr<BitVecSort>) = ctx.mkBVSGT(this, t)
+          infix fun Expr<BitVecSort>.lessThan(t: Expr<BitVecSort>) = ctx.mkBVSLT(this, t)
+
+          val zero = valueOf(0)
+          val max = valueOf(500_000_000_000)
+          val aPress = variableOf("x")
+          val bPress = variableOf("y")
+          val aXSpeed = valueOf(aSpeed.x.toLong())
+          val aYSpeed = valueOf(aSpeed.y.toLong())
+          val bXSpeed = valueOf(bSpeed.x.toLong())
+          val bYSpeed = valueOf(bSpeed.y.toLong())
+          val prizeX = valueOf(prize.first)
+          val prizeY = valueOf(prize.second)
+
+          solver.add(aPress greaterThan zero)
+          solver.add(bPress greaterThan zero)
+          solver.add(aPress lessThan max)
+          solver.add(bPress lessThan max)
+          solver.add((aXSpeed * aPress) + (bXSpeed * bPress) equalTo prizeX)
+          solver.add((aYSpeed * aPress) + (bYSpeed * bPress) equalTo prizeY)
+
+          val status = solver.check()
+
+          if (status == Status.SATISFIABLE) {
+            val model = solver.model
+            val aButtonCost = (model.evaluate(aPress, true) as BitVecNum).long * A_COST
+            val bButtonCost = (model.evaluate(bPress, true) as BitVecNum).long * B_COST
+
+            aButtonCost + bButtonCost
+          } else {
+            null
+          }
+        }
+      }
+      .sum()
+  }
+
+  private fun parse(data: String): Pair<Int, Int> {
+    return data.split(", ").map{ it.drop(2).toInt() }.let { (x, y) -> x to y }
+  }
+
+  companion object {
+    private const val BUFFER = 10000000000000
+    private const val A_COST = 3
+    private const val B_COST = 1
+  }
+}
+
+class ClawGameDijkstra(val speedA: Speed, val speedB: Speed, val destination: GameNode) : GenericIntDijkstra<GameNode>() {
+
+  data class GameNode(val x: Int, val y: Int) : DijkstraNode<GameNode> {
+    lateinit var game: ClawGameDijkstra
+
+    fun withGame(game: ClawGameDijkstra) = apply { this.game = game }
+
+    override fun neighbors(): Map<GameNode, Int> {
+      return mutableMapOf<GameNode, Int>().apply {
+        if (x + game.speedA.x <= game.destination.x && y + game.speedA.y <= game.destination.y) {
+          put(GameNode(x + game.speedA.x, y + game.speedA.y).withGame(game), A_COST)
+        }
+        if (x + game.speedB.x <= game.destination.x && y + game.speedB.y <= game.destination.y) {
+          put(GameNode(x + game.speedB.x, y + game.speedB.y).withGame(game), B_COST)
+        }
+      }
+    }
+  }
+
+  companion object {
+    private const val A_COST = 3
+    private const val B_COST = 1
+  }
+}
+
+data class Speed(val x: Int, val y: Int)

src/main/kotlin/me/peckb/aoc/_2024/calendar/day13/README.md

@@ -0,0 +1 @@
+## [Day 13: Claw Contraption](https://adventofcode.com/2024/day/13)

src/test/kotlin/me/peckb/aoc/_2024/TestDayComponent.kt

@@ -12,6 +12,7 @@ import me.peckb.aoc._2024.calendar.day09.Day09Test
 import me.peckb.aoc._2024.calendar.day10.Day10Test
 import me.peckb.aoc._2024.calendar.day11.Day11Test
 import me.peckb.aoc._2024.calendar.day12.Day12Test
+import me.peckb.aoc._2024.calendar.day13.Day13Test
 import javax.inject.Singleton
 import me.peckb.aoc.DayComponent
 import me.peckb.aoc.InputModule
@@ -32,4 +33,5 @@ internal interface TestDayComponent : DayComponent {
   fun inject(day10Test: Day10Test)
   fun inject(day11Test: Day11Test)
   fun inject(day12Test: Day12Test)
+  fun inject(day13Test: Day13Test)
 }

src/test/kotlin/me/peckb/aoc/_2024/calendar/day13/Day13Test.kt

@@ -0,0 +1,32 @@
+package me.peckb.aoc._2024.calendar.day13
+
+import javax.inject.Inject
+
+import me.peckb.aoc._2024.DaggerTestDayComponent
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+
+internal class Day13Test {
+  @Inject
+  lateinit var day13: Day13
+
+  @BeforeEach
+  fun setup() {
+    DaggerTestDayComponent.create().inject(this)
+  }
+
+  @Test
+  fun testDay13PartOne() {
+    assertEquals(33209, day13.partOne(DAY_13))
+  }
+
+  @Test
+  fun testDay13PartTwo() {
+    assertEquals(83102355665474, day13.partTwo(DAY_13))
+  }
+
+  companion object {
+    private const val DAY_13: String = "advent-of-code-input/2024/day13.input"
+  }
+}