Add solutions to day 12.

Assembunny was fun.

2016/day-12/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "day-12"
+version = "0.1.0"
+authors = ["Bert Peters <bert.ljpeters@gmail.com>"]
+
+[dependencies]

2016/day-12/input.txt

@@ -0,0 +1,23 @@
+cpy 1 a
+cpy 1 b
+cpy 26 d
+jnz c 2
+jnz 1 5
+cpy 7 c
+inc d
+dec c
+jnz c -2
+cpy a c
+inc a
+dec b
+jnz b -2
+cpy c b
+dec d
+jnz d -6
+cpy 16 c
+cpy 12 d
+inc a
+dec d
+jnz d -2
+dec c
+jnz c -5

2016/day-12/src/main.rs

@@ -0,0 +1,81 @@
+use std::env;
+use std::io::prelude::*;
+use std::fs::File;
+use std::io::BufReader;
+
+fn register_num(value: &str) -> Option<usize>
+{
+    match value {
+        "a" => Some(0),
+        "b" => Some(1),
+        "c" => Some(2),
+        "d" => Some(3),
+        _ => None,
+    }
+}
+
+fn get_value(value: &str, registers: &[i32; 4]) -> i32
+{
+    match register_num(value) {
+        Some(num) => registers[num],
+        _ => value.parse().unwrap(),
+    }
+}
+
+fn run(program: &Vec<Vec<String>>, mut registers: [i32; 4]) -> [i32; 4]
+{
+    let mut iptr: i32 = 0;
+
+    while iptr < program.len() as i32 {
+        let ref instruction = program[iptr as usize];
+        //println!("{} ({:?}): {:?}", iptr, registers, instruction);
+        match instruction[0].as_ref() {
+            "cpy" => {
+                let val = get_value(&instruction[1], &registers);
+                let dest = register_num(&instruction[2]).unwrap();
+                registers[dest] = val;
+            },
+            "jnz" => {
+                let val = get_value(&instruction[1], &registers);
+                if val != 0 {
+                    let jump: i32 = instruction[2].parse().unwrap();
+                    iptr += jump;
+                    continue;
+                }
+            },
+            "inc" => {
+                let dest = register_num(&instruction[1]).unwrap();
+                registers[dest] += 1;
+            },
+            "dec" => {
+                let dest = register_num(&instruction[1]).unwrap();
+                registers[dest] -= 1;
+            },
+            _ => panic!("Invalid instruction: {:?}", instruction),
+        }
+        iptr += 1;
+    }
+
+    return registers;
+}
+
+fn main() {
+    let args: Vec<String> = env::args().collect();
+    let f = File::open(&args[1]).expect("Could not open file");
+    let reader = BufReader::new(f);
+
+    let mut program = Vec::new();
+
+    for line in reader.lines() {
+        let contents = line.unwrap();
+        let parts: Vec<String> = contents.split(" ").map(|part| String::from(part)).collect();
+
+        program.push(parts);
+    }
+
+    let result1 = run(&program, [0; 4]);
+    println!("Run 1: register a contains {}", result1[0]);
+
+    let result2 = run(&program, [0, 0, 1, 0]);
+    println!("Run 2: register a contains {}", result2[0]);
+}