Going great for me...

    monkeys = []
    @dataclass
    class Monkey:
        items : List[int] = dataclass_field(default_factory=list)
        operation = None
        test = 0
        test_true = 0
        test_false= 0
        inspected = 0

    def consume(s, prefix):
        assert s.startswith(prefix)
        return s[len(prefix):]

    for s in data:
        op, args = s.split(':')
        # print(f'{op!r}: {args!r}')
        if op.startswith('Monkey'):
            assert not args
            _, arg = op.split()
            assert int(arg) == len(monkeys)
            monke = Monkey()
            monkeys.append(monke)
        elif op == 'Starting items':
            monke.items = [int(s.strip()) for s in args.split(',')]
        elif op == 'Operation':
            args = consume(args, ' new = old ')
            op = args[0]
            assert op in '*+'
            arg = args[1:].strip()
            if arg != 'old':
                arg = int(arg)
            if op == '+':
                monke.operation = lambda x, arg=arg: x + (x if arg == 'old' else arg)
            else:
                monke.operation = lambda x, arg=arg: x * (x if arg == 'old' else arg)
        elif op == 'Test':
            args = consume(args, ' divisible by ')
            monke.test = int(args)
        elif op == 'If true':
            args = consume(args, ' throw to monkey ')
            monke.test_true = int(args)
        elif op == 'If false':
            args = consume(args, ' throw to monkey ')
            monke.test_false = int(args)
        else:
            assert False

    # pprint(monkeys)

    modulo = functools.reduce(operator.mul, [m.test for m in monkeys], 1)

    for round in range(10_000 if second else 20):
        for i, m in enumerate(monkeys):
            # print(f'Monke {i}')
            items = m.items
            m.items = []
            for it in items:
                m.inspected += 1
                # print(f'inspect {it}')
                it = m.operation(it)
                # print(f'worry to {it}')
                if not second:
                    it //= 3
                it %= modulo
                # print(f'worry to {it}')
                target = m.test_false if it % m.test else m.test_true
                # print(f'target {target}')
                monkeys[target].items.append(it)
        # pprint(monkeys)

    top = [-m.inspected for m in monkeys]
    heapify(top)
    a, b = heappop(top), heappop(top)
    return a * b

Did anyone get it to loop through state space correctly? I tried for a few hours but couldn't get it

Not that bad today. Took me an embarrassingly long time to realize I needed to reduce worry levels on part 2 though

That second half took me longer than I would've liked... I understood the problem but I was trying to do crazy stuff with prime factors which were way off-track. Also hard-coded the inputs because fuck that noise.

monke = [[85, 77, 77], [80, 99], [74, 60, 74, 63, 86, 92, 80], [71, 58, 93, 65, 80, 68, 54, 71], [97, 56, 79, 65, 58], [77], [99, 90, 84, 50], [50, 66, 61, 92, 64, 78]]
count = [0,0,0,0,0,0,0,0]

def take_turn(i, n):
    div_check = [[19, 6, 7], [3, 3, 5], [13, 0, 6], [7, 2, 4], [5, 2, 0], [11, 4, 3], [17, 7, 1], [2, 5, 1]]
    vals = [n*7, n*11, n+8, n+7, n+5, n+4, n*n, n+3]
    val = vals[i]
    if val%div_check[i][0] == 0:
        return div_check[i][1], val%(2*3*5*7*11*13*17*19)
    else:
        return div_check[i][2], val%(2*3*5*7*11*13*17*19)

for n in range(10000):
    for m in range(len(monke)):
        for i in range(len(monke[m])):
            count[m] += 1
            item = monke[m][0]
            monke[m] = monke[m][1:]
            new_monke, new_val = take_turn(m, item)
            monke[new_monke] = [new_val] + monke[new_monke]
count.sort()
print(count[-1]*count[-2])

The puzzle in Part 2 was a homework problem when I was in college. Not with the monkeys, just the part where you need to use a ring with the product of prime numbers as a modulus to determine divisibility.

Unfortunately college was more than 20 years ago so it took me a long fricking time to remember that.

