Document alternative Dragon Curve parity calculation

The existing O(log n) solution solves in under 1µs, so there is not
really much to be shaved by swapping to an O(1) computation per bit.
But it is still a fun read, so worth documenting for anyone else using
this repository as a reference point.

It is also worth adding a unit test of the example given in part 1.

Author: ebblake

src/year2016/day16.rs

@@ -33,6 +33,14 @@
 //! 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 initial input and we can lookup the final count from the prefix sum.
+//!
+//! Note that it is also possible to compute the parity of any prefix of the Dragon Curve in
+//! O(1) time; the formula is available on [OEIS A255070](https://oeis.org/A255070), and there
+//! are a [couple](https://www.reddit.com/r/adventofcode/comments/5ititq/2016_day_16_c_how_to_tame_your_dragon_in_under_a/)
+//! of [posts](https://www.reddit.com/r/adventofcode/comments/1r642oc/2016_day_16_in_review_dragon_checksum/)
+//! showing how to utilize that approach.  However, the logarithmic solution shown here is
+//! fast enough to not need to worry about askalski's comment "I have no idea why it works,
+//! only that it does work."
 use crate::util::parse::*;
 
 /// Build a prefix sum of the number of ones at each length in the pattern
@@ -51,18 +59,22 @@ pub fn parse(input: &str) -> Vec<usize> {
 
 /// 272 is 17 * 2⁴
 pub fn part1(input: &[usize]) -> String {
-    checksum(input, 1 << 4)
+    checksum(input, 272)
 }
 
 /// 35651584 is 17 * 2²¹
 pub fn part2(input: &[usize]) -> String {
-    checksum(input, 1 << 21)
+    checksum(input, 35651584)
 }
 
 /// 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 {
-    let counts: Vec<_> = (0..18).map(|i| count(input, i * step_size)).collect();
+pub fn checksum(input: &[usize], disk_size: usize) -> String {
+    // Determine how many blocks and how big each one is, by lowest 1-bit in disk_size
+    let step_size = disk_size & (!disk_size + 1);
+    let blocks = disk_size / step_size;
+
+    let counts: Vec<_> = (0..blocks + 1).map(|i| count(input, i * step_size)).collect();
     counts.windows(2).map(|w| if (w[1] - w[0]) % 2 == 0 { '1' } else { '0' }).collect()
 }
 

tests/year2016/day16.rs

@@ -1,6 +1,13 @@
+use aoc::year2016::day16::*;
+
+// From the puzzle, valid for part 1.
+const EXAMPLE: &str = "10000";
+
 #[test]
 fn part1_test() {
-    // No example data
+    // 20 is 5 * 2²
+    let input = parse(EXAMPLE);
+    assert_eq!(checksum(&input, 20), "01100");
 }
 
 #[test]