Add day 11

Author: LinAGKar

day11_input.txt

@@ -0,0 +1,55 @@
+Monkey 0:
+  Starting items: 50, 70, 89, 75, 66, 66
+  Operation: new = old * 5
+  Test: divisible by 2
+    If true: throw to monkey 2
+    If false: throw to monkey 1
+
+Monkey 1:
+  Starting items: 85
+  Operation: new = old * old
+  Test: divisible by 7
+    If true: throw to monkey 3
+    If false: throw to monkey 6
+
+Monkey 2:
+  Starting items: 66, 51, 71, 76, 58, 55, 58, 60
+  Operation: new = old + 1
+  Test: divisible by 13
+    If true: throw to monkey 1
+    If false: throw to monkey 3
+
+Monkey 3:
+  Starting items: 79, 52, 55, 51
+  Operation: new = old + 6
+  Test: divisible by 3
+    If true: throw to monkey 6
+    If false: throw to monkey 4
+
+Monkey 4:
+  Starting items: 69, 92
+  Operation: new = old * 17
+  Test: divisible by 19
+    If true: throw to monkey 7
+    If false: throw to monkey 5
+
+Monkey 5:
+  Starting items: 71, 76, 73, 98, 67, 79, 99
+  Operation: new = old + 8
+  Test: divisible by 5
+    If true: throw to monkey 0
+    If false: throw to monkey 2
+
+Monkey 6:
+  Starting items: 82, 76, 69, 69, 57
+  Operation: new = old + 7
+  Test: divisible by 11
+    If true: throw to monkey 7
+    If false: throw to monkey 4
+
+Monkey 7:
+  Starting items: 65, 79, 86
+  Operation: new = old + 5
+  Test: divisible by 17
+    If true: throw to monkey 5
+    If false: throw to monkey 0

day11a/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "day11a"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+regex = "1"

day11a/src/main.rs

@@ -0,0 +1,74 @@
+use regex::Regex;
+use std::collections::VecDeque;
+use std::io::Read;
+
+enum Operation {
+    Add(u32),
+    Mult(u32),
+    Square,
+}
+
+struct Monkey {
+    items: VecDeque<u32>,
+    op: Operation,
+    divisor: u32,
+    t: usize,
+    f: usize,
+    inspections: u32,
+}
+
+fn main() {
+    let mut input = String::new();
+    std::io::stdin().read_to_string(&mut input).unwrap();
+
+    let re = Regex::new(concat!(
+        r"(?m)^Monkey (\d+):\n  Starting items: (\d+(?:, \d+)*)\n  Operation: new = old (?:\* (?:(\d+)|(old))|\+ ",
+        r"(\d+))\n  Test: divisible by (\d+)\n    If true: throw to monkey (\d+)\n    If false: throw to monkey (\d+)$",
+    )).unwrap();
+
+    let mut monkeys: Vec<_> = re.captures_iter(&input).enumerate().map(|(n, m)| {
+        assert_eq!(m[1].parse::<usize>().unwrap(), n);
+
+        Monkey {
+            items: m[2].split(", ").map(|num| num.parse().unwrap()).collect(),
+            op: if let Some(factor) = m.get(3) {
+                Operation::Mult(factor.as_str().parse().unwrap())
+            } else if let Some(_) = m.get(4) {
+                Operation::Square
+            } else if let Some(term) = m.get(5) {
+                 Operation::Add(term.as_str().parse().unwrap())
+            } else {
+                panic!()
+            },
+            divisor: m[6].parse().unwrap(),
+            t: m[7].parse().unwrap(),
+            f: m[8].parse().unwrap(),
+            inspections: 0,
+        }
+    }).collect();
+
+    for _ in 0..20 {
+        for i in 0..monkeys.len() {
+            while let Some(item) = monkeys[i].items.pop_front() {
+                let monkey = &monkeys[i];
+                let item = match monkey.op {
+                    Operation::Mult(factor) => item * factor,
+                    Operation::Square => item * item,
+                    Operation::Add(term) => item + term,
+                } / 3;
+                let target = if item % monkey.divisor == 0 { monkey.t } else { monkey.f };
+                monkeys[i].inspections += 1;
+                monkeys[target].items.push_back(item);
+            }
+        }
+    }
+
+    let mut top = [0; 2];
+    for monkey in &monkeys {
+        let i = top.iter_mut().min().unwrap();
+        if monkey.inspections > *i {
+            *i = monkey.inspections;
+        }
+    }
+    println!("{}", top.iter().product::<u32>());
+}

day11b/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "day11b"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+regex = "1"

day11b/src/main.rs

@@ -0,0 +1,77 @@
+use regex::Regex;
+use std::collections::VecDeque;
+use std::io::Read;
+
+enum Operation {
+    Add(u64),
+    Mult(u64),
+    Square,
+}
+
+struct Monkey {
+    items: VecDeque<u64>,
+    op: Operation,
+    divisor: u64,
+    t: usize,
+    f: usize,
+    inspections: u64,
+}
+
+fn main() {
+    let mut input = String::new();
+    std::io::stdin().read_to_string(&mut input).unwrap();
+
+    let re = Regex::new(concat!(
+        r"(?m)^Monkey (\d+):\n  Starting items: (\d+(?:, \d+)*)\n  Operation: new = old (?:\* (?:(\d+)|(old))|\+ ",
+        r"(\d+))\n  Test: divisible by (\d+)\n    If true: throw to monkey (\d+)\n    If false: throw to monkey (\d+)$",
+    )).unwrap();
+
+    let mut monkeys: Vec<_> = re.captures_iter(&input).enumerate().map(|(n, m)| {
+        assert_eq!(m[1].parse::<usize>().unwrap(), n);
+
+        Monkey {
+            items: m[2].split(", ").map(|num| num.parse().unwrap()).collect(),
+            op: if let Some(factor) = m.get(3) {
+                Operation::Mult(factor.as_str().parse().unwrap())
+            } else if let Some(_) = m.get(4) {
+                Operation::Square
+            } else if let Some(term) = m.get(5) {
+                 Operation::Add(term.as_str().parse().unwrap())
+            } else {
+                panic!()
+            },
+            divisor: m[6].parse().unwrap(),
+            t: m[7].parse().unwrap(),
+            f: m[8].parse().unwrap(),
+            inspections: 0,
+        }
+    }).collect();
+    let modulo = monkeys.iter().fold(1, |acc, monkey|
+        if acc % monkey.divisor == 0 { acc } else { acc * monkey.divisor }
+    );
+
+    for _ in 0..10000 {
+        for i in 0..monkeys.len() {
+            while let Some(item) = monkeys[i].items.pop_front() {
+                let monkey = &monkeys[i];
+                let item = match monkey.op {
+                    Operation::Mult(factor) => item * factor,
+                    Operation::Square => item * item,
+                    Operation::Add(term) => item + term,
+                } % modulo;
+                let target = if item % monkey.divisor == 0 { monkey.t } else { monkey.f };
+                monkeys[i].inspections += 1;
+                monkeys[target].items.push_back(item);
+            }
+        }
+    }
+
+    let mut top = [0; 2];
+    for monkey in &monkeys {
+        let i = top.iter_mut().min().unwrap();
+        if monkey.inspections > *i {
+            *i = monkey.inspections;
+        }
+    }
+    println!("{}", top.iter().product::<u64>());
+}