[2016][rust][12.0] Screw immutability

2016/rust/src/day_12.rs

@@ -1,22 +1,119 @@
 use std::collections::HashMap;
+use std::str;
 
 use errors::*;
 
 pub fn solve(input: &str) -> Result<String> {
-    Ok("".into())
+    let instructions: Instructions = input.parse()?;
+    let assembunny = Assembunny::new(instructions);
+    let registers = assembunny.last().ok_or("")?;
+    Ok(format!("{}", registers.get(Register::A)))
+}
+
+struct Assembunny {
+    registers: Registers,
+    instructions: Instructions,
+}
+
+impl Assembunny {
+    fn new(instructions: Instructions) -> Self {
+        Assembunny {
+            registers: Registers::new(),
+            instructions: instructions,
+        }
+    }
+
+    fn value<V: Into<Variable>>(&self, v: V) -> isize {
+        let v: Variable = v.into();
+        match v {
+            Variable::Register(r) => self.registers.get(r),
+            Variable::Value(i) => i,
+        }
+    }
+}
+
+impl Iterator for Assembunny {
+    type Item = Registers;
+    fn next(&mut self) -> Option<Registers> {
+        let pc = self.value(Register::PC) as usize;
+        let instruction = match self.instructions.0.get(pc) {
+            Some(i) => i,
+            None => {
+                return None;
+            }
+        };
+
+        match *instruction {
+            Instruction::Cpy(v, r) => {
+                let value = self.value(v);
+                self.registers.set(r, value);
+                self.registers.inc(Register::PC);
+            }
+            Instruction::Inc(r) => {
+                self.registers.inc(r);
+                self.registers.inc(Register::PC);
+            }
+            Instruction::Dec(r) => {
+                self.registers.dec(r);
+                self.registers.inc(Register::PC);
+            }
+            Instruction::Jnz(v, i) => {
+                let delta = if self.value(v) == 0 { 1 } else { i };
+                let pc = self.value(Register::PC) + delta;
+                self.registers.set(Register::PC, pc);
+            }
+        }
+
+        Some(self.registers.clone())
+    }
+}
+
+#[derive(Clone, Debug)]
+struct Registers(HashMap<Register, isize>);
+struct Instructions(Vec<Instruction>);
+
+impl Registers {
+    fn new() -> Self {
+        Registers(HashMap::new())
+    }
+
+    fn get(&self, r: Register) -> isize {
+        self.0.get(&r).cloned().unwrap_or(0)
+    }
+
+    fn set(&mut self, r: Register, i: isize) {
+        self.0.insert(r, i);
+    }
+
+    fn inc(&mut self, r: Register) {
+        let v = self.get(r) + 1;
+        self.set(r, v);
+    }
+
+    fn dec(&mut self, r: Register) {
+        let v = self.get(r) - 1;
+        self.set(r, v);
+    }
 }
 
-// The assembunny code you've extracted operates on four registers (a, b, c, and d) that start at 0
-// and can hold any integer. However, it seems to make use of only a few instructions:
 #[derive(Clone, Copy, Debug, Hash, Eq, PartialEq)]
 enum Register {
+    PC,
     A,
     B,
     C,
     D,
 }
 
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum Instruction {
+    Cpy(Variable, Register),
+    Inc(Register),
+    Dec(Register),
+    Jnz(Variable, isize),
+}
+
+#[derive(Clone, Copy, Debug, PartialEq)]
 enum Variable {
     Register(Register),
     Value(isize),
@@ -28,148 +125,153 @@ impl From<Register> for Variable {
     }
 }
 