let pop = s => {
  if (s === 'old * old')return a=>a*a
  let q = /^old \* (\d*)$/.exec(s); if (q) return a=>a*(+q[1])
  q = /^old \+ (\d*)$/.exec(s); if (q) return a=>a+(+q[1])
}
let p2 = true
let s = fs.readFileSync('/tmp/input','utf8').split('\n\n').map(a=>/Monkey .*:\n *Starting items: (?<items>.*)\n *Operation: new = (?<op>.*)\n *Test: divisible by (?<div>.*)\n *If true: throw to monkey (?<true>.*)\n *If false: throw to monkey (?<false>.*)/.exec(a).groups).map(a=>({...a, items: a.items.split(', ').map(a=>+a), op: pop(a.op), act: 0}))
let modulo = s.map(a=>a.div).reduce((a,b)=>a*b)
for (let x = 0; x < (p2 ? 10000 : 20); x++)
for (let m of s) {
  for (let i of m.items) {
    m.act++
    i = m.op(i)
    if (!p2) i = floor(i/3)
    else i %= modulo
    s[i%m.div === 0 ? m.true : m.false].items.push(i)
  }
  m.items = []
}

let q = s.map(a=>a.act).sort((a,b)=>a-b)
let out = q.at(-1)*q.at(-2)

the above has two main sources of bloat: writing out the parser instead of just doing 'eval("old => " + op)' bc eval BAD and actually parsing with a big regex instead of just a.split('\n')[3].slice(5) or whatever

why do they need to create retarded narratives? it's just a 'throwing numbers around in a datastructure problem' that has nothing to do with monkeys. they've all been very boring so far, hopefully it'll get better.

Got stuck on part 2 because of big numbers and had to get help

Added gcd after getting help

with open('./input11.txt') as infile:
    text = infile.read()

class Monkey:
    def __init__(self, op, test:int, true:int, false:int) -> None:
        self.op = op
        self.test = test
        self.true = true
        self.false = false
        self.items = []
        self.items_checked = 0

    def inspect(self):
        for item in self.items:
            self.items_checked += 1
            item = self.op(item)
            item = item % gcd
            if item % self.test == 0:
                monkeys[self.true].items.append(item)
            else:
                monkeys[self.false].items.append(item)
        self.items = []

monkeys = []

def parse_op(op):
    _, out = map(str.strip, op.split('='))
    func  = "lambda old:" + out
    return eval(func)

gcd = 1

for m in text.split('\n\n'):
    _, items, op, test, true, false = m.splitlines()
    op = parse_op(op)
    test = int(test.split()[-1])
    true = int(true.split()[-1])
    false = int(false.split()[-1])
    monkey = Monkey(op, test, true, false)
    _, items = items.split(':')
    items = map(int, items.strip().split(', '))
    monkey.items.extend(items)
    monkeys.append(monkey)
    gcd *= test

for i in range(10000):
    for m in monkeys:
        m.inspect()

a , b = sorted([m.items_checked for m in monkeys])[-2:]
print(a*b)

>"huh this is taking a long time"

>throw in a random modulo that just feels right

>it werks

Yes i needed to include an external library to split a string in c++ and no dont ask me why i decided to make things into pointers or i have struct that only stores one value.

Also at first i assume that all throws needed to happen at the same time. So if Monkey 1 throws to Monkey 3, Monkey 3 will not throw that item in the same round again. This was not the case, and Monkey 3 would immediately keep throwing it further in the next throw.

#include <vector>
#include <memory>
#include <fstream>
#include <string>
#include <queue>
#include <scn/scn.h>
#include <fmt/core.h>
#include <boost/algorithm/string.hpp>

struct Operation {
    char operand;
    std::string rhs;
    int32_t rhs_int{ -1 };
};

struct Item {
public:
    int64_t worry;
};

class Monkey {
public:
    int32_t id;
    int32_t divisible_test;
    int32_t items_seen{ 0 };

    std::pair<int32_t, int32_t> next_monkeys;
    std::vector<std::unique_ptr<Item>> items;

    Operation op;

    int64_t do_operation(int64_t worry) {
        int64_t rhs{ 0 };
        if (op.rhs == "old") rhs = worry;
        else {
            if (op.rhs_int < 0) {
                op.rhs_int = std::stoi(op.rhs);
            }
            rhs = op.rhs_int;
        }

        if (op.operand == '*') return worry * rhs;
        if (op.operand == '+') return worry + rhs;
        if (op.operand == '-') return worry - rhs;
        return worry / rhs;
    }

    void simulate_throw(const std::vector<std::unique_ptr<Monkey>>& storage, int32_t mod, int32_t division = 3) {
        for (auto it = items.begin(); it != items.end();) {
            int32_t move_to{ next_monkeys.second };
            this->items_seen++;

            int64_t worry{ do_operation((*it)->worry) };

            if (mod == 1) (*it)->worry = worry / division;
            else (*it)->worry = worry % mod;

            if ((*it)->worry % this->divisible_test == 0) {
                move_to = next_monkeys.first;
            }  

            storage[move_to]->items.push_back(std::move(*it));
            it = items.erase(it);
        }
    }
};

