finish day18 and day 19

Author: EmRe-One

build.gradle.kts

@@ -50,8 +50,8 @@ dependencies {
     implementation(kotlin("reflect"))
 
     implementation("org.slf4j:slf4j-api:2.0.5")
-    implementation("ch.qos.logback:logback-classic:1.4.5")
-    implementation("ch.qos.logback:logback-core:1.4.5")
+    implementation("ch.qos.logback:logback-classic:1.4.12")
+    implementation("ch.qos.logback:logback-core:1.4.12")
     implementation("io.github.microutils:kotlin-logging-jvm:3.0.4")
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4")
     implementation("org.mariuszgromada.math:MathParser.org-mXparser:5.1.0")

src/main/kotlin/tr/emreone/adventofcode/days/Day18.kt

@@ -8,33 +8,20 @@ import tr.emreone.kotlin_utils.extensions.formatted
 import tr.emreone.kotlin_utils.math.*
 import java.util.LinkedList
 import kotlin.collections.forEach
+import kotlin.math.abs
 
 class Day18 : Day(18, 2023, "Lavaduct Lagoon") {
 
-/*
-    private val p2Instructions = input.map {
-        val (_, _, c) = it.split(' ')
-        val steps = c.drop(2).dropLast(2).toInt(16)
-        val dir = when (c.dropLast(1).last()) {
-            '0'  -> RIGHT
-            '1'  -> DOWN
-            '2'  -> LEFT
-            else -> UP
-        }
-        dir to steps
-    }
-*/
-
     override fun part1(): Int {
         val instructions = inputAsList.map {
             val (d, s, _) = it.split(' ')
-            val steps = s.toInt()
             val dir = when (d) {
-                "R"  -> Direction4.EAST
-                "D"  -> Direction4.SOUTH
-                "L"  -> Direction4.WEST
+                "R" -> Direction4.EAST
+                "D" -> Direction4.SOUTH
+                "L" -> Direction4.WEST
                 else -> Direction4.NORTH
             }
+            val steps = s.toInt()
             dir to steps
         }
 
@@ -66,7 +53,7 @@ class Day18 : Day(18, 2023, "Lavaduct Lagoon") {
         map.formatted(area = bigger) { x, c ->
             when {
                 x in seen -> "~"
-                else      -> "#"
+                else -> "#"
             }
         }
 
@@ -75,25 +62,45 @@ class Day18 : Day(18, 2023, "Lavaduct Lagoon") {
         return bigger.size - seen.size
     }
 
-/*
     override fun part2(): Long {
-        val boundary = p2Instructions.sumOf { it.second.toLong() }
-        val corners = p2Instructions.runningFold(origin) { acc, instruction ->
+        val instructions = inputAsList.map {
+            val (_, _, c) = it.split(' ')
+            // c is the color in braces in hex with 6 digits
+            // e.g. c = (#159ABC)
+            val dir = when (c.dropLast(1).last()) {
+                '0' -> Direction4.EAST
+                '1' -> Direction4.SOUTH
+                '2' -> Direction4.WEST
+                else -> Direction4.NORTH
+            }
+            val steps = c
+                .drop(2)        // remove (#
+                .dropLast(2)    // remove x)
+                .toInt(16)
+            dir to steps
+        }
+
+        val boundary = instructions.sumOf { it.second.toLong() }
+        val corners = instructions.runningFold(origin) { acc, instruction ->
             acc + (instruction.first * instruction.second)
         }
         require(corners.first() == corners.last()) { "not a closed loop" }
 
-        // area by Shoelace algorithm https://en.wikipedia.org/wiki/Shoelace_formula
+        // area by Shoelace algorithm
+        // https://en.wikipedia.org/wiki/Shoelace_formula
         // https://youtu.be/0KjG8Pg6LGk?si=qC_1iX1YhQlGvI1o
-        val area = abs(corners.zipWithNext().sumOf { (ci, cj) ->
-            ci.x.toLong() * cj.y - cj.x.toLong() * ci.y
-        }) / 2
+        val area = abs(
+            corners
+                .zipWithNext()
+                .sumOf { (ci, cj) ->
+                    ci.x.toLong() * cj.y - cj.x.toLong() * ci.y
+                }
+        ) / 2
 
         // according to Pick's theorem: A = i + b / 2 - 1
         // https://en.wikipedia.org/wiki/Pick%27s_theorem
         val inside = area - boundary / 2 + 1
         return inside + boundary
     }
-*/
 
 }

src/main/kotlin/tr/emreone/adventofcode/days/Day19.kt

@@ -2,101 +2,118 @@ package tr.emreone.adventofcode.days
 
 import tr.emreone.kotlin_utils.automation.Day
 import tr.emreone.kotlin_utils.automation.extractAllIntegers
-import tr.emreone.kotlin_utils.math.Coords
-import tr.emreone.kotlin_utils.math.Direction4
-import tr.emreone.kotlin_utils.math.plus
 
-class Day19 : Day(19, 2023, "Aplenty") {
+enum class Category(name: String) {
+    X("Extremely cool looking"),
+    M("Musical"),
+    A("Aerodynamic"),
+    S("Shiny")
+}
 
-    private val workflows = inputAsGroups[0].map {
-        val name = it.substringBefore('{')
-        val rules = it.substringAfter('{').dropLast(1).split(',').map { r ->
-            if (':' in r) {
-                val (c, n) = r.split(':')
-                val category = when (c[0]) {
-                    'x'  -> 0
-                    'm'  -> 1
-                    'a'  -> 2
-                    's'  -> 3
-                    else -> error(r)
-                }
-                when (c[1]) {
-                    '>'  -> Rule.GreaterThan(category, c.first { it.isDigit() }.digitToInt(), n)
-                    '<'  -> Rule.LessThan(category, c.first { it.isDigit() }.digitToInt(), n)
-                    else -> error(r)
-                }
-            }
-            else
-                Rule.Unconditional(r)
-        }
-        Workflow(name, rules)
-    }.associateBy { it.name }.show()
+typealias PotentialPart = Map<Category, IntRange>
 
-    private val parts = inputAsGroups[1].map { it.extractAllIntegers() }.show()
+fun PotentialPart.patch(category: Category, newRange: IntRange?): PotentialPart? {
+    return newRange?.let { patched ->
+        val parts = this.toMutableMap()
+        parts[category] = patched
 
-    data class Workflow(val name: String, val rules: List<Rule>)
+        parts.toMap()
+    }
+}
+
+class Day19 : Day(19, 2023, "Aplenty") {
 
     sealed interface Rule {
         val next: String
-        fun matches(part: List<Int>): Boolean
+        fun matches(part: Map<Category, Int>): Boolean
         fun split(parts: PotentialPart): Pair<PotentialPart?, PotentialPart?>
 
-        data class LessThan(val category: Int, val value: Int, override val next: String) : Rule {
-            override fun matches(part: List<Int>) = part[category] < value
+        data class LessThan(val category: Category, val value: Int, override val next: String) : Rule {
+            override fun matches(part: Map<Category, Int>) = part[category]!! < value
 
             override fun split(parts: PotentialPart): Pair<PotentialPart?, PotentialPart?> {
-                val relevant = parts[category]
+                val relevant = parts[category]!!
                 val (matching, notMatching) =
                     when {
-                        value in relevant     ->
+                        value in relevant ->
                             (relevant.first..<value) to (value..relevant.last)
 
                         value > relevant.last ->
                             relevant to null
 
-                        else                  -> null to null
+                        else -> null to null
                     }
                 return parts.patch(category, matching) to parts.patch(category, notMatching)
             }
         }
 
-        data class GreaterThan(val category: Int, val value: Int, override val next: String) : Rule {
-            override fun matches(part: List<Int>) = part[category] > value
+        data class GreaterThan(val category: Category, val value: Int, override val next: String) : Rule {
+            override fun matches(part: Map<Category, Int>) = part[category]!! > value
 
             override fun split(parts: PotentialPart): Pair<PotentialPart?, PotentialPart?> {
-                val relevant = parts[category]
+                val relevant = parts[category]!!
                 val (matching, notMatching) =
                     when {
-                        value in relevant      ->
+                        value in relevant ->
                             ((value + 1)..relevant.last) to (relevant.first..value)
 
                         value < relevant.first ->
                             relevant to null
 
-                        else                   -> null to null
+                        else -> null to null
                     }
                 return parts.patch(category, matching) to parts.patch(category, notMatching)
             }
         }
 
         data class Unconditional(override val next: String) : Rule {
-            override fun matches(part: List<Int>) = true
+            override fun matches(part: Map<Category, Int>) = true
 
             override fun split(parts: PotentialPart): Pair<PotentialPart?, PotentialPart?> =
                 parts to null
         }
+    }
+
+    data class Workflow(val name: String, val rules: List<Rule>)
 
-        fun List<IntRange>.patch(category: Int, newRange: IntRange?): List<IntRange>? =
-            newRange?.let { patched ->
-                mapIndexed { index, range ->
-                    patched.takeIf { index == category } ?: range
+    private val workflows = inputAsGroups[0]
+        .map {
+            val (name, ruleString) = it.split('{')
+            val rules = ruleString.dropLast(1)
+                .split(',')
+                .map { r ->
+                    if (':' in r) {
+                        val (c, next) = r.split(':')
+                        val category = when (c[0]) {
+                            'x' -> Category.X
+                            'm' -> Category.M
+                            'a' -> Category.A
+                            's' -> Category.S
+                            else -> error(r)
+                        }
+                        when (c[1]) {
+                            '>' -> Rule.GreaterThan(category, c.split('>')[1].toInt(), next)
+                            '<' -> Rule.LessThan(category, c.split('<')[1].toInt(), next)
+                            else -> error(r)
+                        }
+                    } else {
+                        Rule.Unconditional(r)
+                    }
                 }
-            }
-    }
 
-    override fun part1(): Int {
+            Workflow(name, rules)
+        }
+        .associateBy { it.name }
+        .show()
 
-        fun List<Int>.isAccepted(): Boolean {
+    private val partRatings = inputAsGroups[1]
+        .map {
+            Category.entries.zip(it.extractAllIntegers()).toMap()
+        }
+        .show()
+
+    override fun part1(): Int {
+        fun Map<Category, Int>.isAccepted(): Boolean {
             var wf = "in"
             while (true) {
                 if (wf == "R") return false
@@ -105,38 +122,37 @@ class Day19 : Day(19, 2023, "Aplenty") {
             }
         }
 
-        return parts.filter { it.isAccepted() }.sumOf { it.sum() }
+        return partRatings
+            .filter { it.isAccepted() }
+            .sumOf { it.values.sum() }
     }
 
     override fun part2(): Long {
-        val potentialPart = listOf(
-            1..4000,
-            1..4000,
-            1..4000,
-            1..4000,
+        val potentialParts = mapOf(
+            Category.X to 1..4000,
+            Category.M to 1..4000,
+            Category.A to 1..4000,
+            Category.S to 1..4000,
         )
 
         fun countAccepted(wf: Workflow, parts: PotentialPart?): Long =
             wf.rules.fold(parts to 0L) { (remaining, count), rule ->
                 if (remaining != null) {
                     val (matching, notMatching) = rule.split(remaining)
                     notMatching to count + when (rule.next) {
-                        "A"  -> matching?.combinations() ?: 0
-                        "R"  -> 0
+                        "A" -> matching?.combinations() ?: 0
+                        "R" -> 0
                         else -> countAccepted(workflows[rule.next]!!, matching)
                     }
-                }
-                else
+                } else
                     null to count
             }.second
 
-        return countAccepted(workflows["in"]!!, potentialPart)
+        return countAccepted(workflows["in"]!!, potentialParts)
     }
 
     private fun PotentialPart.combinations(): Long =
-        this.map { r -> r.last - r.first + 1L }
-            .reduce { acc, i -> acc * i }
-
+        this.values.fold(1) { acc, i ->
+            acc * (i.last - i.first + 1L)
+        }
 }
-
-typealias PotentialPart = List<IntRange>

src/test/kotlin/tr/emreone/adventofcode/days/Day18Test.kt

@@ -10,7 +10,7 @@ internal class Day18Test {
     fun `execute_tests`() {
         solve<Day18>(false) {
             Resources.resourceAsList("day18_example.txt")
-                .joinToString("\n") part1 62
+                .joinToString("\n") part1 62 part2 952_408_144_115L
         }
     }
 

src/test/kotlin/tr/emreone/adventofcode/days/Day19Test.kt

@@ -10,7 +10,7 @@ internal class Day19Test {
     fun `execute_tests`() {
         solve<Day19>(false) {
             Resources.resourceAsList("day19_example.txt")
-                .joinToString("\n") part1 0
+                .joinToString("\n") part1 19_114 part2 167_409_079_868_000L
         }
     }