Better regexes
[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         let cpy_lit_match = cpy_lit.captures(line);
28         let cpy_reg_match = cpy_reg.captures(line);
29         let inc_match = inc.captures(line);
30         let dec_match = dec.captures(line);
31         let jnz_lit_match = jnz_lit.captures(line);
32         let jnz_reg_match = jnz_reg.captures(line);
33         
34         if cpy_lit_match.is_some() {
35             let cap = cpy_lit_match.unwrap();
36             let src: i32 = cap.at(1).unwrap().parse().unwrap();
37             let dest = to_register_index(cap.at(2).unwrap());
38             Instruction::CpyLit(src, dest)
39         }
40         else if cpy_reg_match.is_some() {
41             let cap = cpy_reg_match.unwrap();
42             let src = to_register_index(cap.at(1).unwrap());
43             let dest = to_register_index(cap.at(2).unwrap());
44             Instruction::CpyReg(src, dest)
45         }
46         else if inc_match.is_some() {
47             let cap = inc_match.unwrap();
48             let dest = to_register_index(cap.at(1).unwrap());
49             Instruction::Inc(dest)
50         }
51         else if dec_match.is_some() {
52             let cap = dec_match.unwrap();
53             let dest = to_register_index(cap.at(1).unwrap());
54             Instruction::Dec(dest)
55         }
56         else if jnz_lit_match.is_some() {
57             let cap = jnz_lit_match.unwrap();
58             let condition: i32 = cap.at(1).unwrap().parse().unwrap();
59             let offset: i32 = cap.at(2).unwrap().parse().unwrap();
60             if condition != 0 {
61                 Instruction::Jmp(offset)
62             }
63             else {
64                 Instruction::Noop
65             }
66         }
67         else if jnz_reg_match.is_some() {
68             let cap = jnz_reg_match.unwrap();
69             let condition = to_register_index(cap.at(1).unwrap());
70             let offset: i32 = cap.at(2).unwrap().parse().unwrap();
71             Instruction::Jnz(condition, offset)
72         }
73         else {
74             panic!("Invalid instruction line")
75         }
76     }
77 }
78
79 fn main() {
80     let program = read_file();
81
82     let mut registers: [i32; 4] = [0, 0, 1, 0];
83     let mut pc: usize = 0;
84     
85     while pc < program.len() {
86         let mut pc_next: usize = pc+1;
87
88         match program[pc] {
89             Instruction::CpyLit(src, dest) => {
90                 registers[dest] = src;
91             },
92             Instruction::CpyReg(src, dest) => {
93                 registers[dest] = registers[src];
94             },
95             Instruction::Inc(dest) => {
96                 registers[dest] += 1;
97             },
98             Instruction::Dec(dest) => {
99                 registers[dest] -= 1;
100             },
101             Instruction::Jnz(condition, offset) => {
102                 if registers[condition] != 0 {
103                     pc_next = (pc as i32 + offset) as usize;
104                 }
105             },
106             Instruction::Jmp(offset) => {
107                 pc_next = (pc as i32 + offset) as usize
108             },
109             Instruction::Noop => {}
110         }
111
112         pc = pc_next;
113     }
114     
115     println!("a: {}, b: {}, c: {}, d: {}", registers[0], registers[1], registers[2], registers[3]);
116     
117 }
118
119 fn to_register_index(name: &str) -> usize {
120     match name {
121         "a" => 0,
122         "b" => 1,
123         "c" => 2,
124         "d" => 3,
125         _ => panic!("Invalid register provided")
126     }
127 }
128
129 fn read_file() -> Vec<Instruction> {
130     let file = BufReader::new(File::open("input.txt").unwrap());
131     file.lines()
132         .map(|line| line.unwrap())
133         .filter(|line| line.len() > 0)
134         .map(|line| Instruction::parse(line.trim()))
135         .collect()
136 }