auto load_monkeys()
{
    std::vector<std::unique_ptr<Monkey>> monkey_storage;

    std::ifstream file("input.txt");
    std::string line;

    while (std::getline(file, line)) {
        monkey_storage.push_back(std::make_unique<Monkey>());
        scn::scan(line, "Monkey {}:", monkey_storage.back()->id);
        std::getline(file, line, ':'); // skip until : in Operation: {}, ...
        std::getline(file, line);

        std::vector<std::string> results;
        boost::split(results, line, boost::is_any_of(","));
        for (auto item : results) {
            monkey_storage.back()->items.push_back(std::make_unique<Item>(std::stoi(item)));
        }

        std::getline(file, line);
        scn::scan(line, "  Operation: new = old {} {}", monkey_storage.back()->op.operand, monkey_storage.back()->op.rhs);

        std::getline(file, line);
        scn::scan(line, "  Test: divisible by {}", monkey_storage.back()->divisible_test);

        std::getline(file, line);
        scn::scan(line, "    If true: throw to monkey {}", monkey_storage.back()->next_monkeys.first);

        std::getline(file, line);
        scn::scan(line, "    If false: throw to monkey {}", monkey_storage.back()->next_monkeys.second);

        std::getline(file, line);
    }
    return monkey_storage;
}

std::string run(bool partTwo) {
    auto monkey_storage = load_monkeys();

    int32_t mod{ 1 };
    int32_t runs{ 20 };

    if (partTwo) {
        runs = 10'000;
        for (const auto& monkey : monkey_storage) {
            mod *= monkey->divisible_test;
        }
    } else runs = 20;

    for (int32_t i = { 0 }; i < runs; i++) {
        for (const auto& monkey : monkey_storage) {
            monkey->simulate_throw(monkey_storage, mod);
        }
    }
    std::vector<int64_t> monkey_seen;
    for (const auto& monkey : monkey_storage) {
        monkey_seen.push_back(monkey.get()->items_seen);
    }
    std::sort(monkey_seen.begin(), monkey_seen.end(), std::greater<int64_t>());

    return fmt::format("{}", monkey_seen[0] * monkey_seen[1]);
}

int main() {
    fmt::print("Part One: {}\n", run(false));
    fmt::print("Part Two: {}\n", run(true));
}

me vs snakes vs @everyone

logarithmic scales, each point is the average of three measurements, figures in milliseconds

C++chads simply cannot stop winning @drama_enthusiast discuss

i forgot that i was mutating the input for part 2 and was wondering where i was fucking up for a good hour and change. i also shamelessly stole the old = monkey[0] % maximum because 4096+ digit ints dont really chooch u_u

IT DOESN'T WORK FOR PART B

ANY IDEA WHYYYYY

I AM GOING INSANE AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

SNAKES DISCUSS

k it wasn't that difficult I just had to re-think about discrete math n shit

Tidied up version. Not all that different from my live solve, aside from switching to eval for the Monkey Operations because it's funnier to use eval, despite it being noticeably slower.

import * as fs from 'fs'
const monkeys: {
  items: number[],
  op: (old: number) => number,
  test: (num: number) => number,
  n: number,
}[] = [];
let lsd = 1;
fs.readFileSync(process.argv[2], 'utf-8').split('\n\n').forEach((ls) => {
  const l = ls.split('\n');
  const opStr = l[2].split('=')[1] || '';
  const d = Number(l[3].match(/\d+/)?.[0]) || 0;
  if (lsd % d) lsd *= d;
  const tM =  Number(l[4].match(/\d+/)?.[0]) || 0;
  const fM = Number(l[5].match(/\d+/)?.[0]) || 0;
  monkeys.push({
    items: l[1].match(/\d+/g)?.map(Number) || [],
    op: (old: number) => Number(eval(opStr.replace(/old/g, String(old)))),
    test: (num: number) => (num % d) ? fM : tM,
    n: 0,
  });
});
const round = () => monkeys.forEach(monk => {
  const items = monk.items;
  monk.items = [];
  items.forEach(w => {
    const newW = monk.op(w) % lsd;
    const newM = monk.test(newW);
    monk.n++;
    monkeys[newM].items.push(newW);
  })
});
for (let i = 0; i < 10000; i++) round();
console.log(monkeys.sort((m1, m2) => m2.n-m1.n).slice(0,2).reduce((p, m) => p * m.n, 1));

Sorry I haven't been able to keep up with it for the past three days. I have been sleeping a lot from the semester ending and stuff. Will probably catch up later

butt : washed

