day 10, part 2 solution

Author: mlcohen

day10/src/main/kotlin/org/adventofcode/App.kt

@@ -6,33 +6,43 @@ data class Token(val char: Char, val pos: Int)
 
 sealed class EvaluationResult {
     data class Valid(val _blank: Boolean = true): EvaluationResult()
-    data class Corrupt(val token: Token): EvaluationResult()
-    data class Incomplete(val token: Token): EvaluationResult()
+    data class Corrupt(val token: Token, val stack: List<Token>): EvaluationResult()
+    data class Incomplete(val token: Token, val stack: List<Token>): EvaluationResult()
     data class Invalid(val token: Token): EvaluationResult()
 }
 
+data class RepairResult(val completion: String)
+
 val LEFT_BRACKET_SET = "([<{".toSet()
 val RIGHT_BRACKET_SET = ")]>}".toSet()
-val RIGHT_BRACKET_PAIRING = mapOf(
-    ')' to '(',
-    ']' to '[',
-    '}' to '{',
-    '>' to '<',
+val BRACKET_PAIRINGS = listOf(
+    '(' to ')',
+    '[' to ']',
+    '{' to '}',
+    '<' to '>',
 )
-val BRACKET_POINTS = mapOf(
+val LEFT_TO_RIGHT_BRACKET_MAP = BRACKET_PAIRINGS.toMap()
+val RIGHT_TO_LEFT_BRACKET_MAP = BRACKET_PAIRINGS.associate { it.second to it.first }
+val EVAL_BRACKET_POINTS = mapOf(
     ')' to 3,
     ']' to 57,
     '}' to 1197,
     '>' to 25137,
 )
+val REPAIR_BRACKET_POINTS = mapOf(
+    ')' to 1,
+    ']' to 2,
+    '}' to 3,
+    '>' to 4,
+)
 
 object ExpressionEvaluator {
     fun evaluateNextToken(pos: Int, tokens: List<Token>, stack: List<Token>): EvaluationResult {
         if (pos == tokens.size) {
             val token = stack.last()
             return when (token.char) {
-                in LEFT_BRACKET_SET -> EvaluationResult.Incomplete(token)
-                in RIGHT_BRACKET_SET -> EvaluationResult.Corrupt(tokens[pos - 1])
+                in LEFT_BRACKET_SET -> EvaluationResult.Incomplete(token, stack)
+                in RIGHT_BRACKET_SET -> EvaluationResult.Corrupt(tokens[pos - 1], stack)
                 else -> EvaluationResult.Valid()
             }
         }
@@ -44,8 +54,8 @@ object ExpressionEvaluator {
             }
             in RIGHT_BRACKET_SET -> {
                 val peek = stack.lastOrNull()
-                if (peek?.char != RIGHT_BRACKET_PAIRING[token.char]) {
-                    EvaluationResult.Corrupt(token)
+                if (peek?.char != RIGHT_TO_LEFT_BRACKET_MAP[token.char]) {
+                    EvaluationResult.Corrupt(token, stack)
                 } else {
                     evaluateNextToken(pos + 1, tokens, stack.dropLast(1))
                 }
@@ -62,6 +72,18 @@ object ExpressionEvaluator {
     }
 }
 
+object IncompleteExpressionRepairer {
+    fun buildCompletionString(stack: List<Token>, expr: String = ""): String {
+        if (stack.isEmpty()) {
+            return expr;
+        }
+
+        val token = stack.last()
+        val currentExpr = expr + LEFT_TO_RIGHT_BRACKET_MAP[token.char]
+        return buildCompletionString(stack.dropLast(1), currentExpr)
+    }
+}
+
 fun runSolutionPart1(expressions: List<String>) {
     val evaluations = expressions.map { it to ExpressionEvaluator.evaluate(it) }
 
@@ -75,12 +97,44 @@ fun runSolutionPart1(expressions: List<String>) {
         .groupingBy { it.token.char }
         .eachCount()
         .toList()
-        .sumOf { (char, count) -> count * BRACKET_POINTS[char]!! }
+        .sumOf { (char, count) -> count * EVAL_BRACKET_POINTS[char]!! }
 
     println("\nPoints = $points")
 }
 
+fun runSolutionPart2(expressions: List<String>) {
+    val evaluations = expressions.map { it to ExpressionEvaluator.evaluate(it) }
+
+    val repairs = evaluations
+        .filter { (_, result) -> result is EvaluationResult.Incomplete }
+        .map { (expr, result) ->
+            val stack = (result as EvaluationResult.Incomplete).stack
+            expr to IncompleteExpressionRepairer.buildCompletionString(stack)
+        }
+
+    val sumPointsForRepair: (String) -> Long = { repair: String ->
+        repair.toList().fold(0L) { points, bracket ->
+            (points * 5) + REPAIR_BRACKET_POINTS[bracket]!!
+        }
+    }
+
+    println()
+
+    val scoredRepairs = repairs
+        .map { (expr, repair) -> repair to sumPointsForRepair(repair) }
+        .sortedBy { (_, points) -> points }
+
+    scoredRepairs.forEach { (repair, points) ->
+        println("repair $repair: points = $points")
+    }
+
+    val middleScoredReport = scoredRepairs[scoredRepairs.size / 2]
+
+    println("\nMiddle: $middleScoredReport")
+}
+
 fun main() {
     val expressions = File("day10/src/main/resources/puzzleInput.txt").readLines()
-    runSolutionPart1(expressions)
+//    runSolutionPart1(expressions)
+    runSolutionPart2(expressions)
 }