Tries for solution, too high

Author: romellem

2019/19/part-two.js

@@ -3,4 +3,4 @@ const { TractorBeam } = require('./tractor-beam');
 
 let tractor_beam = new TractorBeam(input);
 console.log(tractor_beam.partTwo());
-console.log(tractor_beam.grid.toString());
+// 9370819 - too high

2019/19/tractor-beam.js

@@ -10,11 +10,9 @@ class TractorBeam {
 	partOne() {
 		for (let x = 0; x < 50; x++) {
 			for (let y = 0; y < 50; y++) {
-				// The computer halts after every output, so we create a new one each time
-				let computer = new Computer({ memory: this.memory, inputs: [x, y] });
-				let output = computer.run();
+				let output = this.computeAt(x, y);
 
-				this.grid.set(x, y, output.shift());
+				this.grid.set(x, y, output);
 			}
 		}
 
@@ -35,13 +33,11 @@ class TractorBeam {
 		let x = 1;
 		let y = 0;
 		while (!start) {
-			// The computer halts after every output, so we create a new one each time
-			let computer = new Computer({ memory: this.memory, inputs: [x, y] });
-			let [output] = computer.run();
+			let output = this.computeAt(x, y);
 
-			if (output) {
+			if (output === 1) {
 				this.grid.set(x, y, 1);
-				start = {x, y};
+				start = { x, y };
 				break;
 			}
 
@@ -68,11 +64,55 @@ class TractorBeam {
 		 * Similarly, for TOP, move down 1, then move right until we hit a `0`. The cell
 		 * immediately to the left of that is the right edge.
 		 */
-		let top_edge = {...start};
-		let bottom_edge = {...start};
-		while (top_edge.x - bottom_edge.x <= square_size) {
+		let top_edge = { ...start };
+		let bottom_edge = { ...start };
+		while (this.getWidth(bottom_edge, top_edge) < square_size) {
 			this.calculateNewEdges(bottom_edge, top_edge);
 		}
+
+		/**
+		 * Once we have a row that is wide enough, we can move onto the next phase.
+		 * Take the left most point in the row (bottom_edge.x). Calculate the value
+		 * at the point + `square_size` down from there. If we hit a `0`, go to B.
+		 *
+		 * If we hit a `1`, then move right `square_size` amount from that point.
+		 * If _that_ is a `1`, we found our top-left point. Exit.
+		 *
+		 * B. If it's a `0`, then move inward `square_size - row_width` number of times,
+		 * continually checking the point + `square_size` down. If we iterate through
+		 * the available squares in the row, then the top-left point doesn't exist
+		 * in that row. Calculate the next set of edges and start again.
+		 */
+		let found_square;
+		while (!found_square) {
+			const row_width = this.getWidth(bottom_edge, top_edge);
+			for (
+				let x = bottom_edge.x;
+				x < bottom_edge.x + row_width - square_size;
+				x++
+			) {
+				let y = bottom_edge.y + square_size;
+				let output = this.computeAt(x, y);
+				this.grid.set(x, y, output);
+				if (output === 1) {
+					let bottom_right = this.computeAt(x + square_size, y);
+					if (bottom_right === 1) {
+						found_square = { x, y: bottom_edge.y };
+						break;
+					}
+				}
+			}
+
+			if (!found_square) {
+				// Try the next row
+				this.calculateNewEdges(bottom_edge, top_edge);
+			}
+		}
+
+		// What value do you get if you take that
+		// point's X coordinate, multiply it by 10000, then add the point's Y coordinate?
+		console.log(found_square);
+		return found_square.x * 10000 + found_square.y;
 	}
 
 	/**
@@ -83,15 +123,21 @@ class TractorBeam {
 		let output;
 		do {
 			bottom_edge.y++;
-			let computer = new Computer({ memory: this.memory, inputs: [bottom_edge.x, bottom_edge.y] });
+			let computer = new Computer({
+				memory: this.memory,
+				inputs: [bottom_edge.x, bottom_edge.y],
+			});
 			[output] = computer.run();
 			this.grid.set(bottom_edge.x, bottom_edge.y, output);
 		} while (output === 1);
-		
+
 		// Then, move inward until we hit a `1`
 		do {
 			bottom_edge.x++;
-			let computer = new Computer({ memory: this.memory, inputs:  [bottom_edge.x, bottom_edge.y] });
+			let computer = new Computer({
+				memory: this.memory,
+				inputs: [bottom_edge.x, bottom_edge.y],
+			});
 			[output] = computer.run();
 			this.grid.set(bottom_edge.x, bottom_edge.y, output);
 		} while (output === 0);
@@ -103,7 +149,10 @@ class TractorBeam {
 			do {
 				// Move right until we hit a `0`
 				top_edge.x++;
-				let computer = new Computer({ memory: this.memory, inputs: [top_edge.x, top_edge.y] });
+				let computer = new Computer({
+					memory: this.memory,
+					inputs: [top_edge.x, top_edge.y],
+				});
 				[output] = computer.run();
 				this.grid.set(top_edge.x, top_edge.y, output);
 			} while (output === 1);
@@ -112,6 +161,17 @@ class TractorBeam {
 		// The cell immediately to the left of that is the right edge.
 		top_edge.x--;
 	}
+
+	getWidth(bottom_edge, top_edge) {
+		return top_edge.x - bottom_edge.x + 1;
+	}
+
+	computeAt(x, y) {
+		// The computer halts after every output, so we create a new one each time
+		let computer = new Computer({ memory: this.memory, inputs: [x, y] });
+		let [output] = computer.run();
+		return output;
+	}
 }
 
 module.exports = {