Solution 2025-08 (Playground)

Author: rhaendel

src/main/kotlin/de/ronny_h/aoc/extensions/Combinations.kt

@@ -16,6 +16,17 @@ fun <E> Iterable<E>.combinations() = sequence {
     }
 }
 
+/**
+ * @return All pairwise combinations of list elements without the reflexive and symmetrical ones.
+ */
+fun <E> List<E>.symmetricalCombinations() = sequence {
+    forEachIndexed { i, a ->
+        for (j in i + 1..lastIndex) {
+            yield(a to get(j))
+        }
+    }
+}
+
 /**
  * @return All pairwise combinations of list elements of the [first] and the [second] list.
  */

src/main/kotlin/de/ronny_h/aoc/extensions/numbers/IntegralNumbers.kt

@@ -26,6 +26,8 @@ fun Long.toIntChecked(): Int {
     return this.toInt()
 }
 
+fun Long.squared() = this * this
+
 /**
  * @return This Int to the power of [power].
  */

src/main/kotlin/de/ronny_h/aoc/extensions/threedim/Vector.kt

@@ -1,7 +1,9 @@
 package de.ronny_h.aoc.extensions.threedim
 
+import de.ronny_h.aoc.extensions.numbers.squared
 import kotlin.math.abs
 import kotlin.math.cbrt
+import kotlin.math.sqrt
 
 data class Vector(val x: Long, val y: Long, val z: Long) {
     companion object {
@@ -10,7 +12,11 @@ data class Vector(val x: Long, val y: Long, val z: Long) {
 
     operator fun plus(other: Vector) = Vector(x + other.x, y + other.y, z + other.z)
     operator fun minus(other: Vector) = Vector(x - other.x, y - other.y, z - other.z)
+
     infix fun taxiDistanceTo(other: Vector): Long = abs(other.x - x) + abs(other.y - y) + abs(other.z - z)
+    infix fun straightLineDistanceTo(other: Vector): Double =
+        sqrt((other.x - x).squared().toDouble() + (other.y - y).squared() + (other.z - z).squared())
+
     fun abs(): Double = cbrt(x * x.toDouble() + y * y.toDouble() + z * z.toDouble())
 }
 

src/main/kotlin/de/ronny_h/aoc/year2025/day08/Playground.kt

@@ -0,0 +1,75 @@
+package de.ronny_h.aoc.year2025.day08
+
+import de.ronny_h.aoc.AdventOfCode
+import de.ronny_h.aoc.extensions.symmetricalCombinations
+import de.ronny_h.aoc.extensions.threedim.Vector
+import de.ronny_h.aoc.extensions.threedim.Vector.Companion.ZERO
+
+fun main() = Playground().run(122430, 8135565324)
+
+class Playground : AdventOfCode<Long>(2025, 8) {
+    override fun part1(input: List<String>): Long = JunctionBoxConnector(input).connectShortest(1000)
+
+    override fun part2(input: List<String>): Long = JunctionBoxConnector(input).connectShortest()
+}
+
+fun List<String>.parseJunctionBoxes() = map { it.split(",").map(String::toLong) }
+    .map { (x, y, z) -> Vector(x, y, z) }
+
+class JunctionBoxConnector(input: List<String>) {
+
+    private val boxes = input.parseJunctionBoxes()
+
+    fun connectShortest(n: Int? = null): Long {
+        val distances = boxes.pairwiseDistances()
+            .sortedBy { it.distance }
+            .let { dist -> n?.let { dist.take(n) } ?: dist }
+        val circuits = mutableListOf<MutableSet<Vector>>()
+
+        var lastMergingPair: Pair<Vector, Vector> = ZERO to ZERO
+
+        distances.forEach { (boxes, _) ->
+            val containsFirst = circuits.find { it.contains(boxes.first) }
+            val containsSecond = circuits.find { it.contains(boxes.second) }
+
+            when {
+                containsFirst == null && containsSecond == null -> {
+                    circuits.add(mutableSetOf(boxes.first, boxes.second))
+                }
+
+                containsFirst == containsSecond -> {
+                    // already in same circuit -> do nothing
+                }
+
+                containsFirst != null && containsSecond != null -> {
+                    containsFirst.addAll(containsSecond)
+                    circuits.remove(containsSecond)
+                    lastMergingPair = boxes
+                }
+
+                else -> {
+                    containsFirst?.add(boxes.second)
+                    containsSecond?.add(boxes.first)
+                    lastMergingPair = boxes
+                }
+            }
+        }
+
+        return n?.let {
+            circuits
+                .map(MutableSet<Vector>::size)
+                .sorted()
+                .takeLast(3)
+                .reduce(Int::times)
+                .toLong()
+        }
+            ?: (lastMergingPair.first.x * lastMergingPair.second.x)
+    }
+}
+
+fun List<Vector>.pairwiseDistances(): List<BoxDistance> = symmetricalCombinations().map { boxes ->
+    val (a, b) = boxes
+    BoxDistance(boxes, a straightLineDistanceTo b)
+}.toList()
+
+data class BoxDistance(val boxes: Pair<Vector, Vector>, val distance: Double)

src/test/kotlin/de/ronny_h/aoc/year2025/day08/PlaygroundTest.kt

@@ -0,0 +1,74 @@
+package de.ronny_h.aoc.year2025.day08
+
+import de.ronny_h.aoc.extensions.asList
+import de.ronny_h.aoc.extensions.threedim.Vector
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.matchers.shouldBe
+
+class PlaygroundTest : StringSpec({
+
+    val input = """
+        162,817,812
+        57,618,57
+        906,360,560
+        592,479,940
+        352,342,300
+        466,668,158
+        542,29,236
+        431,825,988
+        739,650,466
+        52,470,668
+        216,146,977
+        819,987,18
+        117,168,530
+        805,96,715
+        346,949,466
+        970,615,88
+        941,993,340
+        862,61,35
+        984,92,344
+        425,690,689
+    """.asList()
+
+    "input can be parsed" {
+        """
+            162,817,812
+            57,618,57
+            906,360,560
+        """.asList()
+            .parseJunctionBoxes() shouldBe listOf(
+            Vector(162, 817, 812),
+            Vector(57, 618, 57),
+            Vector(906, 360, 560),
+        )
+    }
+
+    "pairwiseDistances" {
+        listOf(
+            Vector(0, 0, 0),
+            Vector(1, 0, 0),
+            Vector(2, 0, 0),
+        ).pairwiseDistances() shouldBe listOf(
+            BoxDistance(
+                Vector(0, 0, 0) to
+                        Vector(1, 0, 0), 1.0
+            ),
+            BoxDistance(
+                Vector(0, 0, 0) to
+                        Vector(2, 0, 0), 2.0
+            ),
+            BoxDistance(
+                Vector(1, 0, 0) to
+                        Vector(2, 0, 0), 1.0
+            ),
+        )
+    }
+
+    "part 1" {
+        JunctionBoxConnector(input).connectShortest(10) shouldBe 40
+    }
+
+    "part 2" {
+        Playground().part2(input) shouldBe 25272
+    }
+})