day05 task 2

src/tasks/day05.rs

@@ -6,6 +6,7 @@ pub fn run() {
         .map(|s| s.parse::<i32>().unwrap())
         .collect();
     task1(ram.clone());
+    task2(ram.clone());
 }
 
 struct IntCodeComputer {
@@ -21,6 +22,10 @@ enum OpCode {
     Multiply,
     Input,
     Output,
+    JumpIfTrue,
+    JumpIfFalse,
+    LessThan,
+    Equals,
     Terminate,
 }
 
@@ -95,6 +100,36 @@ impl Op {
                 opcode: OpCode::Output,
                 params: vec![OpParam::from(memory[pc + 1], p_type3)],
             },
+            5 => Op {
+                opcode: OpCode::JumpIfTrue,
+                params: vec![
+                    OpParam::from(memory[pc + 1], p_type3),
+                    OpParam::from(memory[pc + 2], p_type2),
+                ],
+            },
+            6 => Op {
+                opcode: OpCode::JumpIfFalse,
+                params: vec![
+                    OpParam::from(memory[pc + 1], p_type3),
+                    OpParam::from(memory[pc + 2], p_type2),
+                ],
+            },
+            7 => Op {
+                opcode: OpCode::LessThan,
+                params: vec![
+                    OpParam::from(memory[pc + 1], p_type3),
+                    OpParam::from(memory[pc + 2], p_type2),
+                    OpParam::from(memory[pc + 3], p_type1),
+                ],
+            },
+            8 => Op {
+                opcode: OpCode::Equals,
+                params: vec![
+                    OpParam::from(memory[pc + 1], p_type3),
+                    OpParam::from(memory[pc + 2], p_type2),
+                    OpParam::from(memory[pc + 3], p_type1),
+                ],
+            },
             99 => Op {
                 opcode: OpCode::Terminate,
                 params: vec![],
@@ -138,6 +173,39 @@ impl IntCodeComputer {
                     self.output_storage.push(op.params[0].retrieve(&self.ram));
                     self.pc += 2;
                 }
+                OpCode::JumpIfTrue => {
+                    if op.params[0].retrieve(&self.ram) > 0 {
+                        self.pc = op.params[1].retrieve(&self.ram) as usize;
+                    } else {
+                        self.pc += 3;
+                    }
+                }
+                OpCode::JumpIfFalse => {
+                    if op.params[0].retrieve(&self.ram) == 0 {
+                        self.pc = op.params[1].retrieve(&self.ram) as usize;
+                    } else {
+                        self.pc += 3;
+                    }
+                }
+                OpCode::LessThan => {
+                    let r = if op.params[0].retrieve(&self.ram) < op.params[1].retrieve(&self.ram) {
+                        1
+                    } else {
+                        0
+                    };
+                    op.params[2].store(&mut self.ram, r);
+                    self.pc += 4;
+                }
+                OpCode::Equals => {
+                    let r = if op.params[0].retrieve(&self.ram) == op.params[1].retrieve(&self.ram)
+                    {
+                        1
+                    } else {
+                        0
+                    };
+                    op.params[2].store(&mut self.ram, r);
+                    self.pc += 4;
+                }
                 OpCode::Terminate => {}
             }
             op = Op::from(self.pc, &self.ram);
@@ -155,3 +223,10 @@ fn task1(ram: Vec<i32>) {
     println!("{:?}", computer.get_output());
     println!("Task 1: {}", computer.get_output().last().unwrap());
 }
+
+fn task2(ram: Vec<i32>) {
+    let mut computer = IntCodeComputer::new(vec![5], ram);
+    computer.run_until_end();
+    println!("{:?}", computer.get_output());
+    println!("Task 2: {}", computer.get_output().last().unwrap());
+}