Vastly improve d22 runtime

I keep doing this, don't I

Author: sschr15

src/main/kotlin/sschr15/aocsolutions/Day22.kt

@@ -1,15 +1,17 @@
 package sschr15.aocsolutions
 
 import sschr15.aocsolutions.util.*
+import java.util.concurrent.ConcurrentHashMap
 
 /**
  * AOC 2024 [Day 22](https://adventofcode.com/2024/day/22)
- * Challenge: 
+ * Challenge: There's a *very* competitive hide-and-seek game going on between a bunch of monkeys, so much so
+ * that the auction house is full of prospective hiders
  */
 object Day22 : Challenge {
     override fun solve() = challenge(2024, 22) {
 //        test()
-        
+
         val nums: List<Int>
         part1 {
             inputLines.ints().map {
@@ -23,28 +25,29 @@ object Day22 : Challenge {
             }.also { nums = it }.sumOf { it.toLong() }
         }
         part2 {
-            val buyers = inputLines.ints().map {
-                val outputs = sequence {
-                    var n = it
-                    repeat(2000) {
-                        n = n xor (n shl 6) and 0xffffff
-                        n = n xor (n ushr 5) and 0xffffff
-                        n = n xor (n shl 11) and 0xffffff
-                        yield(n)
-                    }
+            val counts = ConcurrentHashMap<List<Int>, Int>()
+
+            inputLines.ints().forEachParallel { it ->
+                val outputs = (0..2000).runningFold(it) { acc, _ ->
+                    var n = acc
+                    n = n xor (n shl 6) and 0xffffff
+                    n = n xor (n ushr 5) and 0xffffff
+                    n = n xor (n shl 11) and 0xffffff
+                    n
                 }
 
                 val prices = outputs.map { it % 10 }
                 val diffs = prices.windowed(2) { (a, b) -> b - a }
                 val windows = diffs.windowed(4)
-                val output = mutableMapOf<List<Int>, Int>()
-                prices.drop(4).zip(windows).forEach { (price, window) -> 
-                    if (window !in output) output[window] = price
+                val seen = mutableSetOf<List<Int>>()
+                for ((price, window) in prices.drop(4).zip(windows)) {
+                    if (seen.add(window)) {
+                        counts.merge(window, price, Int::plus)
+                    }
                 }
-                output
             }
 
-            buyers.flatMap { it.entries }.groupBy({ it.key }) { it.value }.maxOf { it.value.sum() }
+            counts.maxOf { it.value }.also { check(it == 2423) }
         }
     }
 

src/main/kotlin/sschr15/aocsolutions/util/IterableUtils.kt

@@ -4,12 +4,9 @@ package sschr15.aocsolutions.util
 
 import it.unimi.dsi.fastutil.objects.Object2IntMap
 import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.async
-import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.FlowCollector
-import kotlinx.coroutines.runBlocking
 import java.math.BigDecimal
 import java.math.BigInteger
 import java.util.*
@@ -134,6 +131,22 @@ inline fun <T, R> Iterable<T>.mapIndexedParallel(crossinline transform: suspend
     mapIndexed { index, t -> async(Dispatchers.Default) { transform(index, t) } }.awaitAll()
 }
 
+inline fun <T> Iterable<T>.forEachParallel(crossinline action: suspend (T) -> Unit) {
+    runBlocking {
+        withContext(Dispatchers.Default) { 
+            forEach { async { action(it) } }
+        }
+    }
+}
+
+inline fun <T> Iterable<T>.forEachIndexedParallel(crossinline action: suspend (Int, T) -> Unit) {
+    runBlocking {
+        withContext(Dispatchers.Default) {
+            forEachIndexed { index, t -> async { action(index, t) } }
+        }
+    }
+}
+
 inline fun <K, V> Iterable<Map<K, V>>.combineMaps(): Map<K, List<V>> {
     val result = mutableMapOf<K, MutableList<V>>()
     for (map in this) {

src/main/kotlin/sschr15/aocsolutions/util/SequenceUtils.kt

@@ -62,3 +62,44 @@ inline fun <T> Sequence<T>.noneIndexed(predicate: (Int, T) -> Boolean): Boolean
     }
     return true
 }
+
+class LimitedSequence<T>(
+    limit: Int,
+    private val first: T = NOT_INITIALIZED as T,
+    private val generateFirst: () -> T = { error("No generation passed") },
+    private val generateNext: (T) -> T
+) : Iterator<T> {
+    private var current = if (first === NOT_INITIALIZED) generateFirst() else first
+    private var left = limit
+
+    override fun hasNext(): Boolean {
+        return left > 0
+    }
+
+    override fun next(): T {
+        if (left-- <= 0) throw NoSuchElementException()
+        val result = current
+        current = generateNext(current)
+        return result
+    }
+
+    companion object {
+        private val NOT_INITIALIZED = Any()
+    }
+}
+
+fun <T> generateLimitedSequence(limit: Int, seed: T, generateNext: (T) -> T): Sequence<T> {
+    return object : Sequence<T> {
+        override fun iterator(): Iterator<T> {
+            return LimitedSequence(limit, seed, generateNext = generateNext)
+        }
+    }
+}
+
+fun <T> generateLimitedSequence(limit: Int, generateFirst: () -> T, generateNext: (T) -> T): Sequence<T> {
+    return object : Sequence<T> {
+        override fun iterator(): Iterator<T> {
+            return LimitedSequence(limit, generateFirst = generateFirst, generateNext = generateNext)
+        }
+    }
+}