2022/Day 10

Author: agrison

README.md

@@ -46,6 +46,10 @@
 🎄 ---- Day 10: Cathode-Ray Tube ---
  🌟 Part 1: 12980 (12.51ms)
  🌟 Part 2: BRJLFULP (8.1us)
+ 
+🎄 ---- Day 11: Monkey in the Middle ---
+ 🌟 Part 1: 76728 (30.8ms)
+ 🌟 Part 2: 21553910156 (100.1ms) 
 ```
 
 ## Visualizations

src/main/kotlin/me/grison/aoc/Strings.kt

@@ -1,5 +1,6 @@
 package me.grison.aoc
 
+import java.math.BigInteger
 import java.util.*
 
 /** Returns the occurrences of `c`. */
@@ -80,6 +81,9 @@ fun String.allPositiveInts(): List<Int> = this.allInts(false)
 fun String.allLongs(includeNegative: Boolean = true): List<Long> =
  (if (includeNegative) "(-?\\d+)" else "(\\d+)").regex().findAll(this).map { it.value.toLong() }.toList()
 
+fun String.allBigIntegers(includeNegative: Boolean = true): List<BigInteger> =
+ (if (includeNegative) "(-?\\d+)" else "(\\d+)").regex().findAll(this).map { it.value.toBigInteger() }.toList()
+
 fun String.firstInt(includeNegative: Boolean = true) = allInts(includeNegative).first()
 fun String.lastInt(includeNegative: Boolean = true) = allInts(includeNegative).last()
 

src/main/kotlin/me/grison/aoc/y2022/Day11.kt

@@ -0,0 +1,71 @@
+package me.grison.aoc.y2022
+
+import me.grison.aoc.*
+import java.math.BigInteger.ONE
+
+class Monkey(
+ var id: Int,
+ var items: MutableList<Long>,
+ var operation: (Long) -> Long,
+ var divisible: Long,
+ var destinations: Pair<Int, Int>
+)
+
+class Day11 : Day(11, 2022) {
+ override fun title() = "Monkey in the Middle"
+
+ override fun partOne() = solve(20, parseMonkeys()) { level -> level / 3L }
+
+ override fun partTwo() = parseMonkeys().let { monkeys ->
+ val lcm = lcm(monkeys)
+ solve(10_000, monkeys) { level -> level % lcm }
+ }
+
+ private fun parseMonkeys(): List<Monkey> {
+ val monkeys = mutableListOf<Monkey>()
+
+ inputGroups.forEach { monkey ->
+ val (id, items, operation, divisible, ok, nok) = monkey.lines()
+ val after = operation.after(": ").words()
+ val (op, operand) = p(after[3], after[4])
+ monkeys.add(
+ Monkey(
+ id.firstInt(),
+ items.allLongs().toMutableList(),
+ { i ->
+ when (operand.isDigits()) {
+ false -> if (op == "+") i + i else i * i
+ true -> if (op == "+") i + operand.toLong() else i * operand.toLong()
+ }
+ },
+ divisible.allLongs().first(),
+ p(ok.firstInt(), nok.firstInt())
+ )
+ )
+ }
+
+ return monkeys
+ }
+
+ private fun lcm(monkeys: List<Monkey>) =
+ monkeys.map { it.divisible.toBigInteger() }.fold(ONE) { acc, i -> (acc * i) / acc.gcd(i) }.toLong()
+
+ private fun solve(rounds: Int, monkeys: List<Monkey>, newLevel: (Long) -> Long): Long {
+ val monkeyBusiness = mutableList(monkeys.size, 0L)
+ repeat(rounds) {
+ monkeys.forEach { monkey ->
+ monkey.items.forEach { item ->
+ monkeyBusiness[monkey.id] += 1L
+ val level = newLevel(monkey.operation(item))
+ val destination =
+ if (level % monkey.divisible == 0L) monkey.destinations.first
+ else monkey.destinations.second
+ monkeys[destination].items.add(level)
+ }
+ monkey.items.clear()
+ }
+ }
+
+ return monkeyBusiness.sorted().takeLast(2).product()
+ }
+}

src/main/resources/2022/11.txt

@@ -0,0 +1,55 @@
+Monkey 0:
+ Starting items: 61
+ Operation: new = old * 11
+ Test: divisible by 5
+ If true: throw to monkey 7
+ If false: throw to monkey 4
+
+Monkey 1:
+ Starting items: 76, 92, 53, 93, 79, 86, 81
+ Operation: new = old + 4
+ Test: divisible by 2
+ If true: throw to monkey 2
+ If false: throw to monkey 6
+
+Monkey 2:
+ Starting items: 91, 99
+ Operation: new = old * 19
+ Test: divisible by 13
+ If true: throw to monkey 5
+ If false: throw to monkey 0
+
+Monkey 3:
+ Starting items: 58, 67, 66
+ Operation: new = old * old
+ Test: divisible by 7
+ If true: throw to monkey 6
+ If false: throw to monkey 1
+
+Monkey 4:
+ Starting items: 94, 54, 62, 73
+ Operation: new = old + 1
+ Test: divisible by 19
+ If true: throw to monkey 3
+ If false: throw to monkey 7
+
+Monkey 5:
+ Starting items: 59, 95, 51, 58, 58
+ Operation: new = old + 3
+ Test: divisible by 11
+ If true: throw to monkey 0
+ If false: throw to monkey 4
+
+Monkey 6:
+ Starting items: 87, 69, 92, 56, 91, 93, 88, 73
+ Operation: new = old + 8
+ Test: divisible by 3
+ If true: throw to monkey 5
+ If false: throw to monkey 2
+
+Monkey 7:
+ Starting items: 71, 57, 86, 67, 96, 95
+ Operation: new = old + 7
+ Test: divisible by 17
+ If true: throw to monkey 3
+ If false: throw to monkey 1

src/test/kotlin/me/grison/aoc/y2022/AllDaysTest.kt

@@ -21,6 +21,7 @@ class AllDaysTest {
  Answer({ Day08() }, 1763, 671160),
  Answer({ Day09() }, 6026, 2273),
  Answer({ Day10() }, 12980, "BRJLFULP"),
+ Answer({ Day11() }, 76728, 21553910156),
  ).map {
  val day = it.inst.invoke()
  DynamicTest.dynamicTest("Day ${day.year}/${day.dayNumber} - Part 1 - expecting ${it.part1}") {