e3b603872826f55fcb5623cfd64b7899e43365b4
[advent-of-code-2016.git] / aoc12 / src / main.rs
1 extern crate regex;
2 use regex::Regex;
3
4 use std::io::BufReader;
5 use std::io::prelude::*;
6 use std::fs::File;
7
8 enum Instruction {
9     CpyLit(i32, usize),
10     CpyReg(usize, usize),
11     Inc(usize),
12     Dec(usize),  
13     Jnz(usize, i32),
14     Jmp(i32),
15     Noop
16 }
17
18 impl Instruction {
19     fn parse(line: &str) -> Instruction {
20         let cpy_lit: Regex = Regex::new(r"cpy ([-\d]+) (a|b|c|d)").unwrap();
21         let cpy_reg = Regex::new(r"cpy (a|b|c|d) (a|b|c|d)").unwrap();
22         let inc = Regex::new(r"inc (a|b|c|d)").unwrap();
23         let dec = Regex::new(r"dec (a|b|c|d)").unwrap();
24         let jnz_lit = Regex::new(r"jnz ([-\d]+) ([-\d]+)").unwrap();
25         let jnz_reg = Regex::new(r"jnz (a|b|c|d) ([-\d]+)").unwrap();
26
27         if cpy_lit.is_match(line) {
28             let cap = cpy_lit.captures(line).unwrap();
29             let src: i32 = cap.at(1).unwrap().parse().unwrap();
30             let dest = to_register_index(cap.at(2).unwrap());
31             Instruction::CpyLit(src, dest)
32         }
33         else if cpy_reg.is_match(line) {
34             let cap = cpy_reg.captures(line).unwrap();
35             let src = to_register_index(cap.at(1).unwrap());
36             let dest = to_register_index(cap.at(2).unwrap());
37             Instruction::CpyReg(src, dest)
38         }
39         else if inc.is_match(line) {
40             let cap = inc.captures(line).unwrap();
41             let dest = to_register_index(cap.at(1).unwrap());
42             Instruction::Inc(dest)
43         }
44         else if dec.is_match(line) {
45             let cap = dec.captures(line).unwrap();
46             let dest = to_register_index(cap.at(1).unwrap());
47             Instruction::Dec(dest)
48         }
49         else if jnz_lit.is_match(line) {
50             let cap = jnz_lit.captures(line).unwrap();
51             let condition: i32 = cap.at(1).unwrap().parse().unwrap();
52             let offset: i32 = cap.at(2).unwrap().parse().unwrap();
53             if condition != 0 {
54                 Instruction::Jmp(offset)
55             }
56             else {
57                 Instruction::Noop
58             }
59         }
60         else if jnz_reg.is_match(line) {
61             let cap = jnz_reg.captures(line).unwrap();
62             let condition = to_register_index(cap.at(1).unwrap());
63             let offset: i32 = cap.at(2).unwrap().parse().unwrap();
64             Instruction::Jnz(condition, offset)
65         }
66         else {
67             panic!("Invalid instruction line")
68         }
69     }
70 }
71
72 fn main() {
73     let program = read_file();
74
75     let mut registers: [i32; 4] = [0, 0, 1, 0];
76     let mut pc: usize = 0;
77     
78     while pc < program.len() {
79         let mut pc_next: usize = pc+1;
80
81         match program[pc] {
82             Instruction::CpyLit(src, dest) => {
83                 registers[dest] = src;
84             },
85             Instruction::CpyReg(src, dest) => {
86                 registers[dest] = registers[src];
87             },
88             Instruction::Inc(dest) => {
89                 registers[dest] += 1;
90             },
91             Instruction::Dec(dest) => {
92                 registers[dest] -= 1;
93             },
94             Instruction::Jnz(condition, offset) => {
95                 if registers[condition] != 0 {
96                     pc_next = (pc as i32 + offset) as usize;
97                 }
98             },
99             Instruction::Jmp(offset) => {
100                 pc_next = (pc as i32 + offset) as usize
101             },
102             Instruction::Noop => {}
103         }
104
105         pc = pc_next;
106     }
107     
108     println!("a: {}, b: {}, c: {}, d: {}", registers[0], registers[1], registers[2], registers[3]);
109     
110 }
111
112 fn to_register_index(name: &str) -> usize {
113     match name {
114         "a" => 0,
115         "b" => 1,
116         "c" => 2,
117         "d" => 3,
118         _ => panic!("Invalid register provided")
119     }
120 }
121
122 fn read_file() -> Vec<Instruction> {
123     let file = BufReader::new(File::open("input.txt").unwrap());
124     file.lines()
125         .map(|line| line.unwrap())
126         .filter(|line| line.len() > 0)
127         .map(|line| Instruction::parse(line.trim()))
128         .collect()
129 }