-impl From<isize> for Variable {
+// Parsing
-    fn from(i: isize) -> Self {
+
-        Variable::Value(i)
+impl str::FromStr for Instructions {
+    type Err = Error;
+    fn from_str(s: &str) -> Result<Self> {
+        s.lines()
+            .map(|line| line.parse())
+            .collect::<Result<Vec<_>>>()
+            .map(Instructions)
     }
 }
 
-#[derive(Debug, PartialEq)]
+impl str::FromStr for Register {
-struct State {
+    type Err = Error;
-    pc: usize,
+    fn from_str(s: &str) -> Result<Self> {
-    registers: HashMap<Register, isize>,
+        match s {
+            "a" => Ok(Register::A),
+            "b" => Ok(Register::B),
+            "c" => Ok(Register::C),
+            "d" => Ok(Register::D),
+            _ => Err(format!("invalid register '{}'", s).into()),
+        }
+    }
 }
 
-impl State {
+impl str::FromStr for Instruction {
-    fn value(&self, v: Variable) -> isize {
+    type Err = Error;
-        match v {
+    fn from_str(s: &str) -> Result<Self> {
-            Variable::Register(ref r) => {
+        let mut tokens = s.split_whitespace();
-                self.registers.get(r).cloned().unwrap_or(0 as isize)
+        match tokens.next() {
+            Some("cpy") => {
+                let v = tokens.read_variable()?;
+                let r = tokens.read_register()?;
+                Ok(Instruction::Cpy(v, r))
             }
-            Variable::Value(value) => value,
+            Some("inc") => {
+                let r = tokens.read_register()?;
+                Ok(Instruction::Inc(r))
             }
+            Some("dec") => {
+                let r = tokens.read_register()?;
+                Ok(Instruction::Dec(r))
             }
-}
+            Some("jnz") => {
-
+                let var = tokens.read_variable()?;
-// cpy x y copies x (either an integer or the value of a register) into register y.
+                let val = tokens.read_value()?;
-struct Copy {
+                Ok(Instruction::Jnz(var, val))
-    variable: Variable,
+            }
-    register: Register,
+            Some(inst) => Err(format!("invalid instruction '{}'", inst).into()),
-}
+            None => Err("no instruction".into()),
-
-impl Copy {
-    fn run(&self, state: &State) -> State {
-        let pc = state.pc + 1;
-        let mut registers = state.registers.clone();
-        let value = state.value(self.variable);
-        registers.insert(self.register, value);
-        State {
-            pc: pc,
-            registers: registers,
         }
     }
 }
 
-// inc x increases the value of register x by one.
+impl str::FromStr for Variable {
-struct Increment {
+    type Err = Error;
-    register: Register,
+    fn from_str(s: &str) -> Result<Self> {
-}
+        s.parse::<Register>()
-
+            .map(Variable::Register)
-impl Increment {
+            .or_else(|_| s.parse::<isize>().map(Variable::Value))
-    fn run(&self, state: &State) -> State {
+            .map_err(|_| format!("invalid variable '{}'", s).into())
-        let pc = state.pc + 1;
-        let mut registers = state.registers.clone();
-        let value = state.value(self.register.into()) + 1;
-        registers.insert(self.register, value);
-        State {
-            pc: pc,
-            registers: registers,
-        }
     }
 }
 
-// dec x decreases the value of register x by one.
+trait SplitWhitespaceExt {
-struct Decrement {
+    fn read_variable(&mut self) -> Result<Variable>;
-    register: Register,
+    fn read_register(&mut self) -> Result<Register>;
+    fn read_value(&mut self) -> Result<isize>;
 }
 
-impl Decrement {
+impl<'a> SplitWhitespaceExt for str::SplitWhitespace<'a> {
-    fn run(&self, state: &State) -> State {
+    fn read_variable(&mut self) -> Result<Variable> {
-        let pc = state.pc + 1;
+        self.next()
-        let mut registers = state.registers.clone();
+            .ok_or("missing variable".into())
-        let value = state.value(self.register.into()) - 1;
+            .and_then(|v| v.parse::<Variable>())
-        registers.insert(self.register, value);
-        State {
-            pc: pc,
-            registers: registers,
     }
+
+    fn read_register(&mut self) -> Result<Register> {
+        self.next()
+            .ok_or("missing register".into())
+            .and_then(|v| v.parse::<Register>())
     }
-}
 
-// jnz x y jumps to an instruction y away (positive means forward; negative means backward), but only if x is not zero.
+    fn read_value(&mut self) -> Result<isize> {
+        self.next()
+            .ok_or("missing value".into())
+            .and_then(|v| v.parse::<isize>().chain_err(|| ""))
+    }
+}
 
 #[cfg(test)]
 mod tests {
-    use super::{Variable, Register, State, Copy, Increment, Decrement};
+    use super::{Assembunny, Instructions, Instruction, Register, Variable};
+    use std::str::FromStr;
 
     #[test]
-    fn test_state_value() {
+    fn test_assembunny() {
-        let state = State {
+        let instructions: Instructions = "cpy 41 a
-            pc: 0,
+inc a
-            registers: vec![(Register::A, 41)].into_iter().collect(),
+inc a
-        };
+dec a
-        assert_eq!(state.value(Register::A.into()), 41);
+jnz a 2
-        assert_eq!(state.value(Register::B.into()), 0);
+dec a"
-        assert_eq!(state.value(23.into()), 23);
+            .parse()
-    }
+            .unwrap();
+        let mut assembunny = Assembunny::new(instructions);
 
-    #[test]
+        let registers = assembunny.next().unwrap();
-    fn test_copy() {
+        assert_eq!(registers.get(Register::A), 41);
-        let variable = Variable::Value(41);
+        assert_eq!(registers.get(Register::B), 0);
-        let register = Register::A;
-        let copy = Copy {
-            variable: variable,
-            register: register,
-        };
-        let state = State {
-            pc: 0,
-            registers: vec![].into_iter().collect(),
-        };
-        let expected = State {
-            pc: 1,
-            registers: vec![(Register::A, 41)].into_iter().collect(),
-        };
 
-        assert_eq!(copy.run(&state), expected);
+        let registers = assembunny.next().unwrap();
+        assert_eq!(registers.get(Register::A), 42);
+        assert_eq!(registers.get(Register::C), 0);
+
+        let registers = assembunny.last().unwrap();
+        assert_eq!(registers.get(Register::A), 42);
+        assert_eq!(registers.get(Register::PC), 6);
     }
 
     #[test]
-    fn test_increment() {
+    fn test_instructions_from_str() {
-        let increment = Increment { register: Register::A };
+        let i: Instructions = "cpy 41 a
-        let state = State {
+inc a
-            pc: 0,
+inc a
-            registers: vec![(Register::A, 41)].into_iter().collect(),
+dec a
-        };
+jnz a 2
-        let expected = State {
+dec a"
-            pc: 1,
+            .parse()
-            registers: vec![(Register::A, 42)].into_iter().collect(),
+            .unwrap();
-        };
+        assert_eq!(i.0.len(), 6);
-
+        assert_eq!(i.0[0], Instruction::from_str("cpy 41 a").unwrap());
-        assert_eq!(increment.run(&state), expected);
     }
 
     #[test]
-    fn test_decrement() {
+    fn test_instruction_from_str() {
-        let decrement = Decrement { register: Register::A };
+        assert!(Instruction::from_str("").is_err());
-        let state = State {
+        assert!(Instruction::from_str("omg").is_err());
-            pc: 0,
+        assert!(Instruction::from_str("inc 5").is_err());
-            registers: vec![(Register::A, 41)].into_iter().collect(),
-        };
-        let expected = State {
-            pc: 1,
-            registers: vec![(Register::A, 40)].into_iter().collect(),
-        };
 
-        assert_eq!(decrement.run(&state), expected);
+        assert_eq!(Instruction::from_str("cpy 41 a").unwrap(),
+                   Instruction::Cpy(Variable::Value(41), Register::A));
+        assert_eq!(Instruction::from_str("inc a").unwrap(),
+                   Instruction::Inc(Register::A));
+        assert_eq!(Instruction::from_str("dec b").unwrap(),
+                   Instruction::Dec(Register::B));
+        assert_eq!(Instruction::from_str("jnz c 2").unwrap(),
+                   Instruction::Jnz(Variable::Register(Register::C), 2));
     }
 }