day(10): reformat and refactor

Signed-off-by: Matej Focko <mfocko@redhat.com>

src/year2021/day10/Day10.kt

@@ -3,62 +3,47 @@ package year2021.day10
 import readInput
 
 val CLOSING: Map<Char, Char> = mapOf(
-    ')' to '(',
-    ']' to '[',
-    '}' to '{',
-    '>' to '<'
+    ')' to '(', ']' to '[', '}' to '{', '>' to '<'
+)
+val ERROR_SCORING: Map<Char, Int> = mapOf(
+    ')' to 3, ']' to 57, '}' to 1197, '>' to 25137
 )
-val ERROR_SCORING: Map<Char, Int> = mapOf(')' to 3, ']' to 57, '}' to 1197, '>' to 25137)
 val AUTOCOMPLETE_SCORING: Map<Char, Long> = mapOf(
-    '(' to 1,
-    '[' to 2,
-    '{' to 3,
-    '<' to 4
+    '(' to 1, '[' to 2, '{' to 3, '<' to 4
 )
 
-fun firstInvalid(input: String): Char? {
+fun check(input: String): Pair<Char?, List<Char>> {
     val stack = mutableListOf<Char>()
 
     for (c in input) {
         if (CLOSING.contains(c)) {
             // found a closing one
             if (stack.size < 1 || stack.last() != CLOSING[c]) {
-                return c
+                return Pair(c, stack)
             }
             stack.removeLast()
         } else {
             stack.add(c)
         }
     }
-    return null
+    return Pair(null, stack)
 }
 
 fun part1(input: List<String>): Int = input.sumOf {
-    firstInvalid(it)?.let { c ->
-        ERROR_SCORING[c]
-    } ?: 0
-}
-
-fun getRemaining(input: String): List<Char> {
-    val stack = mutableListOf<Char>()
-
-    for (c in input) {
-        if (CLOSING.contains(c)) {
-            stack.removeLast()
-        } else {
-            stack.add(c)
+    check(it).let { (c, _) ->
+        ERROR_SCORING.getOrDefault(c, 0)
     }
 }
 
-    return stack
+fun part2(input: List<String>): Long =
+    input
+        .map { check(it) }
+        .filter { (c, s) -> c == null && s.isNotEmpty() }
+        .map { (_, stack) ->
+            stack.reversed().fold(0.toLong()) { total, c ->
+                5 * total + AUTOCOMPLETE_SCORING[c]!!
             }
-
-fun part2(input: List<String>): Long = input
-    .filter { firstInvalid(it) == null }
-    .map {
-        getRemaining(it).reversed().fold(0.toLong()) { total, c -> 5 * total + AUTOCOMPLETE_SCORING[c]!! }
-    }
-    .sorted().let { scores ->
+        }.sorted().let { scores ->
             scores[scores.size / 2]
         }