Add solution for Y2024D11.

Author: Jadarma

Diff for: README.md

@@ -15,7 +15,7 @@ _"Anything that's worth doing, is worth overdoing."_
 Table of contents to jump straight to the problem you're looking for.
 
 <details open>
-    <summary>2024 (20x⭐)</summary>
+    <summary>2024 (22x⭐)</summary>
 
 | Day | Title                                                      | Stars |
 |:---:|:-----------------------------------------------------------|:-----:|
@@ -29,6 +29,7 @@ Table of contents to jump straight to the problem you're looking for.
 | 08  | [Resonant Collinearity](solutions/aockt/y2024/Y2024D08.kt) |  ⭐⭐   |
 | 09  | [Disk Fragmenter](solutions/aockt/y2024/Y2024D09.kt)       |  ⭐⭐   |
 | 10  | [Hoof It](solutions/aockt/y2024/Y2024D10.kt)               |  ⭐⭐   |
+| 11  | [Plutonian Pebbles](solutions/aockt/y2024/Y2024D11.kt)     |  ⭐⭐   |
 
 </details>
 

Diff for: inputs/aockt/y2024/d11/input.txt

@@ -0,0 +1,48 @@
+package aockt.y2024
+
+import aockt.util.parse
+import aockt.y2024.Y2024D11.Stone
+import io.github.jadarma.aockt.core.Solution
+import kotlin.math.floor
+import kotlin.math.log10
+import kotlin.math.pow
+
+object Y2024D11 : Solution {
+
+    /** A strange stone from Pluto, wih a [number] engraved on it. */
+    @JvmInline
+    private value class Stone(val number: Long) {
+
+        /** Returns the stone(s) that will appear after this one is blinked at. */
+        fun blink(): List<Stone> = buildList {
+            if (number == 0L) { add(Stone(1L)); return@buildList }
+
+            val digitCount = floor(log10(number.toDouble())).toInt() + 1
+            if (digitCount % 2 == 1) { add(Stone(number * 2024L)); return@buildList }
+
+            val split = 10.0.pow(digitCount / 2).toLong()
+            add(Stone(number / split))
+            add(Stone(number % split))
+        }
+    }
+
+    /** Calculates how many stones will appear after a number of [blinks] from the starting [stones]. */
+    private fun solve(stones: List<Stone>, blinks: Int): Long {
+        val cache = mutableMapOf<Pair<Stone, Int>, Long>()
+
+        fun recurse(stone: Stone, times: Int): Long = when (times) {
+            0 -> 1
+            else -> cache.getOrPut(stone to times) {
+                stone.blink().sumOf { recurse(it, times - 1) }
+            }
+        }
+
+        return stones.sumOf { stone -> recurse(stone, blinks) }
+    }
+
+    /** Parse the [input] and return the initial rows of [Stone]s. */
+    private fun parseInput(input: String): List<Stone> = parse { input.split(' ').map { Stone(it.toLong()) } }
+
+    override fun partOne(input: String): Long = solve(stones = parseInput(input), blinks = 25)
+    override fun partTwo(input: String): Long = solve(stones = parseInput(input), blinks = 75)
+}

Diff for: inputs/aockt/y2024/d11/solution_part1.txt

@@ -0,0 +1,11 @@
+package aockt.y2024
+
+import io.github.jadarma.aockt.test.AdventDay
+import io.github.jadarma.aockt.test.AdventSpec
+
+@AdventDay(2024, 11, "Plutonian Pebbles")
+class Y2024D11Test : AdventSpec<Y2024D11>({
+    val exampleInput = "125 17"
+    partOne { exampleInput shouldOutput 55_312 }
+    partTwo { exampleInput shouldOutput 65_601_038_650_482 }
+})