did most of the obvious optimizations (thanks profiler) so it's down to 3.5 seconds of runtime

No, I will not use something other than a bajillion cell arrays

anyone who wants nice data prep code... lol no

from y2022.scaffold import *

class Day11(Day):
	def __init__(self):
		super()
	
	@property
	def day(self): return :marseymonke: 11

	def prepare_data(self) -> Any:
		data = self.get_data().split('\n\n')
		#data = open('y2022/day11test.txt').read().split('\n\n')
		data2 = []
		for i in range(len(data)):
			key = i
			monkey_raw = data[i]
			monkey_raw2 = data[i].splitlines()
			monkey2 = SimpleNamespace()
			monkey2.number = key
			for j in range(len(monkey_raw2)):
				#print(monkey_raw[j])
				#if i > 7: continue
				if j == 1:
					if i == 0: monkey2.items = [59, 74, 65, 86]
					if i == 1: monkey2.items = [62, 84, 72, 91, 68, 78, 51]
					if i == 2: monkey2.items = [78, 84, 96]
					if i == 3: monkey2.items = [97, 86]
					if i == 4: monkey2.items = [50]
					if i == 5: monkey2.items = [73, 65, 69, 65, 51]
					if i == 6: monkey2.items = [69, 82, 97, 93, 82, 84, 58, 63]
					if i == 7: monkey2.items = [81, 78, 82, 76, 79, 80]
					
					'''### TEST :marseyitsrigged: ###
					if i == 0: monkey2.items = [79, 98]
					if i == 1: monkey2.items = [54, 65, 75, 74]
					if i == 2: monkey2.items = [79, 60, 97]
					if i == 3: monkey2.items = [74]
					### END TEST :marseyitsrigged: ###
					'''
					#if i > 7: raise :marseysuspicious: Exception("TOO MANY :marseymanysuchcases: MONKEYS!!!!!1")
					#idx_start = monkey_raw.find('s: ')
					#idx_end = monkey_raw.
					#items = monkey_raw.split(',')
					#items[0] = items[0].replace('Starting items:', '').strip()
					#monkey2.items = list(map(lambda x:int(x), items))
				elif j == 2:
					#print(monkey_raw2[j])
					idk_anymore = monkey_raw2[j].replace('  Operation: new = old ', '')
					monkey2.op = 'o' if 'old' in idk_anymore else idk_anymore[0]
					idk_anymore = idk_anymore[2:].strip()
					monkey2.operand = int(idk_anymore) if not 'ld' in idk_anymore else 111111111
					#r = search('Operation: new = old {} {:g}', monkey_raw, evaluate_result=True)
					#if not r: raise :marseysuspicious: Exception("COULD NOT PARASES DAHFADGAHGFSG")
					#monkey2.op, monkey2.operand = r[0], r[1]
				elif j == 3:
					r = search('Test: divisible by {:g}{:g}', monkey_raw, evaluate_result=True)
					if r:
						r = r = (int(r[0]) * 10) + int(r[1])
					else:
						r = search('Test: divisible by {:g}', monkey_raw, evaluate_result=True)
					if not r: raise :marseysuspicious: Exception('parse 2')
					monkey2.divisible = int(r[0] if not isinstance(r, int) else r)
				elif j == 4:
					r = search('If true: throw :marseypuke: to monkey :marseybrasileiro: {:g}', monkey_raw, evaluate_result=True)
					if not r: raise :marseysuspicious: Exception('parse 3')
					monkey2.throw_if_true = int(r[0])
				elif j == 5:
					r = search('If false: throw :marseypuke: to monkey :marseybigfoot: {:g}', monkey_raw, evaluate_result=True)
					if not r: raise :marseysuspicious: Exception('parse 4')
					monkey2.throw_if_false = int(r[0])
			monkey2.inspected = 0
			data2.append(monkey2)
		return data2

	def a(self):
		return
		monkeys = self.prepare_data()
		# level of monkey :marseybigfoot: business after 20 rounds
		SIMULATION_ROUNDS = 20
		TOP_FOCUS = 2
		# multiply the top two together
		for round_no in range(SIMULATION_ROUNDS):
			debug = True
			for monkey :marseysopa: in monkeys:
				while monkey.items:
					#if debug:
					#	print(monkey)
					value = int(monkey.items[0])
					old_value = int(monkey.items[0])
					try: operand = int(monkey.operand)
					except: operand = value
					#if debug: repl(locals())
					#print(monkey)
					if monkey.op == '+': value += operand
					elif monkey.op == '*': value *= operand
					elif monkey.op == 'o': value **= 2
					else: raise :marseysuspicious: Exception(f'Unknown operation type {monkey.op}!')

					if debug:
						pass
						#print_filtered_locals(locals())
						#print(f"{old_value} {monkey.op} {operand} = {value}")
						#debug = False

					monkey.inspected += 1
					value //= 3

					if value % monkey.divisible == 0:
						monkeys[monkey.throw_if_true].items.append(value)
					else:
						#print(monkey)
						#print(monkey.throw_if_false)
						#print(monkeys[5])
						monkeys[monkey.throw_if_false].items.append(value)
					del monkey.items[0]

					if debug:
						#continue
						#print(monkey)
						#print(monkeys[3])
						#print("---")
						debug = False
				#print("--------- SIMUL ROUND ----------")
		# 59760 is too low, 63000 is not right :marseyhesright: agbhdsjfsf
		#s = list(monkeys)
		s = list(sorted(monkeys, key=lambda m:m.inspected, reverse=True))
		for item in s[:2]:
			print(item)
	
	def b(self):
		monkeys = self.prepare_data()
		SIMULATION_ROUNDS = 10000
		max2 = 1
		for monkey :marseysopa: in monkeys:
			max2 *= monkey.divisible
		for round_no in range(SIMULATION_ROUNDS):
			if round_no % 2500 == 0: print(f"SIMULATION ROUND {round_no}")
			for monkey :marseybigfoot: in monkeys:
				while monkey.items:
					value = int(monkey.items[0])
					try: operand = int(monkey.operand)
					except: operand = value

					if monkey.op == '+': value += operand
					elif monkey.op == '*': value *= operand
					elif monkey.op == 'o': value *= value# % max2

					#value //= 100000000000
					value %= max2
					#value %= monkey.divisible

					monkey.inspected += 1

					if value % monkey.divisible % monkey.divisible == 0:
						monkeys[monkey.throw_if_true].items.append(value)
					else:
						monkeys[monkey.throw_if_false].items.append(value)# % monkey.divisible)
					del monkey.items[0]
		s = list(map(lambda m:m.inspected, sorted(monkeys, key=lambda m:m.inspected, reverse=True)))
		for item in s[:2]:
			print(item)
		## TOO LOW  8100990030
		## NO HINT :marseywink: 14400239965
		## TOO LOW 14401560030
		## NO HINT :marseywink: 14400959980
		## NO HINT :marseywink: 19203834231 (139343/137817)
		## TOO HIGH :marseycocaine: 22037989580
		## TOO HIGH :marseyrick: 27846764496

