Clean up day 16 and 19.

Day 16 and 19 share the same CPU and now they actually share the same
code for it.

2018/src/day16.rs

@@ -6,105 +6,8 @@ use std::io::Read;
 use regex::Regex;
 
 use common::Solution;
-
-#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
-enum OpCode {
-    ADDR,
-    ADDI,
-    MULR,
-    MULI,
-    BANR,
-    BANI,
-    BORR,
-    BORI,
-    SETR,
-    SETI,
-    GTIR,
-    GTRI,
-    GTRR,
-    EQIR,
-    EQRI,
-    EQRR,
-}
-
-impl OpCode {
-    fn valid(self, op: &[i32; 4], before: &[i32; 4], after: &[i32; 4]) -> bool {
-        let mut cpu: CPU = Default::default();
-
-        cpu.registers.copy_from_slice(before);
-        if let Ok(val) = cpu.execute(self, &op[1..4]) {
-            if val == after[op[3] as usize] {
-                return true;
-            }
-        }
-
-        false
-    }
-}
-
-const OP_LIST: [OpCode; 16] = [
-    OpCode::ADDR,
-    OpCode::ADDI,
-    OpCode::MULR,
-    OpCode::MULI,
-    OpCode::BANR,
-    OpCode::BANI,
-    OpCode::BORR,
-    OpCode::BORI,
-    OpCode::SETR,
-    OpCode::SETI,
-    OpCode::GTIR,
-    OpCode::GTRI,
-    OpCode::GTRR,
-    OpCode::EQIR,
-    OpCode::EQRI,
-    OpCode::EQRR,
-];
-
-#[derive(Debug)]
-enum CPUErr {
-    InvalidRegister(i32),
-}
-
-#[derive(Default)]
-struct CPU {
-    registers: [i32; 4],
-}
-
-impl CPU {
-    pub fn execute(&mut self, op: OpCode, var: &[i32]) -> Result<i32, CPUErr> {
-        use self::OpCode::*;
-        let res = match op {
-            ADDR => self.reg(var[0])? + self.reg(var[1])?,
-            ADDI => self.reg(var[0])? + var[1],
-            MULR => self.reg(var[0])? * self.reg(var[1])?,
-            MULI => self.reg(var[0])? * var[1],
-            BANR => self.reg(var[0])? & self.reg(var[1])?,
-            BANI => self.reg(var[0])? & var[1],
-            BORR => self.reg(var[0])? | self.reg(var[1])?,
-            BORI => self.reg(var[0])? | var[1],
-            SETR => self.reg(var[0])?,
-            SETI => var[0],
-            GTRR => (self.reg(var[0])? > self.reg(var[1])?).into(),
-            GTIR => (var[0] > self.reg(var[1])?).into(),
-            GTRI => (self.reg(var[0])? > var[1]).into(),
-            EQRR => (self.reg(var[0])? == self.reg(var[1])?).into(),
-            EQIR => (var[0] == self.reg(var[1])?).into(),
-            EQRI => (self.reg(var[0])? == var[1]).into(),
-        };
-
-        self.registers[var[2] as usize] = res;
-        Ok(res)
-    }
-
-    fn reg(&self, index: i32) -> Result<i32, CPUErr> {
-        if let Some(val) = self.registers.get(index as usize) {
-            Ok(*val)
-        } else {
-            Err(CPUErr::InvalidRegister(index))
-        }
-    }
-}
+use cpu::OpCode;
+use cpu::CPU;
 
 pub struct Day16 {
     matcher: Regex,
@@ -119,15 +22,15 @@ impl Day16 {
         }
     }
 
-    fn read(&mut self, reader: &mut BufRead, target: &mut [i32; 4]) -> bool {
+    fn read(&mut self, reader: &mut BufRead, target: &mut [i32]) -> bool {
         self.buf.clear();
         if reader.read_line(&mut self.buf).is_err() {
             return false;
         }
 
         if let Some(captures) = self.matcher.captures(&self.buf) {
-            for i in 0..4 {
-                target[i] = captures[i + 1].parse().unwrap();
+            for (target, cap) in target.iter_mut().zip(captures.iter().skip(1)) {
+                *target = cap.unwrap().as_str().parse().unwrap();
             }
 
             true
@@ -143,22 +46,21 @@ impl Day16 {
             HashSet::new(), HashSet::new(), HashSet::new(), HashSet::new(),
             HashSet::new(), HashSet::new(), HashSet::new(), HashSet::new(),
         ];
-        let mut before = [0; 4];
+        let mut before = [0; 6];
         let mut op = [0; 4];
-        let mut after = [0; 4];
-        while self.read(&mut reader, &mut before) {
+        let mut after = [0; 6];
+        while self.read(&mut reader, &mut before[..4]) {
             self.read(&mut reader, &mut op);
-            self.read(&mut reader, &mut after);
+            self.read(&mut reader, &mut after[..4]);
             reader.read_line(&mut self.buf).unwrap_or(0);
 
             if mappings[op[0] as usize].is_empty() {
-                mappings[op[0] as usize].extend(OP_LIST.iter()
-                    .filter(|x| x.valid(&op, &before, &after))
-                    .cloned());
+                mappings[op[0] as usize].extend(OpCode::values()
+                    .filter(|x| x.is_valid(&op, &before, &after)));
             } else {
-                for option in OP_LIST.iter()
-                    .filter(|x| !x.valid(&op, &before, &after)) {
-                    mappings[op[0] as usize].remove(option);
+                for option in OpCode::values()
+                    .filter(|x| !x.is_valid(&op, &before, &after)) {
+                    mappings[op[0] as usize].remove(&option);
                 }
                 continue;
             }
@@ -207,18 +109,18 @@ impl Solution for Day16 {
     fn part1(&mut self, input: &mut Read) -> String {
         let mut reader = BufReader::new(input);
 
-        let mut before = [0; 4];
+        let mut before = [0; 6];
         let mut op = [0; 4];
-        let mut after = [0; 4];
+        let mut after = [0; 6];
         let mut counter = 0;
 
-        while self.read(&mut reader, &mut before) {
+        while self.read(&mut reader, &mut before[..4]) {
             self.read(&mut reader, &mut op);
-            self.read(&mut reader, &mut after);
+            self.read(&mut reader, &mut after[..4]);
             reader.read_line(&mut self.buf).unwrap_or(0);
 
-            let valid = OP_LIST.iter()
-                .filter(|x| x.valid(&op, &before, &after))
+            let valid = OpCode::values()
+                .filter(|x| x.is_valid(&op, &before, &after))
                 .count();
 
             if valid >= 3 {
@@ -238,7 +140,7 @@ impl Solution for Day16 {
         // Skip a line
         reader.read_line(&mut self.buf).unwrap();
 
-        let mut cpu: CPU = Default::default();
+        let mut cpu = CPU::new();
 
         while self.read(&mut reader, &mut op) {
             cpu.execute(mapping[op[0] as usize], &op[1..4]).unwrap();