Day 11-2

src/day_11_2/mod.rs

+mod monkey;
+mod operation;
+
+use monkey::Monkey;
+use operation::Operation;
+
+const ROUNDS: u32 = 10000;
+
+pub fn solve_from_str(input: &str) -> u64 {
+    let mut monkeys = input
+        .split("\n\n")
+        .map(|monkey| Monkey::from_str(monkey))
+        .collect();
+
+    solve(&mut monkeys)
+}
+
+pub fn solve(monkeys: &mut Vec<Monkey>) -> u64 {
+    let common_multiple: u64 = monkeys
+        .iter()
+        .map(|monkey| monkey.test_divisible_by)
+        .product();
+
+    // for i in (1..monkeys[0].test_divisible_by).rev() {
+    //     let mut is_greatest_common_divisor = true;
+
+    //     for monkey in & *monkeys {
+    //         if monkey.test_divisible_by % i != 0 {
+    //             is_greatest_common_divisor = false;
+
+    //             break;
+    //         }
+    //     }
+
+    //     if is_greatest_common_divisor {
+    //         common_multiple = i;
+
+    //         break;
+    //     }
+    // }
+
+    dbg!(common_multiple);
+
+    for _ in 0..ROUNDS {
+        for i in 0..monkeys.len() {
+            while !monkeys[i].items.is_empty() {
+                monkeys[i].inspections += 1;
+
+                let mut item = monkeys[i].items.pop_front().unwrap().clone();
+
+                match monkeys[i].operation {
+                    Operation::Add(number) => item += number,
+                    Operation::Multiply(number) => item *= number,
+                    Operation::Square() => item *= item,
+                }
+
+                item = item % common_multiple;
+
+                if item % monkeys[i].test_divisible_by == 0 {
+                    let to_monkey_true = monkeys[i].to_monkey_true;
+
+                    monkeys[to_monkey_true].items.push_back(item);
+                } else {
+                    let to_monkey_false = monkeys[i].to_monkey_false;
+
+                    monkeys[to_monkey_false].items.push_back(item);
+                }
+            }
+        }
+    }
+
+    dbg!(&monkeys);
+
+    monkeys.sort_by_key(|monkey| monkey.inspections);
+
+    monkeys
+        .iter()
+        .rev()
+        .take(2)
+        .map(|monkey| monkey.inspections)
+        .product()
+}

src/day_11_2/monkey.rs

+use std::collections::VecDeque;
+
+use crate::day_11_2::operation::Operation;
+
+#[derive(Debug)]
+pub struct Monkey {
+    pub items: VecDeque<u64>,
+    pub operation: Operation,
+    pub test_divisible_by: u64,
+    pub to_monkey_true: usize,
+    pub to_monkey_false: usize,
+    pub inspections: u64,
+}
+
+impl Monkey {
+    pub fn from_str(input: &str) -> Monkey {
+        let mut data = input.split('\n');
+
+        data.next();
+
+        let items = data.next().expect("Expected items!");
+        let mut items = items.chars();
+        items.nth(17);
+        let items: String = items.collect();
+
+        let items = items
+            .split(", ")
+            .map(|item| item.parse().expect("Expected number!"))
+            .collect();
+
+        let operation = Operation::from_str(data.next().expect("Expected operation!"));
+
+        let test_divisible_by = data.next().expect("Expected test!");
+        let test_divisible_by = test_divisible_by
+            .split(' ')
+            .nth(5)
+            .expect("Expected number!")
+            .parse()
+            .expect("Expected number!");
+
+        let to_monkey_true = data.next().expect("Expected if true!");
+        let to_monkey_true = to_monkey_true
+            .split(' ')
+            .nth(9)
+            .expect("Expected number!")
+            .parse()
+            .expect("Expected number!");
+
+        let to_monkey_false = data.next().expect("Expected if false!");
+        let to_monkey_false = to_monkey_false
+            .split(' ')
+            .nth(9)
+            .expect("Expected number!")
+            .parse()
+            .expect("Expected number!");
+
+        Monkey {
+            items,
+            operation,
+            test_divisible_by,
+            to_monkey_true,
+            to_monkey_false,
+            inspections: 0,
+        }
+    }
+}

src/day_11_2/operation.rs

+#[derive(Debug)]
+pub enum Operation {
+    Add(u64),
+    Multiply(u64),
+    Square(),
+}
+
+impl Operation {
+    pub fn from_str(input: &str) -> Operation {
+        let operation = input.split(' ').nth(6).expect("Expected operation!");
+
+        if operation == "+" {
+            Operation::Add(
+                input
+                    .split(' ')
+                    .nth(7)
+                    .expect("Expected number!")
+                    .parse()
+                    .expect("Expected number!"),
+            )
+        } else if operation == "*" {
+            if let Ok(number) = input.split(' ').nth(7).expect("Expected number!").parse() {
+                Operation::Multiply(number)
+            } else {
+                Operation::Square()
+            }
+        } else {
+            panic!("Unexpected operation!");
+        }
+    }
+}

src/main.rs

@@ -17,13 +17,14 @@ mod day_9_2;
 mod day_10_1;
 mod day_10_2;
 mod day_11_1;
+mod day_11_2;
 
 use std::fs;
 
 fn main() {
     let input = fs::read_to_string("input").expect("Could not read input!");
 
-    let solution = day_11_1::solve_from_str(input.as_str());
+    let solution = day_11_2::solve_from_str(input.as_str());
 
     println!("Solution: {}", solution);
 }