use std::io::{self, Read};
use std::str::FromStr;
#[derive(Clone, Copy)]
enum Operand {
Register(u8),
Immediate(i32),
}
impl FromStr for Operand {
type Err = ();
fn from_str(s: &str) -> Result<Self, ()> {
match s {
"a" => Ok(Operand::Register(0)),
"b" => Ok(Operand::Register(1)),
"c" => Ok(Operand::Register(2)),
"d" => Ok(Operand::Register(3)),
_ => Ok(Operand::Immediate(s.parse().map_err(|_| ())?)),
}
}
}
#[derive(Clone, Copy)]
enum Operation {
Cpy(Operand, Operand),
Inc(Operand),
Dec(Operand),
Jnz(Operand, Operand),
}
impl FromStr for Operation {
type Err = ();
fn from_str(s: &str) -> Result<Self, ()> {
let mut iter = s.split(' ');
match iter.next() {
Some("cpy") => {
let src = iter.next().ok_or(())?.parse()?;
let dest = iter.next().ok_or(())?.parse()?;
Ok(Operation::Cpy(src, dest))
},
Some("inc") => Ok(Operation::Inc(iter.next().ok_or(())?.parse()?)),
Some("dec") => Ok(Operation::Dec(iter.next().ok_or(())?.parse()?)),
Some("jnz") => {
let cond = iter.next().ok_or(())?.parse()?;
let jump = iter.next().ok_or(())?.parse()?;
Ok(Operation::Jnz(cond, jump))
},
_ => Err(()),
}
}
}
#[derive(Default)]
struct Vm {
registers: [i32; 4],
operations: Vec<Operation>,
index: i32,
}
impl FromStr for Vm {
type Err = ();
fn from_str(s: &str) -> Result<Self, ()> {
let mut vm = Self::default();
for line in s.lines() {
vm.operations.push(line.parse()?);
}
Ok(vm)
}
}
impl Vm {
fn step(&mut self) -> bool {
match self.operations[self.index as usize] {
Operation::Cpy(Operand::Immediate(imm), Operand::Register(reg)) => {
self.registers[reg as usize] = imm;
self.index += 1;
},
Operation::Cpy(Operand::Register(src), Operand::Register(dest)) => {
self.registers[dest as usize] = self.registers[src as usize];
self.index += 1;
},
Operation::Inc(Operand::Register(reg)) => {
self.registers[reg as usize] += 1;
self.index += 1;
},
Operation::Dec(Operand::Register(reg)) => {
self.registers[reg as usize] -= 1;
self.index += 1;
},
Operation::Jnz(Operand::Immediate(cond), Operand::Immediate(jump)) => {
if cond != 0 {
self.index += jump;
} else {
self.index += 1;
}
},
Operation::Jnz(Operand::Register(reg), Operand::Immediate(jump)) => {
if self.registers[reg as usize] != 0 {
self.index += jump;
} else {
self.index += 1;
}
},
_ => panic!("invalid operation"),
}
(self.index as usize) < self.operations.len()
}
}
fn solve1(input: &str) -> i32 {
let mut vm: Vm = input.parse().unwrap();
while vm.step() { }
vm.registers[0]
}
fn solve2(input: &str) -> i32 {
let mut vm: Vm = input.parse().unwrap();
vm.registers[2] = 1;
while vm.step() { }
vm.registers[0]
}
fn main() {
let mut input = String::new();
io::stdin().read_to_string(&mut input).unwrap();
println!("Part 1: {}", solve1(&input));
println!("Part 2: {}", solve2(&input));
}
#[test]
fn part1() {
let input = "
cpy 41 a
inc a
inc a
dec a
jnz a 2
dec a
";
assert_eq!(42, solve1(input.trim()));
}