Working part two!

Took a while due to the bug I had in the computer `run`. That is, after
I halt, I should _not_ parse the next op, because after a halt, we don't
have a guarantee that the current memory is a valid op.

Author: romellem

2019/7/README.md

@@ -1,8 +1,8 @@
 # Answers
 
-|  Part 1 |   Part 2  |
-|---------|-----------|
-| `87138` | ` ` |
+|  Part 1 |   Part 2   |
+|---------|------------|
+| `87138` | `17279674` |
 
 ## --- Day 7: Amplification Circuit ---
 
@@ -49,3 +49,42 @@ Here are some example programs:
 
 
 Try every combination of phase settings on the amplifiers. _What is the highest signal that can be sent to the thrusters?_
+
+-----------------
+
+## --- Part Two ---
+
+It's no good - in this configuration, the amplifiers can't generate a large enough output signal to produce the thrust you'll need. The Elves quickly talk you through rewiring the amplifiers into a _feedback loop_:
+
+          O-------O  O-------O  O-------O  O-------O  O-------O
+    0 -+->| Amp A |->| Amp B |->| Amp C |->| Amp D |->| Amp E |-.
+       |  O-------O  O-------O  O-------O  O-------O  O-------O |
+       |                                                        |
+       '--------------------------------------------------------+
+                                                                |
+                                                                v
+                                                         (to thrusters)
+    
+
+Most of the amplifiers are connected as they were before; amplifier `A`'s output is connected to amplifier `B`'s input, and so on. _However,_ the output from amplifier `E` is now connected into amplifier `A`'s input. This creates the feedback loop: the signal will be sent through the amplifiers _many times_.
+
+In feedback loop mode, the amplifiers need _totally different phase settings_: integers from `5` to `9`, again each used exactly once. These settings will cause the Amplifier Controller Software to repeatedly take input and produce output many times before halting. Provide each amplifier its phase setting at its first input instruction; all further input/output instructions are for signals.
+
+Don't restart the Amplifier Controller Software on any amplifier during this process. Each one should continue receiving and sending signals until it halts.
+
+All signals sent or received in this process will be between pairs of amplifiers except the very first signal and the very last signal. To start the process, a `0` signal is sent to amplifier `A`'s input _exactly once_.
+
+Eventually, the software on the amplifiers will halt after they have processed the final loop. When this happens, the last output signal from amplifier `E` is sent to the thrusters. Your job is to _find the largest output signal that can be sent to the thrusters_ using the new phase settings and feedback loop arrangement.
+
+Here are some example programs:
+
+*   Max thruster signal _`139629729`_ (from phase setting sequence `9,8,7,6,5`):
+    
+        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
+    
+*   Max thruster signal _`18216`_ (from phase setting sequence `9,7,8,5,6`):
+    
+        3,52,1001,52,-5,52,3,53,1,52,56,54,1007,54,5,55,1005,55,26,1001,54,-5,54,1105,1,12,1,53,54,53,1008,54,0,55,1001,55,1,55,2,53,55,53,4,53,1001,56,-1,56,1005,56,6,99,0,0,0,0,10
+    
+
+Try every combination of the new phase settings on the amplifier feedback loop. _What is the highest signal that can be sent to the thrusters?_

2019/7/circuit.js

@@ -12,7 +12,10 @@ const POSITION_MODE = '0';
 const IMMEDIATE_MODE = '1';
 
 class Computer {
-	constructor(memory, inputs, clone_memory = false) {
+	constructor(memory, inputs, id, clone_memory = false) {
+		// For debugging
+		this.id = String.fromCharCode('A'.charCodeAt(0) + id);
+
 		this.original_memory = clone_memory && memory.slice(0);
 		this.memory = memory.slice(0);
 		this.pointer = 0;
@@ -51,7 +54,7 @@ class Computer {
 			[STP]: {
 				name: STP,
 				params: 0,
-				fn: (...a) => console.log('STOP', a),
+				fn: () => (this.halted = true),
 			},
 
 			[JIT]: {
@@ -94,13 +97,22 @@ class Computer {
 				write: true,
 			},
 		};
+
+		this.halted = false;
 	}
 
 	run() {
 		let op = this.parseOp();
 
-		while (op.name !== STP) {
+		while (!this.halted) {
 			this.runOp(op);
+
+			// Pause executing the computer so this output can be given to the next computer
+			// Additionally, break if we've halted
+			if (op.name === OUT || this.halted) {
+				break;
+			}
+
 			op = this.parseOp();
 		}
 
@@ -153,30 +165,63 @@ class Computer {
 	}
 
 	// For debugging
-	// get _() {
-	// 	return this.input.slice(Math.max(0, this.pointer - 1), this.pointer + 8);
-	// }
+	get _() {
+		return this.memory.slice(
+			Math.max(0, this.pointer - 1),
+			this.pointer + 8
+		);
+	}
 }
 
 class Circuit {
-	constructor(memory, phase_settings) {
+	constructor(memory, phase_settings, circuit_size = 5) {
 		this.memory = memory;
 		this.phase_settings = phase_settings;
+		this.circuit = Array(circuit_size)
+			.fill()
+			.map((c, i) => {
+				let phase_setting = [phase_settings[i]];
+				if (i === 0) {
+					// "The first amplifier's input value is 0"
+					phase_setting.push(0);
+				}
+
+				return new Computer(memory, phase_setting, i);
+			});
+
+		this.current_computer = 0;
 	}
 
-	run(return_last_output = true) {
-		// First computer gets 0 as its second input
-		let last_computer_output = [0];
-		for (let phase_seting of this.phase_settings) {
-			let computer = new Computer(this.memory, [
-				phase_seting,
-				...last_computer_output,
-			]);
-			last_computer_output = computer.run();
+	run() {
+		let computer = this.circuit[this.current_computer];
+		let output, last_output;
+
+		while (!computer.halted) {
+			let new_output = computer.run();
+			if (computer.halted) {
+				break;
+			}
+
+			output = new_output;
+
+			let next_computer = this.moveToNextComputer();
+
+			// `output.pop` removes the value from the computers `this.outputs` array,
+			// meaning the next computer effectively "consumes" the value
+			last_output = output.shift();
+			next_computer.inputs.push(last_output);
+
+			computer = next_computer;
 		}
 
+		return last_output;
+	}
+
+	moveToNextComputer() {
+		this.current_computer++;
+		this.current_computer %= this.circuit.length;
 
-		return return_last_output ? last_computer_output.pop() : last_computer_output;
+		return this.circuit[this.current_computer];
 	}
 }
 

2019/7/part-two.js

@@ -1,2 +1,14 @@
+const G = require('generatorics');
 const { input } = require('./input');
-const Computer = require('./computer');
+const { Circuit } = require('./circuit');
+
+let max_output = Number.MIN_SAFE_INTEGER;
+for (var phase_settings of G.permutation([9, 8, 7, 6, 5])) {
+	let circuit = new Circuit(input, phase_settings);
+	let output = circuit.run();
+	if (output > max_output) {
+		max_output = output;
+	}
+}
+
+console.log(max_output);