day09 task 1

input/day09.txt

@@ -0,0 +1 @@
+1102,34463338,34463338,63,1007,63,34463338,63,1005,63,53,1102,1,3,1000,109,988,209,12,9,1000,209,6,209,3,203,0,1008,1000,1,63,1005,63,65,1008,1000,2,63,1005,63,904,1008,1000,0,63,1005,63,58,4,25,104,0,99,4,0,104,0,99,4,17,104,0,99,0,0,1101,0,0,1020,1101,34,0,1004,1101,0,26,1008,1102,1,37,1011,1101,39,0,1018,1102,587,1,1022,1101,1,0,1021,1102,22,1,1012,1101,0,33,1014,1101,24,0,1016,1101,0,752,1029,1101,36,0,1002,1101,35,0,1006,1101,32,0,1009,1102,38,1,1003,1102,584,1,1023,1101,0,20,1001,1102,892,1,1025,1102,29,1,1000,1101,411,0,1026,1102,1,901,1024,1101,0,761,1028,1101,23,0,1017,1102,30,1,1013,1101,0,27,1015,1102,28,1,1005,1101,408,0,1027,1101,25,0,1007,1102,31,1,1019,1101,0,21,1010,109,5,1207,-2,39,63,1005,63,199,4,187,1105,1,203,1001,64,1,64,1002,64,2,64,109,12,21102,40,1,-1,1008,1016,40,63,1005,63,229,4,209,1001,64,1,64,1106,0,229,1002,64,2,64,109,-5,1207,-5,24,63,1005,63,249,1001,64,1,64,1106,0,251,4,235,1002,64,2,64,109,-14,2102,1,6,63,1008,63,32,63,1005,63,271,1106,0,277,4,257,1001,64,1,64,1002,64,2,64,109,2,1202,1,1,63,1008,63,20,63,1005,63,303,4,283,1001,64,1,64,1106,0,303,1002,64,2,64,109,7,2108,34,2,63,1005,63,319,1106,0,325,4,309,1001,64,1,64,1002,64,2,64,109,6,2101,0,-6,63,1008,63,24,63,1005,63,349,1001,64,1,64,1105,1,351,4,331,1002,64,2,64,109,4,21107,41,42,0,1005,1017,369,4,357,1105,1,373,1001,64,1,64,1002,64,2,64,109,5,21101,42,0,-5,1008,1017,41,63,1005,63,397,1001,64,1,64,1106,0,399,4,379,1002,64,2,64,109,9,2106,0,-4,1106,0,417,4,405,1001,64,1,64,1002,64,2,64,109,-20,21108,43,43,0,1005,1011,435,4,423,1105,1,439,1001,64,1,64,1002,64,2,64,109,-15,2102,1,8,63,1008,63,34,63,1005,63,465,4,445,1001,64,1,64,1105,1,465,1002,64,2,64,109,3,1201,6,0,63,1008,63,28,63,1005,63,491,4,471,1001,64,1,64,1106,0,491,1002,64,2,64,109,18,21108,44,46,0,1005,1017,511,1001,64,1,64,1106,0,513,4,497,1002,64,2,64,109,12,1205,-8,527,4,519,1105,1,531,1001,64,1,64,1002,64,2,64,109,-17,1208,-3,32,63,1005,63,553,4,537,1001,64,1,64,1105,1,553,1002,64,2,64,109,-13,1208,10,31,63,1005,63,573,1001,64,1,64,1105,1,575,4,559,1002,64,2,64,109,17,2105,1,7,1105,1,593,4,581,1001,64,1,64,1002,64,2,64,109,-8,2107,19,-7,63,1005,63,615,4,599,1001,64,1,64,1105,1,615,1002,64,2,64,109,4,1206,8,629,4,621,1106,0,633,1001,64,1,64,1002,64,2,64,109,-2,2101,0,-6,63,1008,63,34,63,1005,63,655,4,639,1105,1,659,1001,64,1,64,1002,64,2,64,109,10,1205,0,671,1105,1,677,4,665,1001,64,1,64,1002,64,2,64,109,-21,2107,26,8,63,1005,63,693,1106,0,699,4,683,1001,64,1,64,1002,64,2,64,109,19,1201,-9,0,63,1008,63,30,63,1005,63,719,1105,1,725,4,705,1001,64,1,64,1002,64,2,64,109,9,1206,-6,741,1001,64,1,64,1106,0,743,4,731,1002,64,2,64,109,-5,2106,0,6,4,749,1001,64,1,64,1105,1,761,1002,64,2,64,109,-14,1202,-1,1,63,1008,63,27,63,1005,63,781,1105,1,787,4,767,1001,64,1,64,1002,64,2,64,109,1,21107,45,44,5,1005,1014,807,1001,64,1,64,1105,1,809,4,793,1002,64,2,64,109,8,21101,46,0,0,1008,1017,46,63,1005,63,835,4,815,1001,64,1,64,1106,0,835,1002,64,2,64,109,-26,2108,20,10,63,1005,63,857,4,841,1001,64,1,64,1106,0,857,1002,64,2,64,109,24,21102,47,1,-5,1008,1010,46,63,1005,63,881,1001,64,1,64,1106,0,883,4,863,1002,64,2,64,109,6,2105,1,3,4,889,1001,64,1,64,1105,1,901,4,64,99,21102,27,1,1,21101,915,0,0,1105,1,922,21201,1,29830,1,204,1,99,109,3,1207,-2,3,63,1005,63,964,21201,-2,-1,1,21101,0,942,0,1105,1,922,21202,1,1,-1,21201,-2,-3,1,21102,1,957,0,1105,1,922,22201,1,-1,-2,1105,1,968,21201,-2,0,-2,109,-3,2106,0,0

