2016/25
This commit is contained in:
300
2016/25/src/main.rs
Normal file
300
2016/25/src/main.rs
Normal file
@@ -0,0 +1,300 @@
|
||||
#[macro_use] extern crate lazy_static;
|
||||
extern crate regex;
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::str::FromStr;
|
||||
use std::io::{self, BufRead};
|
||||
use std::i64;
|
||||
|
||||
use regex::Regex;
|
||||
|
||||
|
||||
type Register = String;
|
||||
type Value = i64;
|
||||
|
||||
|
||||
#[derive(Debug, PartialEq, Clone)]
|
||||
pub enum Input {
|
||||
Value(Value),
|
||||
Register(Register)
|
||||
}
|
||||
|
||||
impl FromStr for Input {
|
||||
type Err = ();
|
||||
|
||||
fn from_str(s: &str) -> Result<Input, Self::Err> {
|
||||
if let Ok(value) = s.parse::<Value>() {
|
||||
return Ok(Input::Value(value));
|
||||
}
|
||||
|
||||
if let Ok(register) = s.parse::<Register>() {
|
||||
return Ok(Input::Register(register));
|
||||
}
|
||||
|
||||
Err(())
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#[derive(Debug, PartialEq, Clone)]
|
||||
pub enum Operation {
|
||||
Cpy(Input, Register),
|
||||
Inc(Register),
|
||||
Dec(Register),
|
||||
Jnz(Input, Input),
|
||||
Tgl(Register),
|
||||
Out(Input)
|
||||
}
|
||||
|
||||
impl FromStr for Operation {
|
||||
type Err = ();
|
||||
|
||||
fn from_str(s: &str) -> Result<Operation, Self::Err> {
|
||||
lazy_static! {
|
||||
static ref CPY: Regex = Regex::new(r"^cpy ([a-z]|-?\d+) ([a-z])$").unwrap();
|
||||
static ref INC: Regex = Regex::new(r"^inc ([a-z])$").unwrap();
|
||||
static ref DEC: Regex = Regex::new(r"^dec ([a-z])$").unwrap();
|
||||
static ref JNZ: Regex = Regex::new(r"^jnz ([a-z]|-?\d+) ([a-z]|-?\d+)$").unwrap();
|
||||
static ref TGL: Regex = Regex::new(r"^tgl ([a-z]+)$").unwrap();
|
||||
static ref OUT: Regex = Regex::new(r"^out ([a-z]|-?\d+)$").unwrap();
|
||||
}
|
||||
|
||||
if let Some(caps) = CPY.captures(s) {
|
||||
let input = caps.at(1).unwrap().parse::<Input>().unwrap();
|
||||
let register = caps.at(2).unwrap().parse::<Register>().unwrap();
|
||||
|
||||
return Ok(Operation::Cpy(input, register));
|
||||
}
|
||||
|
||||
if let Some(caps) = INC.captures(s) {
|
||||
let register = caps.at(1).unwrap().parse::<Register>().unwrap();
|
||||
|
||||
return Ok(Operation::Inc(register));
|
||||
}
|
||||
|
||||
if let Some(caps) = DEC.captures(s) {
|
||||
let register = caps.at(1).unwrap().parse::<Register>().unwrap();
|
||||
|
||||
return Ok(Operation::Dec(register));
|
||||
}
|
||||
|
||||
if let Some(caps) = JNZ.captures(s) {
|
||||
let input = caps.at(1).unwrap().parse::<Input>().unwrap();
|
||||
let delta = caps.at(2).unwrap().parse::<Input>().unwrap();
|
||||
|
||||
return Ok(Operation::Jnz(input, delta));
|
||||
}
|
||||
|
||||
if let Some(caps) = TGL.captures(s) {
|
||||
let register = caps.at(1).unwrap().parse::<Register>().unwrap();
|
||||
|
||||
return Ok(Operation::Tgl(register));
|
||||
}
|
||||
|
||||
if let Some(caps) = OUT.captures(s) {
|
||||
let value = caps.at(1).unwrap().parse::<Input>().unwrap();
|
||||
|
||||
return Ok(Operation::Out(value));
|
||||
}
|
||||
|
||||
Err(())
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct CPU {
|
||||
pc: usize,
|
||||
reg: HashMap<Register, Value>,
|
||||
output: Vec<Value>,
|
||||
rom: Vec<Operation>
|
||||
}
|
||||
|
||||
impl CPU {
|
||||
pub fn new() -> Self {
|
||||
CPU {
|
||||
pc: 0,
|
||||
reg: HashMap::new(),
|
||||
output: Vec::new(),
|
||||
rom: Vec::new()
|
||||
}
|
||||
}
|
||||
|
||||
pub fn load(&mut self, input: Vec<Operation>) {
|
||||
self.rom = input;
|
||||
}
|
||||
|
||||
pub fn clear(&mut self) {
|
||||
self.pc = 0;
|
||||
self.reg.clear();
|
||||
self.output.clear();
|
||||
}
|
||||
|
||||
pub fn execute(&mut self) {
|
||||
loop {
|
||||
if let Err(()) = self.step() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn step(&mut self) -> Result<(), ()> {
|
||||
if self.pc >= self.rom.len() {
|
||||
return Err(());
|
||||
}
|
||||
|
||||
let mut swap = None;
|
||||
|
||||
match self.rom[self.pc] {
|
||||
Operation::Cpy(ref value, ref register) => {
|
||||
let input = match value {
|
||||
&Input::Value(value) => {
|
||||
value
|
||||
}
|
||||
&Input::Register(ref register) => {
|
||||
*self.reg.entry(register.clone()).or_insert(0)
|
||||
}
|
||||
};
|
||||
|
||||
*self.reg.entry(register.clone()).or_insert(0) = input;
|
||||
|
||||
self.pc += 1;
|
||||
}
|
||||
Operation::Inc(ref register) => {
|
||||
*self.reg.entry(register.clone()).or_insert(0) += 1;
|
||||
|
||||
self.pc += 1;
|
||||
}
|
||||
Operation::Dec(ref register) => {
|
||||
*self.reg.entry(register.clone()).or_insert(0) -= 1;
|
||||
|
||||
self.pc += 1;
|
||||
}
|
||||
Operation::Jnz(ref value, ref delta) => {
|
||||
let input = match value {
|
||||
&Input::Value(value) => {
|
||||
value
|
||||
}
|
||||
&Input::Register(ref register) => {
|
||||
*self.reg.entry(register.clone()).or_insert(0)
|
||||
}
|
||||
};
|
||||
|
||||
let delta = match delta {
|
||||
&Input::Value(value) => {
|
||||
value
|
||||
}
|
||||
&Input::Register(ref register) => {
|
||||
*self.reg.entry(register.clone()).or_insert(0)
|
||||
}
|
||||
};
|
||||
|
||||
if input != 0 {
|
||||
self.pc = ((self.pc as i64) + delta) as usize;
|
||||
} else {
|
||||
self.pc += 1;
|
||||
}
|
||||
}
|
||||
Operation::Tgl(ref register) => {
|
||||
let index = self.pc as i64 + *self.reg.entry(register.clone()).or_insert(0);
|
||||
|
||||
if index >= 0 && index < self.rom.len() as i64 {
|
||||
swap = match &self.rom[index as usize] {
|
||||
&Operation::Inc(ref register) => {
|
||||
Some((index as usize, Operation::Dec(register.clone())))
|
||||
}
|
||||
&Operation::Dec(ref register) => {
|
||||
Some((index as usize, Operation::Inc(register.clone())))
|
||||
}
|
||||
&Operation::Tgl(ref register) => {
|
||||
Some((index as usize, Operation::Inc(register.clone())))
|
||||
}
|
||||
&Operation::Jnz(ref value, ref delta) => {
|
||||
if let &Input::Register(ref register) = delta {
|
||||
Some((index as usize, Operation::Cpy(value.clone(), register.clone())))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
&Operation::Cpy(ref value, ref register) => {
|
||||
Some((index as usize, Operation::Jnz(value.clone(), Input::Register(register.clone()))))
|
||||
}
|
||||
&Operation::Out(_) => {
|
||||
None
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
self.pc += 1;
|
||||
}
|
||||
Operation::Out(ref value) => {
|
||||
let value = match value {
|
||||
&Input::Value(value) => {
|
||||
value
|
||||
}
|
||||
&Input::Register(ref register) => {
|
||||
*self.reg.entry(register.clone()).or_insert(0)
|
||||
}
|
||||
};
|
||||
|
||||
self.output.push(value);
|
||||
|
||||
self.pc += 1;
|
||||
}
|
||||
}
|
||||
|
||||
if let Some((pc, swap)) = swap {
|
||||
self.rom[pc] = swap;
|
||||
}
|
||||
|
||||
return Ok(());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
fn main() {
|
||||
let stdin = io::stdin();
|
||||
|
||||
let operations = stdin.lock().lines()
|
||||
.filter_map(|x| x.ok())
|
||||
.map(|line| line.parse::<Operation>().unwrap())
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
// Part 1.
|
||||
let mut cpu = CPU::new();
|
||||
|
||||
cpu.load(operations.clone());
|
||||
|
||||
'main: for i in 0..i64::MAX {
|
||||
cpu.clear();
|
||||
cpu.reg.entry("a".to_owned()).or_insert(i);
|
||||
|
||||
while cpu.output.len() < 100_000 {
|
||||
let _ = cpu.step();
|
||||
|
||||
if cpu.output.len() > 0 {
|
||||
let last = cpu.output.last().unwrap();
|
||||
|
||||
if *last != (cpu.output.len() - 1) as i64 % 2 {
|
||||
continue 'main;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
println!("a={:#?}", i);
|
||||
println!("{:#?}", cpu.reg);
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn parse_jnz() {
|
||||
assert_eq!(Ok(Operation::Jnz(Input::Register("c".to_owned()), -2)), "jnz c -2".parse::<Operation>());
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user