Solution 2025-05 (Cafeteria)

Author: rhaendel

src/main/kotlin/de/ronny_h/aoc/year2025/day05/Cafeteria.kt

@@ -0,0 +1,74 @@
+package de.ronny_h.aoc.year2025.day05
+
+import de.ronny_h.aoc.AdventOfCode
+import de.ronny_h.aoc.extensions.collections.split
+
+fun main() = Cafeteria().run(885, 348115621205535)
+
+class Cafeteria : AdventOfCode<Long>(2025, 5) {
+    override fun part1(input: List<String>): Long {
+        with(input.parseIngredients()) {
+            return available.count { it.isFresh(freshRanges) }.toLong()
+        }
+    }
+
+    override fun part2(input: List<String>): Long =
+        input.parseIngredients()
+            .freshRanges
+            .sortedBy { it.first }
+            .fold(mutableListOf<LongRange>()) { compactRanges, range ->
+                compactRanges.mergeRange(range)
+            }.sumOf {
+                it.last - it.first + 1
+            }
+}
+
+data class Ingredients(val freshRanges: List<LongRange>, val available: List<Long>)
+
+// invariant: ranges in this MutableList are non-overlapping and sorted
+// pre-condition: add operations only occur with ranges sorted by their first value
+fun MutableList<LongRange>.mergeRange(toAdd: LongRange): MutableList<LongRange> {
+    if (none { toAdd.first in it || toAdd.last in it }) {
+        // disjunct -> just add it
+        add(toAdd)
+        return this
+    }
+    for ((i, range) in withIndex()) {
+        if (toAdd.first in range && toAdd.last in range) {
+            // toAdd is completely contained in this range
+            return this
+        }
+        if (toAdd.first !in range && toAdd.last !in range) {
+            continue
+        }
+
+        val lastOverlappingRangeIndex = indexOfLast { toAdd.last in it }
+        if (toAdd.first in range && lastOverlappingRangeIndex == -1) {
+            // the beginning overlaps with this range -> merge
+            this[i] = range.first..toAdd.last
+            return this
+        }
+
+        // overlaps with several ranges -> squash them
+        val lastOverlappingRange = this[lastOverlappingRangeIndex]
+        for (index in lastOverlappingRangeIndex downTo i + 1) {
+            this.removeAt(index)
+        }
+        this[i] = range.first..lastOverlappingRange.last
+        return this
+    }
+    error("If this line is reached, a case is missing")
+}
+
+fun Long.isFresh(freshRanges: List<LongRange>): Boolean = freshRanges.any { this in it }
+
+fun List<String>.parseIngredients(): Ingredients {
+    val (fresh, available) = split()
+    return Ingredients(
+        fresh.map {
+            val (from, to) = it.split("-").map(String::toLong)
+            from..to
+        },
+        available.map { it.toLong() }
+    )
+}

src/test/kotlin/de/ronny_h/aoc/year2025/day05/CafeteriaTest.kt

@@ -0,0 +1,57 @@
+package de.ronny_h.aoc.year2025.day05
+
+import de.ronny_h.aoc.extensions.asList
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.data.forAll
+import io.kotest.data.row
+import io.kotest.matchers.shouldBe
+
+class CafeteriaTest : StringSpec({
+
+    val input = """
+        3-5
+        10-14
+        16-20
+        12-18
+
+        1
+        5
+        8
+        11
+        17
+        32
+    """.asList()
+
+    "input can be parsed" {
+        val input = """
+        3-5
+        10-14
+
+        1
+        5
+        11
+    """.asList()
+        input.parseIngredients() shouldBe Ingredients(listOf(3L..5L, 10L..14L), listOf(1L, 5L, 11L))
+    }
+
+    "mergeRange merges the added range with the existing ones" {
+        forAll(
+            row(mutableListOf(2L..5L), 3L..4L, listOf(2L..5L)),
+            row(mutableListOf(2L..5L), 6L..7L, listOf(2L..5L, 6L..7L)),
+            row(mutableListOf(2L..5L, 8L..9L), 4L..6L, listOf(2L..6L, 8L..9L)),
+            row(mutableListOf(2L..5L, 8L..9L), 4L..8L, listOf(2L..9L)),
+            row(mutableListOf(2L..5L, 8L..9L, 11L..13L), 4L..11L, listOf(2L..13L)),
+            row(mutableListOf(0L..1L, 4L..5L, 8L..9L, 11L..13L, 15L..20L), 4L..11L, listOf(0L..1L, 4L..13L, 15L..20L)),
+        ) { list, range, expected ->
+            list.mergeRange(range) shouldBe expected
+        }
+    }
+
+    "part 1: the number of available ingredient IDs that are fresh" {
+        Cafeteria().part1(input) shouldBe 3
+    }
+
+    "part 2: the total number of ingredient IDs considered to be fresh " {
+        Cafeteria().part2(input) shouldBe 14
+    }
+})