Merge pull request #60 from romellem/2017/day-10

2017 - Day 10

Author: romellem

2017/10/README.md

@@ -0,0 +1,80 @@
+# Answers
+
+| Part 1  |               Part 2               |
+|---------|------------------------------------|
+| `38628` | `e1462100a34221a7f0906da15c1c979a` |
+
+## --- Day 10: Knot Hash ---
+
+You come across some programs that are trying to implement a software emulation of a hash based on knot-tying. The hash these programs are implementing isn't very strong, but you decide to help them anyway. You make a mental note to remind the Elves later not to invent their own cryptographic functions.
+
+This hash function simulates tying a knot in a circle of string with 256 marks on it. Based on the input to be hashed, the function repeatedly selects a span of string, brings the ends together, and gives the span a half-twist to reverse the order of the marks within it. After doing this many times, the order of the marks is used to build the resulting hash.
+
+      4--5   pinch   4  5           4   1
+     /    \  5,0,1  / \/ \  twist  / \ / \
+    3      0  -->  3      0  -->  3   X   0
+     \    /         \ /\ /         \ / \ /
+      2--1           2  1           2   5
+    
+
+To achieve this, begin with a _list_ of numbers from `0` to `255`, a _current position_ which begins at `0` (the first element in the list), a _skip size_ (which starts at `0`), and a sequence of _lengths_ (your puzzle input). Then, for each length:
+
+*   _Reverse_ the order of that _length_ of elements in the _list_, starting with the element at the _current position_.
+*   _Move_ the _current position_ forward by that _length_ plus the _skip size_.
+*   _Increase_ the _skip size_ by one.
+
+The _list_ is circular; if the _current position_ and the _length_ try to reverse elements beyond the end of the list, the operation reverses using as many extra elements as it needs from the front of the list. If the _current position_ moves past the end of the list, it wraps around to the front. _Lengths_ larger than the size of the _list_ are invalid.
+
+Here's an example using a smaller list:
+
+Suppose we instead only had a circular list containing five elements, `0, 1, 2, 3, 4`, and were given input lengths of `3, 4, 1, 5`.
+
+*   The list begins as `[0] 1 2 3 4` (where square brackets indicate the _current position_).
+*   The first length, `3`, selects `([0] 1 2) 3 4` (where parentheses indicate the sublist to be reversed).
+*   After reversing that section (`0 1 2` into `2 1 0`), we get `([2] 1 0) 3 4`.
+*   Then, the _current position_ moves forward by the _length_, `3`, plus the _skip size_, 0: `2 1 0 [3] 4`. Finally, the _skip size_ increases to `1`.
+
+*   The second length, `4`, selects a section which wraps: `2 1) 0 ([3] 4`.
+*   The sublist `3 4 2 1` is reversed to form `1 2 4 3`: `4 3) 0 ([1] 2`.
+*   The _current position_ moves forward by the _length_ plus the _skip size_, a total of `5`, causing it not to move because it wraps around: `4 3 0 [1] 2`. The _skip size_ increases to `2`.
+
+*   The third length, `1`, selects a sublist of a single element, and so reversing it has no effect.
+*   The _current position_ moves forward by the _length_ (`1`) plus the _skip size_ (`2`): `4 [3] 0 1 2`. The _skip size_ increases to `3`.
+
+*   The fourth length, `5`, selects every element starting with the second: `4) ([3] 0 1 2`. Reversing this sublist (`3 0 1 2 4` into `4 2 1 0 3`) produces: `3) ([4] 2 1 0`.
+*   Finally, the _current position_ moves forward by `8`: `3 4 2 1 [0]`. The _skip size_ increases to `4`.
+
+In this example, the first two numbers in the list end up being `3` and `4`; to check the process, you can multiply them together to produce `12`.
+
+However, you should instead use the standard list size of `256` (with values `0` to `255`) and the sequence of _lengths_ in your puzzle input. Once this process is complete, _what is the result of multiplying the first two numbers in the list_?
+
+-----------------
+
+## --- Part Two ---
+
+The logic you've constructed forms a single _round_ of the _Knot Hash_ algorithm; running the full thing requires many of these rounds. Some input and output processing is also required.
+
+First, from now on, your input should be taken not as a list of numbers, but as a string of bytes instead. Unless otherwise specified, convert characters to bytes using their [ASCII codes](https://en.wikipedia.org/wiki/ASCII#Printable_characters). This will allow you to handle arbitrary ASCII strings, and it also ensures that your input lengths are never larger than `255`. For example, if you are given `1,2,3`, you should convert it to the ASCII codes for each character: `49,44,50,44,51`.
+
+Once you have determined the sequence of lengths to use, add the following lengths to the end of the sequence: `17, 31, 73, 47, 23`. For example, if you are given `1,2,3`, your final sequence of lengths should be `49,44,50,44,51,17,31,73,47,23` (the ASCII codes from the input string combined with the standard length suffix values).
+
+Second, instead of merely running one _round_ like you did above, run a total of `64` rounds, using the same _length_ sequence in each round. The _current position_ and _skip size_ should be preserved between rounds. For example, if the previous example was your first round, you would start your second round with the same _length_ sequence (`3, 4, 1, 5, 17, 31, 73, 47, 23`, now assuming they came from ASCII codes and include the suffix), but start with the previous round's _current position_ (`4`) and _skip size_ (`4`).
+
+Once the rounds are complete, you will be left with the numbers from `0` to `255` in some order, called the _sparse hash_. Your next task is to reduce these to a list of only `16` numbers called the _dense hash_. To do this, use numeric bitwise [XOR](https://en.wikipedia.org/wiki/Bitwise_operation#XOR) to combine each consecutive block of `16` numbers in the sparse hash (there are `16` such blocks in a list of `256` numbers). So, the first element in the dense hash is the first sixteen elements of the sparse hash XOR'd together, the second element in the dense hash is the second sixteen elements of the sparse hash XOR'd together, etc.
+
+For example, if the first sixteen elements of your sparse hash are as shown below, and the XOR operator is `^`, you would calculate the first output number like this:
+
+    65 ^ 27 ^ 9 ^ 1 ^ 4 ^ 3 ^ 40 ^ 50 ^ 91 ^ 7 ^ 6 ^ 0 ^ 2 ^ 5 ^ 68 ^ 22 = 64
+
+Perform this operation on each of the sixteen blocks of sixteen numbers in your sparse hash to determine the sixteen numbers in your dense hash.
+
+Finally, the standard way to represent a Knot Hash is as a single [hexadecimal](https://en.wikipedia.org/wiki/Hexadecimal) string; the final output is the dense hash in hexadecimal notation. Because each number in your dense hash will be between `0` and `255` (inclusive), always represent each number as two hexadecimal digits (including a leading zero as necessary). So, if your first three numbers are `64, 7, 255`, they correspond to the hexadecimal numbers `40, 07, ff`, and so the first six characters of the hash would be `4007ff`. Because every Knot Hash is sixteen such numbers, the hexadecimal representation is always `32` hexadecimal digits (`0`\-`f`) long.
+
+Here are some example hashes:
+
+*   The empty string becomes `a2582a3a0e66e6e86e3812dcb672a272`.
+*   `AoC 2017` becomes `33efeb34ea91902bb2f59c9920caa6cd`.
+*   `1,2,3` becomes `3efbe78a8d82f29979031a4aa0b16a9d`.
+*   `1,2,4` becomes `63960835bcdc130f0b66d7ff4f6a5a8e`.
+
+Treating your puzzle input as a string of ASCII characters, _what is the Knot Hash of your puzzle input?_ Ignore any leading or trailing whitespace you might encounter.

2017/10/input.js

@@ -0,0 +1,19 @@
+const PART_TWO_TWIST_END_CONCAT = [17, 31, 73, 47, 23];
+
+module.exports = {
+    sampleInput: {
+        size: 5,
+        twists: [3, 4, 1, 5],
+    },
+    input: {
+        size: 256,
+        twists: [130, 126, 1, 11, 140, 2, 255, 207, 18, 254, 246, 164, 29, 104, 0, 224],
+    },
+    inputTwo: {
+        size: 256,
+        twists: `130,126,1,11,140,2,255,207,18,254,246,164,29,104,0,224`
+            .split('')
+            .map(v => v.charCodeAt())
+            .concat(PART_TWO_TWIST_END_CONCAT),
+    },
+};

2017/10/input.txt

@@ -0,0 +1 @@
+130,126,1,11,140,2,255,207,18,254,246,164,29,104,0,224

2017/10/knot.js

@@ -0,0 +1,55 @@
+const { range } = require('lodash');
+const assert = require('assert');
+
+class Knot {
+    constructor(size, current_position = 0, skip = 0) {
+        this.string = range(size);
+        this.current_position = current_position;
+        this.skip = skip;
+    }
+
+    static stringToInputArray(str) {
+        return str
+            .split('')
+            .map(v => v.charCodeAt())
+            .concat([17, 31, 73, 47, 23]);
+    }
+
+    performTwists(twists, iterations = 1) {
+        for (let iteration = 0; iteration < iterations; iteration++) {
+            twists.forEach(twist => {
+                let indices = range(twist).map(
+                    v => (v + this.current_position) % this.string.length
+                );
+                let points = indices.map(i => this.string[i]);
+                points.reverse();
+                indices.forEach((string_i, root_i) => (this.string[string_i] = points[root_i]));
+                this.current_position =
+                    (this.current_position + twist + this.skip++) % this.string.length;
+            });
+        }
+
+        return this.string;
+    }
+
+    denseHash() {
+        let hash = [];
+        for (let i = 0; i < 16; i++) {
+            let slice = this.string.slice(i * 16, (i + 1) * 16);
+            hash.push(slice.reduce((a, b) => a ^ b));
+        }
+
+        return hash.map(v => v.toString(16).padStart(2, '0')).join('');
+    }
+
+    partOneAnswer() {
+        assert.ok(this.string.length >= 2);
+        return this.string[0] * this.string[1];
+    }
+
+    partTwoAnswer() {
+        return this.denseHash();
+    }
+}
+
+module.exports = Knot;

2017/10/part-one.js

@@ -0,0 +1,15 @@
+const { input, sampleInput } = require('./input');
+const Knot = require('./knot');
+const assert = require('assert');
+
+// Tests
+let sample_knot = new Knot(sampleInput.size);
+sample_knot.performTwists(sampleInput.twists);
+assert.deepStrictEqual(sample_knot.string, [3, 4, 2, 1, 0]);
+assert.strictEqual(sample_knot.partOneAnswer(), 12);
+assert.strictEqual(sample_knot.current_position, 4);
+
+let knot = new Knot(input.size);
+knot.performTwists(input.twists);
+
+console.log(knot.partOneAnswer());

2017/10/part-two.js

@@ -0,0 +1,21 @@
+const { inputTwo } = require('./input');
+const Knot = require('./knot');
+const assert = require('assert');
+
+// Tests
+[
+    { str: '', hash: 'a2582a3a0e66e6e86e3812dcb672a272' },
+    { str: 'AoC 2017', hash: '33efeb34ea91902bb2f59c9920caa6cd' },
+    { str: '1,2,3', hash: '3efbe78a8d82f29979031a4aa0b16a9d' },
+    { str: '1,2,4', hash: '63960835bcdc130f0b66d7ff4f6a5a8e' },
+].forEach(({ str, hash }) => {
+    let sample_twists = Knot.stringToInputArray(str);
+    let sample_knot = new Knot(256);
+    sample_knot.performTwists(sample_twists, 64);
+    assert.strictEqual(sample_knot.denseHash(), hash);
+});
+
+let knot = new Knot(inputTwo.size);
+knot.performTwists(inputTwo.twists, 64);
+
+console.log(knot.partTwoAnswer());