Reuse intcode instances

Author: maneatingape

Diff for: README.md

@@ -212,7 +212,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 4 | [Secure Container](https://adventofcode.com/2019/day/4) | [Source](src/year2019/day04.rs) | 7 |
 | 5 | [Sunny with a Chance of Asteroids](https://adventofcode.com/2019/day/5) | [Source](src/year2019/day05.rs) | 3 |
 | 6 | [Universal Orbit Map](https://adventofcode.com/2019/day/6) | [Source](src/year2019/day06.rs) | 28 |
-| 7 | [Amplification Circuit](https://adventofcode.com/2019/day/7) | [Source](src/year2019/day07.rs) | 487 |
+| 7 | [Amplification Circuit](https://adventofcode.com/2019/day/7) | [Source](src/year2019/day07.rs) | 82 |
 | 8 | [Space Image Format](https://adventofcode.com/2019/day/8) | [Source](src/year2019/day08.rs) | 5 |
 | 9 | [Sensor Boost](https://adventofcode.com/2019/day/9) | [Source](src/year2019/day09.rs) | 1021 |
 | 10 | [Monitoring Station](https://adventofcode.com/2019/day/10) | [Source](src/year2019/day10.rs) | 1001 |

Diff for: src/year2019/day07.rs

@@ -7,20 +7,22 @@
 use super::intcode::*;
 use crate::util::parse::*;
 use crate::util::slice::*;
+use std::array::from_fn;
 
 pub fn parse(input: &str) -> Vec<i64> {
     input.iter_signed::<i64>().collect()
 }
 
 pub fn part1(input: &[i64]) -> i64 {
     let mut result = 0;
+    let mut computer = Computer::new(input);
 
     let sequence = |slice: &[i64]| {
         let mut signal = 0;
 
         // Send exactly 2 inputs and receive exactly 1 output per amplifier.
         for &phase in slice {
-            let mut computer = Computer::new(input);
+            computer.reset();
             computer.input(phase);
             computer.input(signal);
 
@@ -39,9 +41,11 @@ pub fn part1(input: &[i64]) -> i64 {
 
 pub fn part2(input: &[i64]) -> i64 {
     let mut result = 0;
+    let mut computers: [Computer; 5] = from_fn(|_| Computer::new(input));
 
     let feedback = |slice: &[i64]| {
-        let mut computers: Vec<_> = (0..5).map(|_| Computer::new(input)).collect();
+        // Reset state.
+        computers.iter_mut().for_each(Computer::reset);
 
         // Send each initial phase setting exactly once.
         for (computer, &phase) in computers.iter_mut().zip(slice.iter()) {

Diff for: src/year2019/intcode.rs

@@ -33,6 +33,13 @@ impl Computer {
         self.input.extend(ascii.bytes().map(|b| b as usize));
     }
 
+    /// Resets state *except* for memory which may have been modified.
+    pub fn reset(&mut self) {
+        self.pc = 0;
+        self.base = 0;
+        self.input.clear();
+    }
+
     /// Runs until either the program needs input, outputs a value or encounters the halt opcode.
     /// In the first two cases, the computer can be resumed by calling `run` again.
     pub fn run(&mut self) -> State {

Diff for: tests/year2019/day07_test.rs

@@ -1,20 +1,9 @@
-use aoc::year2019::day07::*;
-
-const FIRST_EXAMPLE: &str = "\
-3,15,3,16,1002,16,10,16,1,16,15,15,4,15,99,0,0";
-
-const SECOND_EXAMPLE: &str = "\
-3,26,1001,26,-4,26,3,27,1002,27,2,27,1,27,26,
-27,4,27,1001,28,-1,28,1005,28,6,99,0,0,5";
-
 #[test]
 fn part1_test() {
-    let input = parse(FIRST_EXAMPLE);
-    assert_eq!(part1(&input), 43210);
+    // No example data
 }
 
 #[test]
 fn part2_test() {
-    let input = parse(SECOND_EXAMPLE);
-    assert_eq!(part2(&input), 139629729);
+    // No example data
 }