Merge pull request #155 from romellem/2019/day-16

romellem · web-flow · commit ba96284ee15e · 2021-07-16T21:03:39.000-05:00
2019 - Day 16
diff --git a/2019/16/README.md b/2019/16/README.md
@@ -0,0 +1,96 @@
+# Answers
+
+|   Part 1   |   Part 2   |
+|------------|------------|
+| `27831665` | `36265589` |
+
+## --- Day 16: Flawed Frequency Transmission ---
+
+You're 3/4ths of the way through the [gas giants](https://en.wikipedia.org/wiki/Gas_giant). Not only do roundtrip signals to Earth take five hours, but the signal quality is quite bad as well. You can clean up the signal with the Flawed Frequency Transmission algorithm, or _FFT_.
+
+As input, FFT takes a list of numbers. In the signal you received (your puzzle input), each number is a single digit: data like `15243` represents the sequence `1`, `5`, `2`, `4`, `3`.
+
+FFT operates in repeated _phases_. In each phase, a new list is constructed with the same length as the input list. This new list is also used as the input for the next phase.
+
+Each element in the new list is built by multiplying every value in the input list by a value in a repeating _pattern_ and then adding up the results. So, if the input list were `9, 8, 7, 6, 5` and the pattern for a given element were `1, 2, 3`, the result would be `9*1 + 8*2 + 7*3 + 6*1 + 5*2` (with each input element on the left and each value in the repeating pattern on the right of each multiplication). Then, only the ones digit is kept: `38` becomes `8`, `-17` becomes `7`, and so on.
+
+While each element in the output array uses all of the same input array elements, the actual repeating pattern to use depends on _which output element_ is being calculated. The base pattern is `0, 1, 0, -1`. Then, repeat each value in the pattern a number of times equal to the _position in the output list_ being considered. Repeat once for the first element, twice for the second element, three times for the third element, and so on. So, if the third element of the output list is being calculated, repeating the values would produce: `0, 0, 0, 1, 1, 1, 0, 0, 0, -1, -1, -1`.
+
+When applying the pattern, skip the very first value exactly once. (In other words, offset the whole pattern left by one.) So, for the second element of the output list, the actual pattern used would be: `0, 1, 1, 0, 0, -1, -1, 0, 0, 1, 1, 0, 0, -1, -1, ...`.
+
+After using this process to calculate each element of the output list, the phase is complete, and the output list of this phase is used as the new input list for the next phase, if any.
+
+Given the input signal `12345678`, below are four phases of FFT. Within each phase, each output digit is calculated on a single line with the result at the far right; each multiplication operation shows the input digit on the left and the pattern value on the right:
+
+    Input signal: 12345678
+    
+    1*1  + 2*0  + 3*-1 + 4*0  + 5*1  + 6*0  + 7*-1 + 8*0  = 4
+    1*0  + 2*1  + 3*1  + 4*0  + 5*0  + 6*-1 + 7*-1 + 8*0  = 8
+    1*0  + 2*0  + 3*1  + 4*1  + 5*1  + 6*0  + 7*0  + 8*0  = 2
+    1*0  + 2*0  + 3*0  + 4*1  + 5*1  + 6*1  + 7*1  + 8*0  = 2
+    1*0  + 2*0  + 3*0  + 4*0  + 5*1  + 6*1  + 7*1  + 8*1  = 6
+    1*0  + 2*0  + 3*0  + 4*0  + 5*0  + 6*1  + 7*1  + 8*1  = 1
+    1*0  + 2*0  + 3*0  + 4*0  + 5*0  + 6*0  + 7*1  + 8*1  = 5
+    1*0  + 2*0  + 3*0  + 4*0  + 5*0  + 6*0  + 7*0  + 8*1  = 8
+    
+    After 1 phase: 48226158
+    
+    4*1  + 8*0  + 2*-1 + 2*0  + 6*1  + 1*0  + 5*-1 + 8*0  = 3
+    4*0  + 8*1  + 2*1  + 2*0  + 6*0  + 1*-1 + 5*-1 + 8*0  = 4
+    4*0  + 8*0  + 2*1  + 2*1  + 6*1  + 1*0  + 5*0  + 8*0  = 0
+    4*0  + 8*0  + 2*0  + 2*1  + 6*1  + 1*1  + 5*1  + 8*0  = 4
+    4*0  + 8*0  + 2*0  + 2*0  + 6*1  + 1*1  + 5*1  + 8*1  = 0
+    4*0  + 8*0  + 2*0  + 2*0  + 6*0  + 1*1  + 5*1  + 8*1  = 4
+    4*0  + 8*0  + 2*0  + 2*0  + 6*0  + 1*0  + 5*1  + 8*1  = 3
+    4*0  + 8*0  + 2*0  + 2*0  + 6*0  + 1*0  + 5*0  + 8*1  = 8
+    
+    After 2 phases: 34040438
+    
+    3*1  + 4*0  + 0*-1 + 4*0  + 0*1  + 4*0  + 3*-1 + 8*0  = 0
+    3*0  + 4*1  + 0*1  + 4*0  + 0*0  + 4*-1 + 3*-1 + 8*0  = 3
+    3*0  + 4*0  + 0*1  + 4*1  + 0*1  + 4*0  + 3*0  + 8*0  = 4
+    3*0  + 4*0  + 0*0  + 4*1  + 0*1  + 4*1  + 3*1  + 8*0  = 1
+    3*0  + 4*0  + 0*0  + 4*0  + 0*1  + 4*1  + 3*1  + 8*1  = 5
+    3*0  + 4*0  + 0*0  + 4*0  + 0*0  + 4*1  + 3*1  + 8*1  = 5
+    3*0  + 4*0  + 0*0  + 4*0  + 0*0  + 4*0  + 3*1  + 8*1  = 1
+    3*0  + 4*0  + 0*0  + 4*0  + 0*0  + 4*0  + 3*0  + 8*1  = 8
+    
+    After 3 phases: 03415518
+    
+    0*1  + 3*0  + 4*-1 + 1*0  + 5*1  + 5*0  + 1*-1 + 8*0  = 0
+    0*0  + 3*1  + 4*1  + 1*0  + 5*0  + 5*-1 + 1*-1 + 8*0  = 1
+    0*0  + 3*0  + 4*1  + 1*1  + 5*1  + 5*0  + 1*0  + 8*0  = 0
+    0*0  + 3*0  + 4*0  + 1*1  + 5*1  + 5*1  + 1*1  + 8*0  = 2
+    0*0  + 3*0  + 4*0  + 1*0  + 5*1  + 5*1  + 1*1  + 8*1  = 9
+    0*0  + 3*0  + 4*0  + 1*0  + 5*0  + 5*1  + 1*1  + 8*1  = 4
+    0*0  + 3*0  + 4*0  + 1*0  + 5*0  + 5*0  + 1*1  + 8*1  = 9
+    0*0  + 3*0  + 4*0  + 1*0  + 5*0  + 5*0  + 1*0  + 8*1  = 8
+    
+    After 4 phases: 01029498
+    
+
+Here are the first eight digits of the final output list after 100 phases for some larger inputs:
+
+*   `80871224585914546619083218645595` becomes `24176176`.
+*   `19617804207202209144916044189917` becomes `73745418`.
+*   `69317163492948606335995924319873` becomes `52432133`.
+
+After _100_ phases of FFT, _what are the first eight digits in the final output list?_
+
+-----------------
+
+## --- Part Two ---
+
+Now that your FFT is working, you can decode the _real signal_.
+
+The real signal is your puzzle input _repeated 10000 times_. Treat this new signal as a single input list. Patterns are still calculated as before, and 100 phases of FFT are still applied.
+
+The _first seven digits_ of your initial input signal also represent the _message offset_. The message offset is the location of the eight-digit message in the final output list. Specifically, the message offset indicates _the number of digits to skip_ before reading the eight-digit message. For example, if the first seven digits of your initial input signal were `1234567`, the eight-digit message would be the eight digits after skipping 1,234,567 digits of the final output list. Or, if the message offset were `7` and your final output list were `98765432109876543210`, the eight-digit message would be `21098765`. (Of course, your real message offset will be a seven-digit number, not a one-digit number like `7`.)
+
+Here is the eight-digit message in the final output list after 100 phases. The message offset given in each input has been highlighted. (Note that the inputs given below are repeated 10000 times to find the actual starting input lists.)
+
+*   <code><b>0303673</b>2577212944063491565474664</code> becomes `84462026`.
+*   <code><b>0293510</b>9699940807407585447034323</code> becomes `78725270`.
+*   <code><b>0308177</b>0884921959731165446850517</code> becomes `53553731`.
+
+After repeating your input signal 10000 times and running 100 phases of FFT, _what is the eight-digit message embedded in the final output list?_
diff --git a/2019/16/input.js b/2019/16/input.js
@@ -0,0 +1,25 @@
+const path = require('path');
+const fs = require('fs');
+
+const input = fs
+	.readFileSync(path.join(__dirname, 'input.txt'), 'utf8')
+	.toString()
+	.trim()
+	.split('')
+	.map(v => +v);
+
+const inputTimes10 = [];
+for (let i = 0; i < 10; i++) {
+	inputTimes10.push(...input);
+}
+
+const partTwoInput = [];
+for (let i = 0; i < 10000; i++) {
+	partTwoInput.push(...input);
+}
+
+module.exports = {
+	input,
+	inputTimes10,
+	partTwoInput,
+};
diff --git a/2019/16/input.txt b/2019/16/input.txt
@@ -0,0 +1 @@
+59766977873078199970107568349014384917072096886862753001181795467415574411535593439580118271423936468093569795214812464528265609129756216554981001419093454383882560114421882354033176205096303121974045739484366182044891267778931831792562035297585485658843180220796069147506364472390622739583789825303426921751073753670825259141712329027078263584903642919122991531729298497467435911779410970734568708255590755424253797639255236759229935298472380039602200033415155467240682533288468148414065641667678718893872482168857631352275667414965503393341925955626006552556064728352731985387163635634298416016700583512112158756656289482437803808487304460165855189
diff --git a/2019/16/part-one-optimized.js b/2019/16/part-one-optimized.js
@@ -0,0 +1,38 @@
+// Performs much better for larger inputs because:
+// - We don't generate long arrays for patterns
+const { input } = require('./input');
+
+const base_pattern = [0, 1, 0, -1];
+let current = input;
+
+for (let phase = 1; phase <= 100; phase++) {
+	let new_arr = [];
+	for (let n = 0; n < current.length; n++) {
+		let sum = 0;
+
+		let index = 0;
+		let position = n + 1;
+		for (let i = 0; i < current.length; i++) {
+			position--;
+			if (position <= 0) {
+				position = n + 1;
+				index = (index + 1) % base_pattern.length;
+			}
+
+			let v = current[i];
+			let scalar = base_pattern[index];
+			let new_val = v * scalar;
+
+			sum += new_val;
+		}
+
+		let last_digit = Math.abs(sum % 10);
+
+		new_arr.push(last_digit);
+	}
+
+	current = new_arr;
+}
+
+let first_eight_digits = current.slice(0, 8).join('');
+console.log(first_eight_digits);
diff --git a/2019/16/part-one.js b/2019/16/part-one.js
@@ -0,0 +1,53 @@
+const { input } = require('./input');
+
+var fillPattern = (function () {
+	let cachedPatterns = {};
+
+	return (n) => {
+		if (cachedPatterns[n]) {
+			return cachedPatterns[n];
+		}
+
+		let pattern = [];
+		for (let num of [0, 1, 0, -1]) {
+			for (let i = 0; i < n; i++) {
+				pattern.push(num);
+			}
+		}
+
+		// Offset the whole pattern left by one
+		let first_digit = pattern.shift();
+		pattern.push(first_digit);
+
+		cachedPatterns[n] = pattern;
+
+		return pattern;
+	};
+})();
+
+let current = input;
+
+for (let phase = 1; phase <= 100; phase++) {
+	let new_arr = [];
+	for (let n = 0; n < current.length; n++) {
+		let pattern = fillPattern(n + 1);
+		let sum = 0;
+		for (let i = 0; i < current.length; i++) {
+			let v = current[i];
+			let index = i % pattern.length;
+			let new_val = v * pattern[index];
+
+			sum += new_val;
+		}
+
+		let last_char = String(sum).substr(-1, 1);
+		let last_digit = parseInt(last_char, 10);
+
+		new_arr.push(last_digit);
+	}
+
+	current = new_arr;
+}
+
+let first_eight_digits = current.slice(0, 8).join('');
+console.log(first_eight_digits);
diff --git a/2019/16/part-two.js b/2019/16/part-two.js
@@ -0,0 +1,95 @@
+const { partTwoInput } = require('./input');
+
+const offset = parseInt(partTwoInput.slice(0, 7).join(''), 10);
+const slice_to_iterate = partTwoInput.slice(offset);
+for (let j = 0; j < 100; j++) {
+	// We don't need to do anything with the last number so start at 2nd the last
+	for (let i = slice_to_iterate.length - 2; i >= 0; i--) {
+		slice_to_iterate[i] = (slice_to_iterate[i + 1] + slice_to_iterate[i]) % 10;
+	}
+}
+
+// First 8 digits from our offset
+console.log(slice_to_iterate.slice(0, 8).join(''));
+
+/*
+
+Here's the trick:
+
+Let's say your 12 digits number is `123456789123`.
+Look at the table after you get past the "halfway point" down the list:
+
+|  # |   1  |   2  |   3  |   4  |   5  |   6  |   7  |   8  |   9  |   1  |   2  |   3  |
+|----|------|------|------|------|------|------|------|------|------|------|------|------|
+|  1 |   1  |      |  -3  |      |   5  |      |  -7  |      |   9  |      |  -2  |      |
+|  2 |      |   2  |   3  |      |      |  -6  |  -7  |      |      |   1  |   2  |      |
+|  3 |      |      |   3  |   4  |   5  |      |      |      |  -9  |  -1  |  -2  |      |
+|  4 |      |      |      |   4  |   5  |   6  |   7  |      |      |      |      |  -3  |
+|  5 |      |      |      |      |   5  |   6  |   7  |   8  |   9  |      |      |      |
+|  6 |      |      |      |      |      |   6  |   7  |   8  |   9  |   1  |   2  |      |
+|  7 |      |      |      |      |      |      |  *7* |  *8* |  *9* |  *1* |  *2* |  *3* |
+|  8 |      |      |      |      |      |      |      |  *8* |  *9* |  *1* |  *2* |  *3* |
+|  9 |      |      |      |      |      |      |      |      |  *9* |  *1* |  *2* |  *3* |
+| 10 |      |      |      |      |      |      |      |      |      |  *1* |  *2* |  *3* |
+| 11 |      |      |      |      |      |      |      |      |      |      |  *2* |  *3* |
+| 12 |      |      |      |      |      |      |      |      |      |      |      |  *3* |
+
+Starting from row 7 on down, all the numbers are added together! No 0s, no -1s, just the numbers
+added.
+
+Since our "offset" is more than halfway through our full list, we can just immediately jump to the offset
+and compute those numbers on down.
+
+Now adding up all those numbers in the triangle is still a _lot._ But there is another trick!
+
+Look at the very last number, 3. let's call it A.
+
+Go up one row, we have 2 + (3). But wait, 3 is A. So we have 2 + A. Let's call that B.
+
+Go up another row, we have 1 + 2 + (3) -> 1 + (2 + A) -> 1 + B. Call that C.
+
+You see where this is going. Go up another row, 9 + 1 + 2 + (3),
+9 + 1 + (2 + A) -> 9 + (1 + B) -> 9 + C. Call that D.
+
+And so on.
+
+The other trick is, we only need to store the last digit each time we start from the bottom
+and loop up.
+
+Consider
+
+    n + ...           = x_n      n + x_n-1 = x_n
+        d + c + b + a = x_4      d + x_3   = x_4
+            c + b + a = x_3  =>  c + x_2   = x_3
+                b + a = x_2      b + x_1   = x_2
+                    a = x_1      a         = x_1
+
+Let `x_n` = `D_i..D_1D_0`, where `D_n` is a single digit.
+
+Clearly `(x_n)mod 10 = D_0`, aka the last digit.
+
+Let `l + x_n` be the next line up we want to add. So `l` is a single digit number.
+
+I'm saying we should only care about the last digit of all that addition, so I want to show that
+
+    (l + x_n)mod 10 = (l + D_0)mod 10.
+
+From the "Addition Property" of modular arithmetic, we know that
+
+    (a + b)mod_n = [(a)mod_n + (b)mod_n]mod_n
+
+So, expanding `(l + x_n)mod 10` is
+
+    (l + x_n)mod_10 = ((l)mod_10 + (x_n)mod_10)mod_10.
+    
+    # Well `(l)mod_10` is just `l`, since `l` is less than 10 (aka a single digit).
+    
+    (l + x_n)mod_10 = ((l)       + (x_n)mod_10)mod_10.
+    
+    # Add (x_n)mod_10 = D_0
+    
+    (l + x_n)mod_10 = (l         + D0         )mod_10.
+
+QED ∎
+
+*/
diff --git a/README.md b/README.md
@@ -49,7 +49,7 @@ Completed: **25 / 25** (100% ⭐️)
 
 ## 2019 Puzzles List
 
-Completed: **16 / 25** (64%)
+Completed: **17 / 25** (68%)
 
 *  [✅ Day 1](2019/1/)
 *  [✅ Day 2](2019/2/)
@@ -66,7 +66,7 @@ Completed: **16 / 25** (64%)
 *  [✅ Day 13](2019/13/)
 *  [✅ Day 14](2019/14/)
 *  Day 15
-*  Day 16
+*  [✅ Day 16](2019/16/)
 *  Day 17
 *  Day 18
 *  [✅ Day 19](2019/19/)

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	+59766977873078199970107568349014384917072096886862753001181795467415574411535593439580118271423936468093569795214812464528265609129756216554981001419093454383882560114421882354033176205096303121974045739484366182044891267778931831792562035297585485658843180220796069147506364472390622739583789825303426921751073753670825259141712329027078263584903642919122991531729298497467435911779410970734568708255590755424253797639255236759229935298472380039602200033415155467240682533288468148414065641667678718893872482168857631352275667414965503393341925955626006552556064728352731985387163635634298416016700583512112158756656289482437803808487304460165855189