Day 11

Author: WVerlaek

src/main/kotlin/common/ext/Number.kt

@@ -1,5 +1,8 @@
 package common.ext
 
+import kotlin.math.floor
+import kotlin.math.log10
+
 fun Boolean.toInt() = if (this) 1 else 0
 
 fun List<Int>.product() = fold(1) { a, b -> a * b }
@@ -26,3 +29,8 @@ inline fun <T> Iterable<T>.productOf(selector: (T) -> Long): Long {
 }
 
 fun Int.divideRoundUp(divideBy: Int) = (this + divideBy - 1) / divideBy
+
+fun Long.numDigits(): Int {
+    if (this == 0L) return 1
+    return log10(this.toDouble()).toInt() + 1
+}

src/main/kotlin/y24/Day11.kt

@@ -0,0 +1,70 @@
+package y24
+
+import common.puzzle.solvePuzzle
+import common.puzzle.Input
+import common.puzzle.Puzzle
+import common.datastructures.*
+import common.ext.*
+import common.puzzle.splitToLongs
+import common.util.*
+import java.util.*
+import kotlin.math.*
+import kotlin.system.exitProcess
+
+
+fun main() = solvePuzzle(year = 2024, day = 11, dryRun = false) { Day11(it) }
+
+class Day11(val input: Input) : Puzzle {
+
+    data class Stone(
+        val stone: Long,
+        val amount: Long,
+    )
+
+    private fun blinkOnce(stone: Long): List<Long> {
+        if (stone == 0L) {
+            return listOf(1L)
+        }
+        val digits = stone.numDigits()
+        if (digits % 2 == 0) {
+            // Split
+            val str = stone.toString()
+            val left = str.substring(0, digits / 2).toLong()
+            val right = str.substring(digits / 2).toLong()
+            return listOf(left, right)
+        }
+
+        return listOf(stone * 2024)
+    }
+
+    private fun blinkStones(stones: List<Stone>, n: Int): List<Stone> {
+        if (n == 0) return stones
+
+        val newStones = mutableListOf<Stone>()
+        stones.forEach { stone ->
+            val blinked = blinkOnce(stone.stone)
+            blinked.map { Stone(it, stone.amount) }.forEach { newStones += it }
+        }
+
+        // Merge newStones
+        val grouped = newStones
+            .groupBy { it.stone }
+            .map { (stone, group) ->
+                Stone(stone, group.sumOf { it.amount })
+            }
+
+        return blinkStones(grouped, n - 1)
+    }
+
+    private val inputStones = input.lines[0]
+        .splitToLongs(" ")
+        .map { Stone(it, 1L) }
+
+    override fun solveLevel1(): Any {
+        return blinkStones(inputStones, 25).sumOf { it.amount }
+    }
+
+    override fun solveLevel2(): Any {
+        return blinkStones(inputStones, 75).sumOf { it.amount }
+    }
+}

src/test/kotlin/common/ext/NumberTest.kt

@@ -0,0 +1,17 @@
+package common.ext
+
+import org.junit.jupiter.api.Test
+
+import org.junit.jupiter.api.Assertions.*
+
+internal class NumberTest {
+    @Test
+    fun numDigits() {
+        assertEquals(1, 0.numDigits())
+        assertEquals(1, 1.numDigits())
+        assertEquals(1, 9.numDigits())
+        assertEquals(2, 10.numDigits())
+        assertEquals(2, 99.numDigits())
+        assertEquals(3, 100.numDigits())
+    }
+}

src/test/kotlin/y24/Day11Test.kt

@@ -0,0 +1,23 @@
+package y24
+
+import common.puzzle.Input
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+internal class Day11Test {
+    private val sample = Input("""
+    125 17
+    """.trimIndent())
+
+    private val day = Day11(sample)
+
+    @Test
+    fun solveLevel1() {
+        assertEquals(55312L, day.solveLevel1())
+    }
+
+    @Test
+    fun solveLevel2() {
+        // No sample
+    }
+}