Solution 2018-07 (The Sum of Its Parts)

Author: rhaendel

src/main/kotlin/de/ronny_h/aoc/year2018/day07/TheSumOfItsParts.kt

@@ -0,0 +1,85 @@
+package de.ronny_h.aoc.year2018.day07
+
+import de.ronny_h.aoc.AdventOfCode
+
+fun main() = TheSumOfItsParts().run("BKCJMSDVGHQRXFYZOAULPIEWTN", "1040")
+
+class TheSumOfItsParts : AdventOfCode<String>(2018, 7) {
+    override fun part1(input: List<String>): String = input
+        .createDependencyGraph()
+        .executeStepsInDependencyOrder()
+        .joinToString("")
+
+    override fun part2(input: List<String>): String = input
+        .createDependencyGraph()
+        .simulateSteps(5, 60)
+
+    companion object {
+        fun List<String>.createDependencyGraph(): MutableMap<String, MutableSet<String>> {
+            // build a graph using a map: step -> list of steps that must be finished before
+            val dependencyGraph = mutableMapOf<String, MutableSet<String>>()
+            parseSteps().forEach {
+                dependencyGraph.computeIfAbsent(it.second) { mutableSetOf() }.add(it.first)
+            }
+            return dependencyGraph
+        }
+
+        private fun Map<String, Set<String>>.executeStepsInDependencyOrder(): List<String> {
+            // Find the first steps that must have no other dependencies.
+            // ready steps = not done steps whose dependant steps are done
+            var readySteps = values.flatten().filterNot { it in keys }.toSet()
+            val stepsDone = mutableListOf<String>()
+            while (readySteps.isNotEmpty()) {
+                val step = readySteps.min()
+                stepsDone.add(step)
+                readySteps = (readySteps - step) + this
+                    .filter { it.key !in stepsDone }
+                    .filter { it.allDependenciesAreDone(stepsDone) }
+                    .keys
+            }
+            return stepsDone
+        }
+
+        fun Map<String, Set<String>>.simulateSteps(workers: Int, baseDurationSeconds: Int): String {
+            val stepsDone = mutableListOf<String>()
+            val readySteps = values.flatten().filterNot { it in keys }.toMutableSet()
+            var workersOccupied = 0
+            var completionSeconds = -1
+            var stepsInAction = listOf<StepInAction>()
+
+            while (readySteps.isNotEmpty() || stepsInAction.isNotEmpty()) {
+                completionSeconds++
+                stepsInAction.forEach { it.remainingDuration-- }
+                val (done, stillInAction) = stepsInAction.partition { it.remainingDuration == 0 }
+                stepsDone.addAll(done.map(StepInAction::name))
+
+                workersOccupied -= done.size
+
+                readySteps += this.filter { it.key !in (stepsDone + stepsInAction.map(StepInAction::name)) }
+                    .filter { it.allDependenciesAreDone(stepsDone) }
+                    .keys
+                val newSteps = readySteps.sorted().take(workers - workersOccupied).toSet()
+                workersOccupied += newSteps.size
+                stepsInAction = stillInAction + newSteps.map { StepInAction(it, it.duration(baseDurationSeconds)) }
+                readySteps -= newSteps
+            }
+            return "$completionSeconds"
+        }
+
+        private data class StepInAction(val name: String, var remainingDuration: Int)
+
+        private fun Map.Entry<String, Set<String>>.allDependenciesAreDone(stepsDone: List<String>): Boolean =
+            value.all { it in stepsDone }
+
+        // duration = baseDuration + letter's position in the alphabet
+        private fun String.duration(baseDurationSeconds: Int) = first().code - 'A'.code + baseDurationSeconds + 1
+    }
+}
+
+private val stepPattern = """Step ([A-Z]) must be finished before step ([A-Z]) can begin.""".toPattern()
+
+fun List<String>.parseSteps() = map {
+    val matcher = stepPattern.matcher(it)
+    require(matcher.matches())
+    matcher.group(1) to matcher.group(2)
+}

src/test/kotlin/de/ronny_h/aoc/year2018/day07/TheSumOfItsPartsTest.kt

@@ -0,0 +1,44 @@
+package de.ronny_h.aoc.year2018.day07
+
+import de.ronny_h.aoc.extensions.asList
+import de.ronny_h.aoc.year2018.day07.TheSumOfItsParts.Companion.createDependencyGraph
+import de.ronny_h.aoc.year2018.day07.TheSumOfItsParts.Companion.simulateSteps
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.matchers.shouldBe
+
+class TheSumOfItsPartsTest : StringSpec({
+
+    val input = """
+        Step C must be finished before step A can begin.
+        Step C must be finished before step F can begin.
+        Step A must be finished before step B can begin.
+        Step A must be finished before step D can begin.
+        Step B must be finished before step E can begin.
+        Step D must be finished before step E can begin.
+        Step F must be finished before step E can begin.
+    """.asList()
+
+    "Input can be parsed" {
+        input.parseSteps() shouldBe listOf(
+            "C" to "A",
+            "C" to "F",
+            "A" to "B",
+            "A" to "D",
+            "B" to "E",
+            "D" to "E",
+            "F" to "E",
+        )
+    }
+
+    "part 1: the order the steps in the instructions should be completed" {
+        TheSumOfItsParts().part1(input) shouldBe "CABDFE"
+    }
+
+    "simulate steps with two workers" {
+        input.createDependencyGraph().simulateSteps(2, 0) shouldBe "15"
+    }
+
+    "part 2: the number of seconds it takes with 5 workers" {
+        TheSumOfItsParts().part2(input) shouldBe "253"
+    }
+})