diff options
author | Justin Wernick <justin@worthe-it.co.za> | 2019-12-11 23:02:42 +0200 |
---|---|---|
committer | Justin Wernick <justin@worthe-it.co.za> | 2019-12-11 23:02:42 +0200 |
commit | 003a62f1c38344c5a647170bd2472c4eab39cf75 (patch) | |
tree | 1e32598b23b10d5ab9be1b8c65f6e3493f29b3d1 /src/lib.rs | |
parent | ad526abdd30e3495024b62e79f9fa0dc81cec613 (diff) |
Intcode program into lib! It's shared code now.
Diffstat (limited to 'src/lib.rs')
-rw-r--r-- | src/lib.rs | 246 |
1 files changed, 246 insertions, 0 deletions
diff --git a/src/lib.rs b/src/lib.rs new file mode 100644 index 0000000..2591a54 --- /dev/null +++ b/src/lib.rs @@ -0,0 +1,246 @@ +use rpds::{list::List, vector::Vector}; +use std::fmt; +use std::iter; +use std::iter::FromIterator; +use std::iter::IntoIterator; + +pub type Intcode = i32; + +#[derive(Debug, Clone)] +pub struct IntcodeProgram { + instruction_pointer: usize, + error: bool, + halted: bool, + memory: Vector<Intcode>, + input: List<Intcode>, + output: Vector<Intcode>, +} + +impl FromIterator<Intcode> for IntcodeProgram { + fn from_iter<I: IntoIterator<Item = Intcode>>(iter: I) -> Self { + IntcodeProgram { + instruction_pointer: 0, + error: false, + halted: false, + memory: iter.into_iter().collect(), + input: List::new(), + output: Vector::new(), + } + } +} + +impl IntcodeProgram { + pub fn with_noun_verb_input(&self, noun: Intcode, verb: Intcode) -> IntcodeProgram { + self.with_memory_set(1, noun).with_memory_set(2, verb) + } + + pub fn with_input(&self, input: List<Intcode>) -> IntcodeProgram { + IntcodeProgram { + input, + ..self.clone() + } + } + + pub fn execute(&self) -> Result<Vector<Intcode>, IntcodeProgramError> { + self.run_to_termination().output_into_result() + } + + pub fn execute_returning_memory_0(&self) -> Result<Option<Intcode>, IntcodeProgramError> { + self.run_to_termination().memory_0_into_result() + } + + fn with_instruction_pointer(&self, instruction_pointer: usize) -> IntcodeProgram { + IntcodeProgram { + instruction_pointer, + ..self.clone() + } + } + + fn with_instruction_pointer_offset(&self, offset: usize) -> IntcodeProgram { + IntcodeProgram { + instruction_pointer: self.instruction_pointer + offset, + ..self.clone() + } + } + + fn with_memory_set(&self, address: usize, value: Intcode) -> IntcodeProgram { + self.memory + .set(address, value) + .map(|memory| IntcodeProgram { + memory, + ..self.clone() + }) + .unwrap_or(self.error()) + } + + fn with_input_consumed(&self) -> IntcodeProgram { + self.input + .drop_first() + .map(|input| IntcodeProgram { + input, + ..self.clone() + }) + .unwrap_or(self.error()) + } + + fn with_output(&self, print: Intcode) -> IntcodeProgram { + IntcodeProgram { + output: self.output.push_back(print), + ..self.clone() + } + } + + fn output_into_result(&self) -> Result<Vector<Intcode>, IntcodeProgramError> { + if self.error { + Err(IntcodeProgramError) + } else { + Ok(self.output.clone()) + } + } + + fn memory_0_into_result(&self) -> Result<Option<Intcode>, IntcodeProgramError> { + if self.error { + Err(IntcodeProgramError) + } else { + Ok(self.memory.get(0).cloned()) + } + } + + fn run_to_termination(&self) -> IntcodeProgram { + iter::successors(Some(self.clone()), |p| Some(IntcodeProgram::next(&p))) + .find(|p| p.halted) + .unwrap() // successors doesn't terminate, so this will never be none. + } + + fn next(&self) -> IntcodeProgram { + //eprintln!("{:?}", self); + self.memory + .get(self.instruction_pointer) + .map(|&opcode| match opcode % 100 { + 1 => self.add(opcode), + 2 => self.multiply(opcode), + 3 => self.input(opcode), + 4 => self.output(opcode), + 5 => self.jump_if_true(opcode), + 6 => self.jump_if_false(opcode), + 7 => self.less_than(opcode), + 8 => self.equals(opcode), + 99 => self.halt(), + _ => self.error(), + }) + .unwrap_or(self.error()) + } + + fn add(&self, mode: Intcode) -> IntcodeProgram { + match (self.get(1, mode), self.get(2, mode), self.get_immediate(3)) { + (Some(in1), Some(in2), Some(out)) => self + .with_instruction_pointer_offset(4) + .with_memory_set(out as usize, in1 + in2), + _ => self.error(), + } + } + + fn multiply(&self, mode: Intcode) -> IntcodeProgram { + match (self.get(1, mode), self.get(2, mode), self.get_immediate(3)) { + (Some(in1), Some(in2), Some(out)) => self + .with_instruction_pointer_offset(4) + .with_memory_set(out as usize, in1 * in2), + _ => self.error(), + } + } + + fn input(&self, _mode: Intcode) -> IntcodeProgram { + match (self.input.first().cloned(), self.get_immediate(1)) { + (Some(input), Some(out)) => self + .with_instruction_pointer_offset(2) + .with_memory_set(out as usize, input) + .with_input_consumed(), + _ => self.error(), + } + } + + fn output(&self, mode: Intcode) -> IntcodeProgram { + match self.get(1, mode) { + Some(print) => self.with_instruction_pointer_offset(2).with_output(print), + _ => self.error(), + } + } + + fn jump_if_true(&self, mode: Intcode) -> IntcodeProgram { + match (self.get(1, mode), self.get(2, mode)) { + (Some(pred), Some(to)) if pred != 0 => self.with_instruction_pointer(to as usize), + (Some(_), Some(_)) => self.with_instruction_pointer_offset(3), + _ => self.error(), + } + } + fn jump_if_false(&self, mode: Intcode) -> IntcodeProgram { + match (self.get(1, mode), self.get(2, mode)) { + (Some(pred), Some(to)) if pred == 0 => self.with_instruction_pointer(to as usize), + (Some(_), Some(_)) => self.with_instruction_pointer_offset(3), + _ => self.error(), + } + } + + fn less_than(&self, mode: Intcode) -> IntcodeProgram { + match (self.get(1, mode), self.get(2, mode), self.get_immediate(3)) { + (Some(in1), Some(in2), Some(out)) => self + .with_instruction_pointer_offset(4) + .with_memory_set(out as usize, if in1 < in2 { 1 } else { 0 }), + _ => self.error(), + } + } + + fn equals(&self, mode: Intcode) -> IntcodeProgram { + match (self.get(1, mode), self.get(2, mode), self.get_immediate(3)) { + (Some(in1), Some(in2), Some(out)) => self + .with_instruction_pointer_offset(4) + .with_memory_set(out as usize, if in1 == in2 { 1 } else { 0 }), + _ => self.error(), + } + } + + fn halt(&self) -> IntcodeProgram { + IntcodeProgram { + halted: true, + ..self.clone() + } + } + + fn error(&self) -> IntcodeProgram { + IntcodeProgram { + halted: true, + error: true, + ..self.clone() + } + } + + fn get(&self, pointer_offset: usize, mode: Intcode) -> Option<Intcode> { + match mode / (10 as Intcode).pow(pointer_offset as u32 + 1) % 10 { + 0 => self.get_position(pointer_offset), + 1 => self.get_immediate(pointer_offset), + _ => None, + } + } + + fn get_immediate(&self, pointer_offset: usize) -> Option<Intcode> { + self.memory + .get(self.instruction_pointer + pointer_offset) + .cloned() + } + + fn get_position(&self, pointer_offset: usize) -> Option<Intcode> { + self.get_immediate(pointer_offset) + .and_then(|r| self.memory.get(r as usize)) + .cloned() + } +} + +#[derive(Debug, PartialEq)] +pub struct IntcodeProgramError; + +impl fmt::Display for IntcodeProgramError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "Unknown error") + } +} +impl std::error::Error for IntcodeProgramError {} |