128 lines
3.5 KiB
Rust
128 lines
3.5 KiB
Rust
use std::fs::File;
|
|
use std::io::{self, BufRead};
|
|
use std::path::Path;
|
|
use std::iter::Zip;
|
|
|
|
#[derive(Debug)]
|
|
enum Operand {
|
|
Add,
|
|
Multiply,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct Test {
|
|
value: u32,
|
|
if_true: usize,
|
|
if_false: usize,
|
|
}
|
|
|
|
impl Test {
|
|
fn new(value: u32, if_true: usize, if_false: usize) -> Self {
|
|
Self {
|
|
value,
|
|
if_true,
|
|
if_false,
|
|
}
|
|
}
|
|
|
|
fn compute(&self, item: u32) -> usize {
|
|
match item % self.value {
|
|
0 => self.if_true,
|
|
_ => self.if_false,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct Operation {
|
|
lhs: Option<u32>,
|
|
rhs: Option<u32>,
|
|
operand: Operand,
|
|
}
|
|
|
|
impl Operation {
|
|
fn new(lhs: Option<u32>, rhs: Option<u32>, operand: Operand) -> Self {
|
|
Self {
|
|
lhs,
|
|
rhs,
|
|
operand,
|
|
}
|
|
}
|
|
|
|
fn compute(&self, item: u32) -> u32 {
|
|
let lhs = self.lhs.unwrap_or(item);
|
|
let rhs = self.rhs.unwrap_or(item);
|
|
match self.operand {
|
|
Operand::Multiply => lhs * rhs,
|
|
Operand::Add => lhs + rhs,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct Monkey {
|
|
items: Vec<u32>,
|
|
operation: Operation,
|
|
test: Test,
|
|
business: usize,
|
|
}
|
|
|
|
impl Monkey {
|
|
fn new(items: Vec<u32>, operation: Operation, test: Test) -> Self {
|
|
Self {
|
|
items,
|
|
operation,
|
|
test,
|
|
business: 0,
|
|
}
|
|
}
|
|
|
|
fn compute(&mut self) -> Vec<usize> {
|
|
self.business += self.items.len();
|
|
self.items = self.items.iter().map(|x| self.operation.compute(*x)).collect();
|
|
self.items = self.items.iter().map(|x| x / 3).collect();
|
|
self.items.iter().map(|x| self.test.compute(*x)).collect()
|
|
}
|
|
}
|
|
|
|
|
|
|
|
fn main() {
|
|
let file_path = String::from("input");
|
|
let mut monkeys = Vec::<Monkey>::new();
|
|
|
|
monkeys.push(Monkey::new(vec![72, 97], Operation::new(None, Some(13), Operand::Multiply), Test::new(19, 5, 6)));
|
|
monkeys.push(Monkey::new(vec![55, 70, 90, 74, 95], Operation::new(None, None, Operand::Multiply), Test::new(7, 5, 0)));
|
|
monkeys.push(Monkey::new(vec![74, 97, 66, 57], Operation::new(None, Some(6), Operand::Add), Test::new(17, 1, 0)));
|
|
monkeys.push(Monkey::new(vec![86, 54, 53], Operation::new(None, Some(2), Operand::Add), Test::new(13, 1, 2)));
|
|
monkeys.push(Monkey::new(vec![50, 65, 78, 50, 62, 99], Operation::new(None, Some(3), Operand::Add), Test::new(11, 3, 7)));
|
|
monkeys.push(Monkey::new(vec![90], Operation::new(None, Some(4), Operand::Add), Test::new(2, 4, 6)));
|
|
monkeys.push(Monkey::new(vec![88, 92, 63, 94, 96, 82, 53, 53], Operation::new(None, Some(8), Operand::Add), Test::new(5, 4, 7)));
|
|
monkeys.push(Monkey::new(vec![70, 60, 71, 69, 77, 70, 98], Operation::new(None, Some(7), Operand::Multiply), Test::new(3, 2, 3)));
|
|
|
|
for _ in 0..20 {
|
|
for i in 0..8 {
|
|
let pass_to_i_vec = monkeys[i].compute();
|
|
let test: Vec<u32> = monkeys[i].items.drain(..).collect();
|
|
let my_zip = test.iter().zip(pass_to_i_vec.iter());
|
|
for (v, i) in my_zip {
|
|
monkeys[*i].items.push(*v);
|
|
}
|
|
}
|
|
}
|
|
|
|
println!("{:#?}", monkeys);
|
|
let mut monkey_business = Vec::<usize>::new();
|
|
for i in 0..8 {
|
|
monkey_business.push(monkeys[i].business);
|
|
}
|
|
monkey_business.sort();
|
|
println!("{}", monkey_business[6] * monkey_business[7]);
|
|
}
|
|
|
|
fn read_lines<P>(filename: P) -> io::Result<io::Lines<io::BufReader<File>>>
|
|
where P: AsRef<Path>, {
|
|
let file = File::open(filename)?;
|
|
Ok(io::BufReader::new(file).lines())
|
|
}
|