Year 2016 Day 16

Author: maneatingape

README.md

@@ -258,6 +258,7 @@ pie
 | 13 | [A Maze of Twisty Little Cubicles](https://adventofcode.com/2016/day/13) | [Source](src/year2016/day13.rs) | 4 |
 | 14 | [One-Time Pad](https://adventofcode.com/2016/day/14) | [Source](src/year2016/day14.rs) | 439000 |
 | 15 | [Timing is Everything](https://adventofcode.com/2016/day/15) | [Source](src/year2016/day15.rs) | 1 |
+| 16 | [Dragon Checksum](https://adventofcode.com/2016/day/16) | [Source](src/year2016/day16.rs) | 1 |
 
 ## 2015
 

benches/benchmark.rs

@@ -79,6 +79,7 @@ mod year2016 {
     benchmark!(year2016, day13);
     benchmark!(year2016, day14);
     benchmark!(year2016, day15);
+    benchmark!(year2016, day16);
 }
 
 mod year2019 {

input/year2016/day16.txt

@@ -0,0 +1 @@
+01111001100111011

src/lib.rs

@@ -206,6 +206,7 @@ pub mod year2016 {
     pub mod day13;
     pub mod day14;
     pub mod day15;
+    pub mod day16;
 }
 
 /// # Rescue Santa from deep space with a solar system adventure.

src/main.rs

@@ -117,6 +117,7 @@ fn all_solutions() -> Vec<Solution> {
         solution!(year2016, day13),
         solution!(year2016, day14),
         solution!(year2016, day15),
+        solution!(year2016, day16),
         // 2019
         solution!(year2019, day01),
         solution!(year2019, day02),

src/year2016/day16.rs

@@ -0,0 +1,101 @@
+//! # Dragon Checksum
+//!
+//! We solve efficiently with a key insight that the checksum is simply the
+//! [odd parity bit](https://en.wikipedia.org/wiki/Parity_bit) for each block. If the total number
+//! of ones is even then the result is one, if the total is odd then the result is zero.
+//!
+//! This means that only the *total number of ones is important* not the pattern itself. Each
+//! checksum bit is computed over the largest power of two divisible into the output size. For part
+//! one this is 2⁴ or 16 and for part this is 2²¹ or 2097152. If we can calculate the number of
+//! ones for any arbitrary length then we can find the number at the start and end of each block,
+//! subtract from each other to get the total in the range then find the checksum bit.
+//!
+//! We find the number of ones for a pattern of length `n` in `log(n)` complexity as follows:
+//! * Start with a known pattern `abcde` and let the reversed bit inverse of this pattern be
+//!   `EDCBA`.
+//! * Caculate the [prefix sum](https://en.wikipedia.org/wiki/Prefix_sum) of the known sequence.
+//! * If the requested length is within the known sequence (in this example from 0 to 5 inclusive)
+//!   then we're done, return the number of ones directly.
+//! * Else after one repetition this becomes `abcde0EDCBA`.
+//! * If the length is at or to the right of the middle `0`,
+//!   for example `length` is 8 then the number of ones is:
+//!    * Let `half` = 5 the length of the left hand known sequence.
+//!    * Let `full` = 11 the length of the entire sequence.
+//!    * Ones in `abcde` => x
+//!    * Ones in `EDCBA` => the number of zeroes in `abcde`
+//!      => 5 - x => half - x
+//!    * Ones in `abc` => y
+//!    * Ones in `CBA` => the number of zeroes in `abc`
+//!      => 3 - y => 11 - 8 - y => full - length - y => next - y
+//!    * The total number of ones in `abcde0ED` is
+//!      x + (half - x) - (next - y) => half - next + y
+//!
+//! Now for the really neat part. We can recursively find the number of ones in `y` by repeating
+//! the same process by setting the new `length` to `next`. We keep recursing until the length
+//! is less the size of the inital input and we can lookup the final count from the prefix sum.
+use crate::util::parse::*;
+
+/// Build a prefix sum of the number of ones at each length in the pattern
+/// including zero at the start.
+pub fn parse(input: &str) -> Vec<usize> {
+    let mut sum = 0;
+    let mut ones = vec![0];
+
+    for b in input.trim().bytes() {
+        sum += b.to_decimal() as usize;
+        ones.push(sum);
+    }
+
+    ones
+}
+
+/// 272 is 17 * 2⁴
+pub fn part1(input: &[usize]) -> String {
+    checksum(input, 1 << 4)
+}
+
+/// 35651584 is 17 * 2²¹
+pub fn part2(input: &[usize]) -> String {
+    checksum(input, 1 << 21)
+}
+
+/// Collect the ones count at each `step_size` then subtract in pairs to calculate the number of
+/// ones in each interval to give the checksum.
+fn checksum(input: &[usize], step_size: usize) -> String {
+    (0..18)
+        .map(|i| count(input, i * step_size))
+        .collect::<Vec<_>>()
+        .windows(2)
+        .map(|w| if (w[1] - w[0]) % 2 == 0 { '1' } else { '0' })
+        .collect()
+}
+
+/// Counts the number of ones from the start to the index (inclusive).
+fn count(ones: &[usize], mut length: usize) -> usize {
+    let mut half = ones.len() - 1;
+    let mut full = 2 * half + 1;
+
+    // Find the smallest pattern size such that the index is on the right hand side
+    // (greater than or to) the middle `0` character.
+    while full < length {
+        half = full;
+        full = 2 * half + 1;
+    }
+
+    let mut result = 0;
+
+    while length >= ones.len() {
+        // Shrink the pattern size until the index is on the right side once more.
+        while length <= half {
+            half /= 2;
+            full /= 2;
+        }
+
+        // "Reflect" the index then add the extra number of ones to the running total.
+        let next = full - length;
+        result += half - next;
+        length = next;
+    }
+
+    result + ones[length]
+}

tests/test.rs

@@ -72,6 +72,7 @@ mod year2016 {
     mod day13_test;
     mod day14_test;
     mod day15_test;
+    mod day16_test;
 }
 
 mod year2019 {

tests/year2016/day16_test.rs

@@ -0,0 +1,9 @@
+#[test]
+fn part1_test() {
+    // No example data
+}
+
+#[test]
+fn part2_test() {
+    // No example data
+}