src/main.rs

@@ -1,5 +1,5 @@
 mod tasks;
 
 fn main() {
-    tasks::day05::run();
+    tasks::day09::run();
 }

src/tasks/day05.rs

@@ -1,19 +1,25 @@
+use std::collections::HashMap;
+
+pub type RAM = HashMap<usize, i128>;
+
 #[allow(dead_code)]
 pub fn run() {
     let input = std::fs::read_to_string("input/day05.txt").unwrap();
-    let ram: Vec<i32> = input
+    let ram: RAM = input
         .split(",")
-        .map(|s| s.parse::<i32>().unwrap())
+        .enumerate()
+        .map(|(i, s)| (i, s.parse::<i128>().unwrap()))
         .collect();
     task1(ram.clone());
     task2(ram.clone());
 }
 
 pub struct IntCodeComputer {
-    input_storage: Vec<i32>,
+    input_storage: Vec<i128>,
-    output_storage: Vec<i32>,
+    output_storage: Vec<i128>,
     pc: usize,
-    ram: Vec<i32>,
+    ram: RAM,
+    relative_base_offset: i128,
 }
 
 #[derive(PartialEq, Debug)]
@@ -26,35 +32,44 @@ enum OpCode {
     JumpIfFalse,
     LessThan,
     Equals,
+    AdjustRelBase,
     Terminate,
 }
 
 #[derive(Debug)]
 enum OpParam {
-    Immediate(i32),
+    Immediate(i128),
     Memory(usize),
+    Relative(i128),
 }
 
 impl OpParam {
-    fn from(val: i32, type_number: i32) -> Self {
+    fn from(val: i128, type_number: i128) -> Self {
         match type_number {
             0 => OpParam::Memory(val as usize),
             1 => OpParam::Immediate(val),
+            2 => OpParam::Relative(val),
             _ => unreachable!("unexpected parameter"),
         }
     }
 
-    fn retrieve(&self, memory: &Vec<i32>) -> i32 {
+    fn retrieve(&self, memory: &RAM, relative_base_offset: i128) -> i128 {
         match self {
             OpParam::Immediate(v) => *v,
-            OpParam::Memory(i) => memory[*i],
+            OpParam::Memory(i) => memory.get_default(*i),
+            OpParam::Relative(i) => memory.get_default((relative_base_offset + *i) as usize),
         }
     }
 
-    fn store(&self, memory: &mut Vec<i32>, value: i32) {
+    fn store(&self, memory: &mut RAM, value: i128, relative_base_offset: i128) {
         match self {
             OpParam::Immediate(_) => panic!("cannot save to immediate position"),
-            OpParam::Memory(i) => memory[*i] = value,
+            OpParam::Memory(i) => {
+                memory.insert(*i, value);
+            }
+            OpParam::Relative(i) => {
+                memory.insert((relative_base_offset + *i) as usize, value);
+            }
         }
     }
 }
@@ -66,9 +81,9 @@ struct Op {
 }
 
 impl Op {
-    fn from(pc: usize, memory: &Vec<i32>) -> Self {
+    fn from(pc: usize, memory: &RAM) -> Self {
         //opcode: 123xx -> 1, 2, 3: parameter type for parameters 1-3, xx = actual op code
-        let mut opcode = memory[pc];
+        let mut opcode = memory.get_default(pc);
         let p_type1 = opcode / 10_000;
         opcode %= 10_000;
         let p_type2 = opcode / 1000;
@@ -79,57 +94,61 @@ impl Op {
             1 => Op {
                 opcode: OpCode::Add,
                 params: vec![
-                    OpParam::from(memory[pc + 1], p_type3),
+                    OpParam::from(memory.get_default(pc + 1), p_type3),
-                    OpParam::from(memory[pc + 2], p_type2),
+                    OpParam::from(memory.get_default(pc + 2), p_type2),
-                    OpParam::from(memory[pc + 3], p_type1),
+                    OpParam::from(memory.get_default(pc + 3), p_type1),
                 ],
             },
             2 => Op {
                 opcode: OpCode::Multiply,
                 params: vec![
-                    OpParam::from(memory[pc + 1], p_type3),
+                    OpParam::from(memory.get_default(pc + 1), p_type3),
-                    OpParam::from(memory[pc + 2], p_type2),
+                    OpParam::from(memory.get_default(pc + 2), p_type2),
-                    OpParam::from(memory[pc + 3], p_type1),
+                    OpParam::from(memory.get_default(pc + 3), p_type1),
                 ],
             },
             3 => Op {
                 opcode: OpCode::Input,
-                params: vec![OpParam::from(memory[pc + 1], p_type3)],
+                params: vec![OpParam::from(memory.get_default(pc + 1), p_type3)],
             },
             4 => Op {
                 opcode: OpCode::Output,
-                params: vec![OpParam::from(memory[pc + 1], p_type3)],
+                params: vec![OpParam::from(memory.get_default(pc + 1), p_type3)],
             },
             5 => Op {
                 opcode: OpCode::JumpIfTrue,
                 params: vec![
-                    OpParam::from(memory[pc + 1], p_type3),
+                    OpParam::from(memory.get_default(pc + 1), p_type3),
-                    OpParam::from(memory[pc + 2], p_type2),
+                    OpParam::from(memory.get_default(pc + 2), p_type2),
                 ],
             },
             6 => Op {
                 opcode: OpCode::JumpIfFalse,
                 params: vec![
-                    OpParam::from(memory[pc + 1], p_type3),
+                    OpParam::from(memory.get_default(pc + 1), p_type3),
-                    OpParam::from(memory[pc + 2], p_type2),
+                    OpParam::from(memory.get_default(pc + 2), p_type2),
                 ],
             },
             7 => Op {
                 opcode: OpCode::LessThan,
                 params: vec![
-                    OpParam::from(memory[pc + 1], p_type3),
+                    OpParam::from(memory.get_default(pc + 1), p_type3),
-                    OpParam::from(memory[pc + 2], p_type2),
+                    OpParam::from(memory.get_default(pc + 2), p_type2),
-                    OpParam::from(memory[pc + 3], p_type1),
+                    OpParam::from(memory.get_default(pc + 3), p_type1),
                 ],
             },
             8 => Op {
                 opcode: OpCode::Equals,
                 params: vec![
-                    OpParam::from(memory[pc + 1], p_type3),
+                    OpParam::from(memory.get_default(pc + 1), p_type3),
-                    OpParam::from(memory[pc + 2], p_type2),
+                    OpParam::from(memory.get_default(pc + 2), p_type2),
-                    OpParam::from(memory[pc + 3], p_type1),
+                    OpParam::from(memory.get_default(pc + 3), p_type1),
                 ],
             },
+            9 => Op {
+                opcode: OpCode::AdjustRelBase,
+                params: vec![OpParam::from(memory.get_default(pc + 1), p_type3)],
+            },
             99 => Op {
                 opcode: OpCode::Terminate,
                 params: vec![],
@@ -140,12 +159,13 @@ impl Op {
 }
 
 impl IntCodeComputer {
-    pub fn new(input: Vec<i32>, memory: Vec<i32>) -> Self {
+    pub fn new(input: Vec<i128>, memory: RAM) -> Self {
         IntCodeComputer {
             input_storage: input,
             output_storage: Vec::new(),
             pc: 0,
             ram: memory,
+            relative_base_offset: 0,
         }
     }
 
@@ -164,60 +184,73 @@ impl IntCodeComputer {
         while op.opcode != OpCode::Terminate {
             match op.opcode {
                 OpCode::Add => {
-                    let r = op.params[0].retrieve(&self.ram) + op.params[1].retrieve(&self.ram);
+                    let r = op.params[0].retrieve(&self.ram, self.relative_base_offset)
-                    op.params[2].store(&mut self.ram, r);
+                        + op.params[1].retrieve(&self.ram, self.relative_base_offset);
+                    op.params[2].store(&mut self.ram, r, self.relative_base_offset);
                     self.pc += 4;
                 }
                 OpCode::Multiply => {
-                    let r = op.params[0].retrieve(&self.ram) * op.params[1].retrieve(&self.ram);
+                    let r = op.params[0].retrieve(&self.ram, self.relative_base_offset)
-                    op.params[2].store(&mut self.ram, r);
+                        * op.params[1].retrieve(&self.ram, self.relative_base_offset);
+                    op.params[2].store(&mut self.ram, r, self.relative_base_offset);
                     self.pc += 4;
                 }
                 OpCode::Input => {
                     if let Some(v) = inputs.next() {
-                        op.params[0].store(&mut self.ram, *v);
+                        op.params[0].store(&mut self.ram, *v, self.relative_base_offset);
                         self.pc += 2;
                     } else {
                         return false;
                     }
                 }
                 OpCode::Output => {
-                    self.output_storage.push(op.params[0].retrieve(&self.ram));
+                    self.output_storage
+                        .push(op.params[0].retrieve(&self.ram, self.relative_base_offset));
                     self.pc += 2;
                 }
                 OpCode::JumpIfTrue => {
-                    if op.params[0].retrieve(&self.ram) > 0 {
+                    if op.params[0].retrieve(&self.ram, self.relative_base_offset) > 0 {
-                        self.pc = op.params[1].retrieve(&self.ram) as usize;
+                        self.pc =
+                            op.params[1].retrieve(&self.ram, self.relative_base_offset) as usize;
                     } else {
                         self.pc += 3;
                     }
                 }
                 OpCode::JumpIfFalse => {
-                    if op.params[0].retrieve(&self.ram) == 0 {
+                    if op.params[0].retrieve(&self.ram, self.relative_base_offset) == 0 {
-                        self.pc = op.params[1].retrieve(&self.ram) as usize;
+                        self.pc =
+                            op.params[1].retrieve(&self.ram, self.relative_base_offset) as usize;
                     } else {
                         self.pc += 3;
                     }
                 }
                 OpCode::LessThan => {
-                    let r = if op.params[0].retrieve(&self.ram) < op.params[1].retrieve(&self.ram) {
+                    let r = if op.params[0].retrieve(&self.ram, self.relative_base_offset)
-                        1
+                        < op.params[1].retrieve(&self.ram, self.relative_base_offset)
-                    } 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);
+                    op.params[2].store(&mut self.ram, r, self.relative_base_offset);
                     self.pc += 4;
                 }
+                OpCode::Equals => {
+                    let r = if op.params[0].retrieve(&self.ram, self.relative_base_offset)
+                        == op.params[1].retrieve(&self.ram, self.relative_base_offset)
+                    {
+                        1
+                    } else {
+                        0
+                    };
+                    op.params[2].store(&mut self.ram, r, self.relative_base_offset);
+                    self.pc += 4;
+                }
+                OpCode::AdjustRelBase => {
+                    self.relative_base_offset +=
+                        op.params[0].retrieve(&self.ram, self.relative_base_offset);
+                    self.pc += 2;
+                }
                 OpCode::Terminate => {}
             }
             op = Op::from(self.pc, &self.ram);
@@ -225,7 +258,7 @@ impl IntCodeComputer {
         return true;
     }
 
-    pub fn set_input(&mut self, input: &[i32]) {
+    pub fn set_input(&mut self, input: &[i128]) {
         self.input_storage.clear();
         for x in input {
             self.input_storage.push(*x);
@@ -236,21 +269,31 @@ impl IntCodeComputer {
         self.output_storage.clear();
     }
 
-    pub fn get_output(&self) -> &[i32] {
+    pub fn get_output(&self) -> &[i128] {
         self.output_storage.as_slice()
     }
 }
 
-fn task1(ram: Vec<i32>) {
+fn task1(ram: RAM) {
     let mut computer = IntCodeComputer::new(vec![1], ram);
     computer.run_until_end();
     println!("{:?}", computer.get_output());
     println!("Task 1: {}", computer.get_output().last().unwrap());
 }
 
-fn task2(ram: Vec<i32>) {
+fn task2(ram: RAM) {
     let mut computer = IntCodeComputer::new(vec![5], ram);
     computer.run_until_end();
     println!("{:?}", computer.get_output());
     println!("Task 2: {}", computer.get_output().last().unwrap());
 }
+
+trait Easy {
+    fn get_default(&self, index: usize) -> i128;
+}
+
+impl Easy for RAM {
+    fn get_default(&self, index: usize) -> i128 {
+        **self.get(&index).get_or_insert(&0)
+    }
+}

src/tasks/day07.rs

@@ -6,20 +6,23 @@ pub fn run() {
     let prog_code: Vec<_> = std::fs::read_to_string("input/day07.txt")
         .unwrap()
         .split(",")
-        .map(|s| s.parse::<i32>().unwrap())
+        .map(|s| s.parse::<i128>().unwrap())
         .collect();
     task1(prog_code.clone());
     task2(prog_code.clone());
 }
 
-fn task1(input: Vec<i32>) {
+fn task1(input: Vec<i128>) {
     let phases = vec![0, 1, 2, 3, 4];
     let result = phases
         .iter()
         .permutations(phases.len())
         .map(|perm| {
             perm.iter().fold(0, |signal, phase| {
-                let mut computer = IntCodeComputer::new(vec![**phase, signal], input.clone());
+                let mut computer = IntCodeComputer::new(
+                    vec![**phase, signal],
+                    input.clone().into_iter().enumerate().collect(),
+                );
                 computer.run_until_end();
                 *computer.get_output().last().unwrap()
             })
@@ -28,7 +31,7 @@ fn task1(input: Vec<i32>) {
     println!("Task 1: best signal is {}", result.unwrap());
 }
 
-fn task2(input: Vec<i32>) {
+fn task2(input: Vec<i128>) {
     let phases = vec![5, 6, 7, 8, 9];
     let result = phases
         .iter()
@@ -37,7 +40,10 @@ fn task2(input: Vec<i32>) {
             let mut machines: Vec<IntCodeComputer> = perm
                 .iter()
                 .map(|phase| {
-                    let mut comp = IntCodeComputer::new(vec![**phase], input.clone());
+                    let mut comp = IntCodeComputer::new(
+                        vec![**phase],
+                        input.clone().into_iter().enumerate().collect(),
+                    );
                     comp.run_until_input_empty();
                     comp
                 })

src/tasks/day09.rs

@@ -0,0 +1,18 @@
+use super::day05::{IntCodeComputer, RAM};
+
+pub fn run() {
+    let input = std::fs::read_to_string("input/day09.txt").unwrap();
+    let ram: RAM = input
+        .split(",")
+        .enumerate()
+        .map(|(i, s)| (i, s.parse::<i128>().unwrap()))
+        .collect();
+    task1(ram.clone());
+}
+
+fn task1(ram: RAM) {
+    let mut computer = IntCodeComputer::new(vec![1], ram);
+    computer.run_until_end();
+    println!("{:?}", computer.get_output());
+    println!("Task 1: {}", computer.get_output().last().unwrap());
+}

src/tasks/mod.rs

@@ -5,3 +5,4 @@ pub mod day05;
 pub mod day06;
 pub mod day07;
 pub mod day08;
+pub mod day09;