no comments removed because fuck you

When do we break the news about the bunkey?

was part 2 supposed to take a while to calculate?

Got a late start, fun problem

import numpy as np
def monkeyOp(num,x):
    if num == 0:
        return x*19
    elif num == 1:
        return x+1
    elif num == 2:
        return x+8
    elif num == 3:
        return x*x
    elif num == 4:
        return x+6
    elif num == 5:
        return x*17
    elif num == 6:
        return x+5
    elif num == 7:
        return x+3
def mOpTest(num,x):
    if num == 0:
        return x*19
    elif num == 1:
        return x+6
    elif num == 2:
        return x*x
    elif num == 3:
        return x+3
class Monkey:
    def __init__(self,string):
        lines = string.split('\n')
        self.monkeynum = int(lines[0].split(' ')[-1][:-1])
        self.items = [int(i) for i in lines[1].split(':')[-1].split(',')]
        self.test = int(lines[3].split(' ')[-1])
        self.ifTrue = int(lines[4].split(' ')[-1])
        self.ifFalse = int(lines[5].split(' ')[-1])
        self.inspecs = 0
    def test_result(self,num):
        if (num % self.test == 0):
            return self.ifTrue
        return self.ifFalse
    def doOp(self,x):
        return monkeyOp(self.monkeynum,x)
lcd = 7*2*19*3*13*11*5*17
f = open('AOC2022Day11.txt')
lines = f.read().strip().split('\n\n')
monkeys = [Monkey(s) for s in lines]
for _ in range(10000):
    for monkey in monkeys:
        for item in monkey.items:
            monkey.inspecs += 1
            level = monkey.doOp(item)
            #level = level //3
            level = level % lcd
            newM = monkey.test_result(level)
            monkeys[newM].items.append(level)
        monkey.items = []
lst = sorted([m.inspecs for m in monkeys])
print(lst)
print(lst[-1]*lst[-2])

oh boy its going to frick me in the butt with the parsing dildo again isn't it/?!

Nice post, bro! I posted it to twitter.

ADVENT OF PARSING

one-off error edition