Day 08 2025 (#302)

* Day 08 2025

* split out input parsing

* remove duplicate code

Author: peckb1

README.md

@@ -164,6 +164,9 @@ as the value which passed the given day/phase combination
 * Day 13 Being able to solve the basic with shortest path while needing math for part two is always fun re-learning linear algebra. And refactoring always speeds things up.
 * Day 17 Another good example of how powerful Z3 can really be.
 
+#### 2025
+* Day 05 My solution is O(n^3), but due to the size of the input runs ~20ms faster than the better solution of using sorted ranges (the sorting takes the time) 
+
 ## Takeaways
 
 * Setting up a Kotlin project with Dagger should have more examples than the multitude of Android examples out there

src/main/kotlin/me/peckb/aoc/_2025/calendar/day08/Day08.kt

@@ -0,0 +1,127 @@
+package me.peckb.aoc._2025.calendar.day08
+
+import javax.inject.Inject
+import me.peckb.aoc.generators.InputGenerator.InputGeneratorFactory
+import java.util.PriorityQueue
+import java.util.UUID
+import kotlin.collections.get
+import kotlin.math.sqrt
+import kotlin.math.pow
+
+class Day08 @Inject constructor(
+  private val generatorFactory: InputGeneratorFactory,
+) {
+  fun partOne(filename: String) = generatorFactory.forFile(filename).readAs(::day08) { input ->
+    val (_, distances) = createConnections(input)
+    val circuits = connectBoxes(distances) { connections, _ ->
+      // short circuit after we have made 1000 connections
+      connections >= 1000
+    }.first
+
+    circuits.map { it.value.boxes.size }.sortedByDescending { it }.take(3).fold(1) { acc, n -> acc * n }
+  }
+
+  fun partTwo(filename: String) = generatorFactory.forFile(filename).readAs(::day08) { input ->
+    val (boxes, distances) = createConnections(input)
+    val lastConnection = connectBoxes(distances) { _, circuits ->
+      // short circuit after we have a circuit that contains every box
+      circuits[boxes.first().circuitId]?.boxes?.size == boxes.size
+    }.second
+
+    lastConnection.fold(1L) { acc, n -> acc * n.x }
+  }
+
+  private fun day08(line: String) = line.split(",")
+    .map { it.toLong() }
+    .let { (x, y, z) -> Box(x, y, z) }
+
+  private fun createConnections(input: Sequence<Box>): Pair<List<Box>, PriorityQueue<Distance>> {
+    val boxes = input.toList()
+
+    val distances = PriorityQueue<Distance>()
+
+    boxes.forEachIndexed { index, box1 ->
+      ((index + 1)until boxes.size).forEach { box2Index ->
+        distances.add(Distance(box1, boxes[box2Index]))
+      }
+    }
+
+    return boxes to distances
+  }
+
+  private fun connectBoxes(distances: PriorityQueue<Distance>, shortCircuit: (Long, Map<String, Circuit>) -> Boolean) : Pair<MutableMap<String, Circuit>, MutableList<Box>> {
+    var connectionsMade = 0L
+    val circuits = mutableMapOf<String, Circuit>()
+    val lastConnection = mutableListOf<Box>()
+
+    while(distances.isNotEmpty()) {
+      connectionsMade++
+      val distance = distances.poll()
+      val b1 = distance.b1
+      val b2 = distance.b2
+
+      if (b1.circuitId != null && b2.circuitId == b1.circuitId) {
+        // if the two are already in the same circuit
+        // do nothing!
+      } else if (b1.circuitId == null && b2.circuitId == null) {
+        // if neither are in a circuit, make a new circuit that contains them
+        val circuit = Circuit(UUID.randomUUID().toString())
+        b1.circuitId = circuit.id
+        b2.circuitId = circuit.id
+        circuit.add(b1)
+        circuit.add(b2)
+        circuits[circuit.id] = circuit
+      } else if (b1.circuitId == null) {
+        // b1 gets to join b2's circuit
+        circuits[b2.circuitId]!!.add(b1)
+        b1.circuitId = b2.circuitId
+      } else if (b2.circuitId == null) {
+        // b2 gets to join b1's circuit
+        circuits[b1.circuitId]!!.add(b2)
+        b2.circuitId = b1.circuitId
+      } else {
+        // we need to collapse the circuits!
+        val firstCircuit = circuits[b1.circuitId]!!
+        val secondCircuit = circuits[b2.circuitId]!!
+        // we pick b2 to "lose" and join b1 - theoretically you would want to have the smaller circuit join the larger
+        circuits.remove(b2.circuitId)
+        secondCircuit.boxes.forEach { box ->
+          box.circuitId = firstCircuit.id
+          firstCircuit.add(box)
+        }
+      }
+
+      if (shortCircuit(connectionsMade, circuits)) {
+        lastConnection.add(b1)
+        lastConnection.add(b2)
+        distances.clear()
+      }
+    }
+
+    return circuits to lastConnection
+  }
+}
+
+data class Box(val x: Long, val y: Long, val z: Long, var circuitId: String? = null) {
+  override fun toString(): String = "($x, $y, $z)"
+}
+
+data class Circuit(val id: String, val boxes: MutableList<Box> = mutableListOf()) {
+  fun add(box: Box) = boxes.add(box)
+
+  override fun toString(): String = "size: ${boxes.size}"
+}
+
+data class Distance(val b1: Box, val b2: Box, val distance: Double = euclideanDistance(b1, b2)) : Comparable<Distance> {
+  override fun compareTo(other: Distance): Int {
+    return this.distance.compareTo(other.distance)
+  }
+}
+
+fun euclideanDistance(b1: Box, b2: Box): Double {
+  val deltaX = b2.x - b1.x
+  val deltaY = b2.y - b1.y
+  val deltaZ = b2.z - b1.z
+
+  return sqrt(deltaX.toDouble().pow(2) + deltaY.toDouble().pow(2) + deltaZ.toDouble().pow(2))
+}

src/main/kotlin/me/peckb/aoc/_2025/calendar/day08/README.md

@@ -0,0 +1 @@
+## [Day 8: Playground](https://adventofcode.com/2025/day/8)

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

@@ -7,6 +7,7 @@ import me.peckb.aoc._2025.calendar.day04.Day04Test
 import me.peckb.aoc._2025.calendar.day05.Day05Test
 import me.peckb.aoc._2025.calendar.day06.Day06Test
 import me.peckb.aoc._2025.calendar.day07.Day07Test
+import me.peckb.aoc._2025.calendar.day08.Day08Test
 import javax.inject.Singleton
 import me.peckb.aoc.DayComponent
 import me.peckb.aoc.InputModule
@@ -22,4 +23,5 @@ internal interface TestDayComponent : DayComponent {
   fun inject(day05Test: Day05Test)
   fun inject(day06Test: Day06Test)
   fun inject(day07Test: Day07Test)
+  fun inject(day08Test: Day08Test)
 }

src/test/kotlin/me/peckb/aoc/_2025/calendar/day08/Day08Test.kt

@@ -0,0 +1,32 @@
+package me.peckb.aoc._2025.calendar.day08
+
+import javax.inject.Inject
+
+import me.peckb.aoc._2025.DaggerTestDayComponent
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+
+internal class Day08Test {
+  @Inject
+  lateinit var day08: Day08
+
+  @BeforeEach
+  fun setup() {
+    DaggerTestDayComponent.create().inject(this)
+  }
+
+  @Test
+  fun testDay08PartOne() {
+    assertEquals(68112, day08.partOne(DAY_08))
+  }
+
+  @Test
+  fun testDay08PartTwo() {
+    assertEquals(44543856, day08.partTwo(DAY_08))
+  }
+
+  companion object {
+    private const val DAY_08: String = "advent-of-code-input/2025/day08.input"
+  }
+}