1 files changed, 59 insertions, 56 deletions

diff --git a/src/Day10.kt b/src/Day10.kt
index 8f73f2f..d6d026c 100644
--- a/src/Day10.kt
+++ b/src/Day10.kt
@@ -1,72 +1,74 @@
-enum class ChunkDelimiter(val open: Char, val close: Char) {
-    Parentheses('(', ')'),
-    Brackets('[', ']'),
-    Braces('{', '}'),
-    Angled('<', '>');
+object Day10 {
+    private enum class ChunkDelimiter(val open: Char, val close: Char) {
+        Parentheses('(', ')'),
+        Brackets('[', ']'),
+        Braces('{', '}'),
+        Angled('<', '>');
 
-    companion object {
-        fun isOpening(character: Char): Boolean = values().any { it.open == character }
-        fun isClosing(character: Char): Boolean = values().any { it.close == character }
-        fun from(character: Char): ChunkDelimiter = values().find { it.open == character || it.close == character }!!
+        companion object {
+            fun isOpening(character: Char): Boolean = values().any { it.open == character }
+            fun isClosing(character: Char): Boolean = values().any { it.close == character }
+            fun from(character: Char): ChunkDelimiter =
+                values().find { it.open == character || it.close == character }!!
+        }
     }
-}
 
-sealed class SyntaxError {
-    object None : SyntaxError()
-    class IncompleteLine(private val stack: ArrayDeque<ChunkDelimiter>) : SyntaxError() {
-        val score: Long
-            get() {
-                fun delimiterValue(delimiter: ChunkDelimiter): Int = when (delimiter) {
-                    ChunkDelimiter.Parentheses -> 1
-                    ChunkDelimiter.Brackets -> 2
-                    ChunkDelimiter.Braces -> 3
-                    ChunkDelimiter.Angled -> 4
+    private sealed class SyntaxError {
+        object None : SyntaxError()
+        class IncompleteLine(private val stack: ArrayDeque<ChunkDelimiter>) : SyntaxError() {
+            val score: Long
+                get() {
+                    fun delimiterValue(delimiter: ChunkDelimiter): Int = when (delimiter) {
+                        ChunkDelimiter.Parentheses -> 1
+                        ChunkDelimiter.Brackets -> 2
+                        ChunkDelimiter.Braces -> 3
+                        ChunkDelimiter.Angled -> 4
+                    }
+
+                    return stack.fold(0) { acc, elem -> acc * 5 + delimiterValue(elem) }
                 }
+        }
 
-                return stack.fold(0) { acc, elem -> acc * 5 + delimiterValue(elem) }
-            }
-    }
-    class CorruptedLine(private val invalidDelimiter: ChunkDelimiter) : SyntaxError() {
-        val score: Int
-            get() = when (invalidDelimiter) {
-                ChunkDelimiter.Parentheses -> 3
-                ChunkDelimiter.Brackets -> 57
-                ChunkDelimiter.Braces -> 1197
-                ChunkDelimiter.Angled -> 25137
-            }
+        class CorruptedLine(private val invalidDelimiter: ChunkDelimiter) : SyntaxError() {
+            val score: Int
+                get() = when (invalidDelimiter) {
+                    ChunkDelimiter.Parentheses -> 3
+                    ChunkDelimiter.Brackets -> 57
+                    ChunkDelimiter.Braces -> 1197
+                    ChunkDelimiter.Angled -> 25137
+                }
+        }
     }
-}
 
-fun parse(line: String): SyntaxError {
-    val stack = ArrayDeque<ChunkDelimiter>()
+    private fun parse(line: String): SyntaxError {
+        val stack = ArrayDeque<ChunkDelimiter>()
 
-    for (char in line) {
-        when {
-            ChunkDelimiter.isOpening(char) -> stack.addFirst(ChunkDelimiter.from(char))
-            ChunkDelimiter.isClosing(char) -> {
-                val closingDelimiter = ChunkDelimiter.from(char)
-                if (stack.first() == closingDelimiter) {
-                    stack.removeFirst()
-                } else {
-                    return SyntaxError.CorruptedLine(closingDelimiter)
+        for (char in line) {
+            when {
+                ChunkDelimiter.isOpening(char) -> stack.addFirst(ChunkDelimiter.from(char))
+                ChunkDelimiter.isClosing(char) -> {
+                    val closingDelimiter = ChunkDelimiter.from(char)
+                    if (stack.first() == closingDelimiter) {
+                        stack.removeFirst()
+                    } else {
+                        return SyntaxError.CorruptedLine(closingDelimiter)
+                    }
                 }
             }
         }
-    }
 
-    if (stack.isNotEmpty()) {
-        return SyntaxError.IncompleteLine(stack)
-    }
+        if (stack.isNotEmpty()) {
+            return SyntaxError.IncompleteLine(stack)
+        }
 
-    return SyntaxError.None
-}
+        return SyntaxError.None
+    }
 
-fun main() {
     fun part1(input: List<String>): Int = input
         .map { parse(it) }
         .filterIsInstance<SyntaxError.CorruptedLine>()
         .sumOf { it.score }
-    
+
     fun part2(input: List<String>): Long =
         input
             .asSequence()
@@ -76,13 +78,14 @@ fun main() {
             .sorted()
             .toList()
             .let { it[it.size / 2] }
+}
 
-
+fun main() {
     val testInput = readInputAsLines("Day10_test")
-    check(part1(testInput) == 26397)
-    check(part2(testInput) == 288957L)
+    check(Day10.part1(testInput) == 26397)
+    check(Day10.part2(testInput) == 288957L)
 
     val input = readInputAsLines("Day10")
-    println(part1(input))
-    println(part2(input))
+    println(Day10.part1(input))
+    println(Day10.part2(input))
 }