|
@@ -12,9 +12,10 @@ type Result<T> = result::Result<T, Box<dyn Error>>;
|
12
|
12
|
|
13
|
13
|
#[derive(Debug, Clone, PartialEq)]
|
14
|
14
|
pub struct Intcode {
|
15
|
|
- pub integers: HashMap<usize, i32>,
|
|
15
|
+ pub integers: HashMap<usize, i64>,
|
16
|
16
|
pub pointer: usize,
|
17
|
17
|
pub halted: bool,
|
|
18
|
+ pub relative_base: i64,
|
18
|
19
|
}
|
19
|
20
|
|
20
|
21
|
#[derive(Debug, PartialEq)]
|
|
@@ -23,25 +24,18 @@ pub struct Instruction {
|
23
|
24
|
parameter_modes: Vec<ParameterMode>,
|
24
|
25
|
}
|
25
|
26
|
|
26
|
|
-impl TryFrom<i32> for Instruction {
|
|
27
|
+impl TryFrom<i64> for Instruction {
|
27
|
28
|
type Error = Box<dyn Error>;
|
28
|
29
|
|
29
|
|
- fn try_from(integer: i32) -> Result<Self> {
|
|
30
|
+ fn try_from(integer: i64) -> Result<Self> {
|
30
|
31
|
let opcode: Opcode = Opcode::try_from((integer % 100) as u8)?;
|
31
|
32
|
let modes_integer = integer / 100;
|
32
|
33
|
let mut parameter_modes = vec![];
|
33
|
34
|
for parameter_index in 0..opcode.parameter_count() {
|
34
|
|
- parameter_modes.push(match opcode.target_parameter_index() {
|
35
|
|
- Some(target_parameter_index)
|
36
|
|
- if target_parameter_index == parameter_index as usize =>
|
37
|
|
- {
|
38
|
|
- ParameterMode::Position
|
39
|
|
- }
|
40
|
|
- _ => ParameterMode::try_from(
|
41
|
|
- (modes_integer % (10_i32.pow(parameter_index + 1))
|
42
|
|
- / 10_i32.pow(parameter_index)) as u8,
|
43
|
|
- )?,
|
44
|
|
- })
|
|
35
|
+ parameter_modes.push(ParameterMode::try_from(
|
|
36
|
+ (modes_integer % (10_i64.pow(parameter_index + 1)) / 10_i64.pow(parameter_index))
|
|
37
|
+ as u8,
|
|
38
|
+ )?)
|
45
|
39
|
}
|
46
|
40
|
Ok(Instruction {
|
47
|
41
|
opcode,
|
|
@@ -61,6 +55,7 @@ pub enum Opcode {
|
61
|
55
|
JumpIfFalse = 6,
|
62
|
56
|
LessThan = 7,
|
63
|
57
|
Equals = 8,
|
|
58
|
+ RelativeBaseOffset = 9,
|
64
|
59
|
Halt = 99,
|
65
|
60
|
}
|
66
|
61
|
|
|
@@ -75,6 +70,7 @@ impl Opcode {
|
75
|
70
|
Opcode::JumpIfFalse => 2,
|
76
|
71
|
Opcode::LessThan => 3,
|
77
|
72
|
Opcode::Equals => 3,
|
|
73
|
+ Opcode::RelativeBaseOffset => 1,
|
78
|
74
|
Opcode::Halt => 0,
|
79
|
75
|
}
|
80
|
76
|
}
|
|
@@ -89,6 +85,7 @@ impl Opcode {
|
89
|
85
|
Opcode::JumpIfFalse => None,
|
90
|
86
|
Opcode::LessThan => Some(2),
|
91
|
87
|
Opcode::Equals => Some(2),
|
|
88
|
+ Opcode::RelativeBaseOffset => None,
|
92
|
89
|
Opcode::Halt => None,
|
93
|
90
|
}
|
94
|
91
|
}
|
|
@@ -99,6 +96,7 @@ impl Opcode {
|
99
|
96
|
pub enum ParameterMode {
|
100
|
97
|
Position = 0,
|
101
|
98
|
Immediate = 1,
|
|
99
|
+ Relative = 2,
|
102
|
100
|
}
|
103
|
101
|
|
104
|
102
|
impl FromStr for Intcode {
|
|
@@ -116,52 +114,75 @@ impl FromStr for Intcode {
|
116
|
114
|
}
|
117
|
115
|
|
118
|
116
|
impl Intcode {
|
119
|
|
- fn new(integers: HashMap<usize, i32>) -> Intcode {
|
|
117
|
+ fn new(integers: HashMap<usize, i64>) -> Intcode {
|
120
|
118
|
Intcode {
|
121
|
119
|
integers,
|
122
|
120
|
pointer: 0,
|
123
|
121
|
halted: false,
|
|
122
|
+ relative_base: 0,
|
124
|
123
|
}
|
125
|
124
|
}
|
126
|
|
- fn load_parameters(&self, pointer: usize, instruction: &Instruction) -> Vec<i32> {
|
|
125
|
+
|
|
126
|
+ fn load_parameters(&mut self, pointer: usize, instruction: &Instruction) -> Vec<i64> {
|
127
|
127
|
(0..instruction.opcode.parameter_count() as usize)
|
128
|
128
|
.map(|parameter_index| {
|
129
|
|
- let mut integer = self.integers[&(pointer + parameter_index + 1)];
|
130
|
|
- if let ParameterMode::Position = instruction.parameter_modes[parameter_index] {
|
131
|
|
- match instruction.opcode.target_parameter_index() {
|
|
129
|
+ let mut integer = *self
|
|
130
|
+ .integers
|
|
131
|
+ .entry(pointer + parameter_index + 1)
|
|
132
|
+ .or_insert(0);
|
|
133
|
+ match instruction.parameter_modes[parameter_index] {
|
|
134
|
+ ParameterMode::Position => match instruction.opcode.target_parameter_index() {
|
132
|
135
|
Some(target_parameter_index)
|
133
|
136
|
if target_parameter_index == parameter_index => {}
|
134
|
137
|
_ => {
|
135
|
|
- integer = self.integers[&(integer as usize)];
|
|
138
|
+ integer = *self.integers.entry(integer as usize).or_insert(0);
|
136
|
139
|
}
|
137
|
|
- }
|
|
140
|
+ },
|
|
141
|
+ ParameterMode::Relative => match instruction.opcode.target_parameter_index() {
|
|
142
|
+ Some(target_parameter_index)
|
|
143
|
+ if target_parameter_index == parameter_index =>
|
|
144
|
+ {
|
|
145
|
+ integer += self.relative_base;
|
|
146
|
+ }
|
|
147
|
+ _ => {
|
|
148
|
+ integer = *self
|
|
149
|
+ .integers
|
|
150
|
+ .entry((self.relative_base + integer) as usize)
|
|
151
|
+ .or_insert(0);
|
|
152
|
+ }
|
|
153
|
+ },
|
|
154
|
+ _ => {}
|
138
|
155
|
}
|
139
|
156
|
integer
|
140
|
157
|
})
|
141
|
158
|
.collect()
|
142
|
159
|
}
|
143
|
160
|
|
144
|
|
- pub fn execute(&mut self, inputs: &[i32]) -> Result<Vec<i32>> {
|
|
161
|
+ pub fn execute(&mut self, inputs: &[i64]) -> Result<Vec<i64>> {
|
145
|
162
|
let mut input_index = 0;
|
146
|
163
|
let mut output = vec![];
|
147
|
164
|
|
148
|
165
|
loop {
|
149
|
|
- let instruction = Instruction::try_from(self.integers[&self.pointer])?;
|
|
166
|
+ let instruction =
|
|
167
|
+ Instruction::try_from(*self.integers.entry(self.pointer).or_insert(0))?;
|
150
|
168
|
let parameters = self.load_parameters(self.pointer, &instruction);
|
151
|
169
|
let mut jump_pointer: Option<usize> = None;
|
152
|
170
|
|
153
|
171
|
match instruction.opcode {
|
154
|
172
|
Opcode::Add => {
|
155
|
|
- self.integers.insert(parameters[2] as usize, parameters[0] + parameters[1]);
|
|
173
|
+ self.integers
|
|
174
|
+ .insert(parameters[2] as usize, parameters[0] + parameters[1]);
|
156
|
175
|
}
|
157
|
176
|
Opcode::Mult => {
|
158
|
|
- self.integers.insert(parameters[2] as usize, parameters[0] * parameters[1]);
|
|
177
|
+ self.integers
|
|
178
|
+ .insert(parameters[2] as usize, parameters[0] * parameters[1]);
|
159
|
179
|
}
|
160
|
180
|
Opcode::Input => {
|
161
|
181
|
if input_index >= inputs.len() {
|
162
|
182
|
break; // pause execution to wait for more input
|
163
|
183
|
}
|
164
|
|
- self.integers.insert(parameters[0] as usize, inputs[input_index]);
|
|
184
|
+ self.integers
|
|
185
|
+ .insert(parameters[0] as usize, inputs[input_index]);
|
165
|
186
|
input_index += 1;
|
166
|
187
|
}
|
167
|
188
|
Opcode::Output => {
|
|
@@ -191,6 +212,9 @@ impl Intcode {
|
191
|
212
|
self.integers.insert(parameters[2] as usize, 0);
|
192
|
213
|
}
|
193
|
214
|
}
|
|
215
|
+ Opcode::RelativeBaseOffset => {
|
|
216
|
+ self.relative_base += parameters[0];
|
|
217
|
+ }
|
194
|
218
|
Opcode::Halt => {
|
195
|
219
|
self.halted = true;
|
196
|
220
|
break;
|
|
@@ -404,4 +428,34 @@ mod tests {
|
404
|
428
|
);
|
405
|
429
|
assert_eq!(intcode.clone().execute(&[1, 1]).unwrap(), vec![11]);
|
406
|
430
|
}
|
|
431
|
+
|
|
432
|
+ #[test]
|
|
433
|
+ fn relative_base_offset_quine() {
|
|
434
|
+ let code = vec![
|
|
435
|
+ 109, 1, 204, -1, 1001, 100, 1, 100, 1008, 100, 16, 101, 1006, 101, 0, 99,
|
|
436
|
+ ];
|
|
437
|
+ let intcode = Intcode::new(code.clone().into_iter().enumerate().collect());
|
|
438
|
+ assert_eq!(intcode.clone().execute(&[]).unwrap(), code);
|
|
439
|
+ }
|
|
440
|
+
|
|
441
|
+ #[test]
|
|
442
|
+ fn sixteen_digit_output() {
|
|
443
|
+ let code = vec![1102, 34915192, 34915192, 7, 4, 7, 99, 0];
|
|
444
|
+ let intcode = Intcode::new(code.into_iter().enumerate().collect());
|
|
445
|
+ assert_eq!(intcode.clone().execute(&[]).unwrap(), [1219070632396864]);
|
|
446
|
+ }
|
|
447
|
+
|
|
448
|
+ #[test]
|
|
449
|
+ fn large_output() {
|
|
450
|
+ let code = vec![104, 1125899906842624, 99];
|
|
451
|
+ let intcode = Intcode::new(code.into_iter().enumerate().collect());
|
|
452
|
+ assert_eq!(intcode.clone().execute(&[]).unwrap(), [1125899906842624]);
|
|
453
|
+ }
|
|
454
|
+
|
|
455
|
+ #[test]
|
|
456
|
+ fn relative_target_parameters() {
|
|
457
|
+ let code = vec![109, 1, 203, 2, 204, 2, 99];
|
|
458
|
+ let intcode = Intcode::new(code.into_iter().enumerate().collect());
|
|
459
|
+ assert_eq!(intcode.clone().execute(&[123]).unwrap(), [123]);
|
|
460
|
+ }
|
407
|
461
|
}
|