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 }