Solution 2017-09 (Stream Processing)

Author: rhaendel

src/main/kotlin/de/ronny_h/aoc/year2017/day09/StreamProcessing.kt

@@ -0,0 +1,98 @@
+package de.ronny_h.aoc.year2017.day09
+
+import de.ronny_h.aoc.AdventOfCode
+import de.ronny_h.aoc.year2017.day09.State.*
+
+fun main() = StreamProcessing().run(16689, 7982)
+
+class StreamProcessing : AdventOfCode<Int>(2017, 9) {
+    override fun part1(input: List<String>): Int = input.single().parseGroups().score
+    override fun part2(input: List<String>): Int = input.single().parseGroups().garbage
+}
+
+enum class State {
+    Start, End, InGroup, InGarbage, Canceled
+}
+
+data class Groups(
+    val count: Int,
+    val score: Int,
+    val garbage: Int,
+)
+
+/*
+The state transitions are:
+                  --<-->            --!-->
+S --{--> in-group        in-garbage        canceled
+E <--}--          <-->--  |      |  <--*--
+                           -*^!>-
+
+in-group: { -> level++
+          } -> level--
+ */
+fun String.parseGroups(): Groups {
+    var state = Start
+    var nestingLevel = 0
+    var groupCount = 0
+    var score = 0
+    var garbage = 0
+
+    forEach { c ->
+        when (state) {
+            Start -> {
+                state = when (c) {
+                    '{' -> {
+                        nestingLevel++
+                        InGroup
+                    }
+
+                    else -> error("illegal character $c in state $state")
+                }
+            }
+
+            End -> error("illegal character $c in state $state")
+
+            InGroup -> {
+                state = when (c) {
+                    ',' -> InGroup
+                    '{' -> {
+                        nestingLevel++
+                        InGroup
+                    }
+
+                    '}' -> {
+                        score += nestingLevel
+                        nestingLevel--
+                        groupCount++
+                        if (nestingLevel > 0) {
+                            InGroup
+                        } else {
+                            End
+                        }
+                    }
+
+                    '<' -> InGarbage
+                    else -> error("illegal character $c in state $state")
+                }
+            }
+
+            InGarbage -> {
+                state = when (c) {
+                    '>' -> InGroup
+                    '!' -> Canceled
+                    else -> {
+                        garbage++
+                        InGarbage
+                    }
+                }
+            }
+
+            Canceled -> {
+                state = InGarbage
+            }
+        }
+    }
+    check(state == End) { "state should be End at the end, but was: $state" }
+    check(nestingLevel == 0) { "nesting level should be 0 at the end, but was: $nestingLevel" }
+    return Groups(groupCount, score, garbage)
+}

src/test/kotlin/de/ronny_h/aoc/year2017/day09/StreamProcessingTest.kt

@@ -0,0 +1,63 @@
+package de.ronny_h.aoc.year2017.day09
+
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.data.forAll
+import io.kotest.data.row
+import io.kotest.matchers.shouldBe
+
+class StreamProcessingTest : StringSpec({
+
+    "the number of groups" {
+        forAll(
+            row("{}", 1),
+            row("{{{}}}", 3),
+            row("{{},{}}", 3),
+            row("{{{},{},{{}}}}", 6),
+            row("{<{},{},{{}}>}", 1),
+            row("{<a>,<a>,<a>,<a>}", 1),
+            row("{{<a>},{<a>},{<a>},{<a>}}", 5),
+            row("{{<!>},{<!>},{<!>},{<a>}}", 2),
+        ) { input, numberOfGroups ->
+            input.parseGroups().count shouldBe numberOfGroups
+        }
+    }
+
+    "the total score for all groups in the input" {
+        forAll(
+            row("{}", 1),
+            row("{{{}}}", 6),
+            row("{{},{}}", 5),
+            row("{{{},{},{{}}}}", 16),
+            row("{<a>,<a>,<a>,<a>}", 1),
+            row("{{<ab>},{<ab>},{<ab>},{<ab>}}", 9),
+            row("{{<!!>},{<!!>},{<!!>},{<!!>}}", 9),
+            row("{{<a!>},{<a!>},{<a!>},{<ab>}}", 3),
+        ) { input, score ->
+            input.parseGroups().score shouldBe score
+        }
+    }
+
+    "the number of non-canceled characters within the garbage" {
+        forAll(
+            row("{<>}", 0),
+            row("{<random characters>}", 17),
+            row("{<<<<>}", 3),
+            row("{<{!>}>}", 2),
+            row("{<!!>}", 0),
+            row("{<!!!>>}", 0),
+            row("{<{o\"i!a,<{i<a>}", 10),
+        ) { input, garbage ->
+            input.parseGroups().garbage shouldBe garbage
+        }
+    }
+
+    "part 1: the total score for all groups in the input" {
+        val input = listOf("{{<ab>},{<ab>},{<ab>},{<ab>}}")
+        StreamProcessing().part1(input) shouldBe 9
+    }
+
+    "part 2: the number of non-canceled characters within the garbage" {
+        val input = listOf("{<{!>}>}")
+        StreamProcessing().part2(input) shouldBe 2
+    }
+})