day 11. took me wayyy to long

day11/src/main.rs

@@ -0,0 +1,97 @@
+use std::collections::VecDeque;
+
+#[derive(Debug, Clone)]
+struct Monkey {
+    id: usize,
+    items: VecDeque<u64>,
+    operation: String,
+    divisor: u64,
+    true_monkey: usize,
+    false_monkey: usize,
+    inspected: usize,
+}
+
+fn main() {
+    let contents = std::fs::read_to_string("data.txt").expect("Failed to read file");
+    let mut monkeys = parse(contents.lines().collect());
+    let mut monkeys2 = monkeys.clone();
+
+    let mut items = monkeys
+        .clone()
+        .into_iter()
+        .map(|m| m.items)
+        .collect::<Vec<VecDeque<u64>>>();
+    let mut items2 = items.clone();
+
+    // Part 1
+    run(&mut monkeys, &mut items, 3, 20);
+ 
+    // Part 2
+    run(&mut monkeys2, &mut items2, 1, 10000);
+}
+
+fn run(monkeys: &mut Vec<Monkey>, items: &mut Vec<VecDeque<u64>>, divisor: u64, rounds: usize) -> () {
+    let total_prod = monkeys.iter().fold(1, |acc, m| m.divisor * acc);
+    for _ in 1..=rounds {
+        for m in 0..monkeys.len() {
+            let monkey = &mut monkeys[m];
+            for _ in 0..items[m].len() {
+                let item = items[m].pop_front().unwrap();
+                let new_item = operate(monkey.operation.as_str(), &item) % total_prod;
+                let new_item = new_item / divisor;
+                monkey.inspected += 1;
+                if new_item % monkey.divisor == 0 {
+                    items[monkey.true_monkey].push_back(new_item);
+                } else {
+                    items[monkey.false_monkey].push_back(new_item);
+                }
+            }
+        }
+    }
+
+    let mut active = monkeys.iter().map(|m| m.inspected).collect::<Vec<usize>>();
+    active.sort();
+    active.reverse();
+    let score = active.drain(0..2).fold(1, |acc, x| acc * x);
+    println!("\nactive: {:?}", active);
+    println!("score: {score}");
+}
+
+fn parse(lines: Vec<&str>) -> Vec<Monkey> {
+    lines
+        .chunks(7)
+        .into_iter()
+        .map(|lines| {
+            let items = lines[1]
+                .split(" ")
+                .skip(4)
+                .map(|i| i.get(0..2).unwrap().parse().unwrap())
+                .collect::<VecDeque<u64>>();
+            let operation = lines[2].split("=").collect::<Vec<&str>>()[1]
+                .trim()
+                .to_string();
+            let divisor = lines[3].split(" ").last().unwrap().parse().unwrap();
+            let true_monkey = lines[4].chars().last().unwrap().to_digit(10).unwrap() as usize;
+            let false_monkey = lines[5].chars().last().unwrap().to_digit(10).unwrap() as usize;
+
+            Monkey {
+                id: lines[0].chars().nth(7).unwrap().to_digit(10).unwrap() as usize,
+                items,
+                operation,
+                divisor,
+                true_monkey,
+                false_monkey,
+                inspected: 0,
+            }
+        })
+        .collect()
+}
+
+fn operate(eq: &str, item: &u64) -> u64 {
+    match eq.split(" ").collect::<Vec<&str>>().as_slice() {
+        ["old", "*", "old"] => item * item,
+        ["old", "*", x] => item * x.parse::<u64>().unwrap(),
+        ["old", "+", x] => item + x.parse::<u64>().unwrap(),
+        _ => panic!("Invalid operation"),
+    }
+}