Faster approach caching precomputed blocks of jump offsets

Author: maneatingape

README.md

@@ -53,7 +53,7 @@ Place input files in `input/yearYYYY/dayDD.txt` including leading zeroes. For ex
 ## Performance
 
 Benchmarks are measured using the built-in `cargo bench` tool run on an [Apple M2 Max][apple-link].
-All 225 solutions from 2023 to 2015 complete sequentially in **594 milliseconds**.
+All 225 solutions from 2023 to 2015 complete sequentially in **581 milliseconds**.
 Interestingly 84% of the total time is spent on just 9 solutions.
 Performance is reasonable even on older hardware, for example a 2011 MacBook Pro with an
 [Intel i7-2720QM][intel-link] processor takes 3.5 seconds to run the same 225 solutions.
@@ -68,7 +68,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | [2020](#2020) | 272 |
 | [2019](#2019) | 16 |
 | [2018](#2018) | 35 |
-| [2017](#2017) | 102 |
+| [2017](#2017) | 89 |
 | [2016](#2016) | 120 |
 | [2015](#2015) | 24 |
 
@@ -274,7 +274,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 2 | [Corruption Checksum](https://adventofcode.com/2017/day/2) | [Source](src/year2017/day02.rs) | 2 |
 | 3 | [Spiral Memory](https://adventofcode.com/2017/day/3) | [Source](src/year2017/day03.rs) | 2 |
 | 4 | [High-Entropy Passphrases](https://adventofcode.com/2017/day/4) | [Source](src/year2017/day04.rs) | 98 |
-| 5 | [A Maze of Twisty Trampolines, All Alike](https://adventofcode.com/2017/day/5) | [Source](src/year2017/day05.rs) | 36000 |
+| 5 | [A Maze of Twisty Trampolines, All Alike](https://adventofcode.com/2017/day/5) | [Source](src/year2017/day05.rs) | 22000 |
 | 6 | [Memory Reallocation](https://adventofcode.com/2017/day/6) | [Source](src/year2017/day06.rs) | 81 |
 | 7 | [Recursive Circus](https://adventofcode.com/2017/day/7) | [Source](src/year2017/day07.rs) | 93 |
 | 8 | [I Heard You Like Registers](https://adventofcode.com/2017/day/8) | [Source](src/year2017/day08.rs) | 47 |

docs/pie-2017.svg

@@ -1,40 +1,105 @@
 //! # A Maze of Twisty Trampolines, All Alike
+//!
+//! Part one brute forces the jumps. For part two we can make an observation that the jumps offsets
+//! will eventually flip flop between 2 or 3 starting from the beginning, for example:
+//!
+//! ```none
+//!     2 3 2 3 -1
+//! ```
+//!
+//! The twos and threes can be represented in binary compact form, using 0 for 2 and 1 for 3:
+//!
+//! ```none
+//!     0101
+//! ```
+//!
+//! We then precompute all possible combination for blocks of size 16, using this to accelerate
+//! part two.
 use crate::util::parse::*;
 
+const WIDTH: usize = 16;
+const LENGTH: usize = 1 << WIDTH;
+
 pub fn parse(input: &str) -> Vec<i32> {
     input.iter_signed().collect()
 }
 
-pub fn part1(input: &[i32]) -> u32 {
+/// Brute force implementation.
+pub fn part1(input: &[i32]) -> usize {
     let mut jump = input.to_vec();
+    let mut total = 0;
     let mut index = 0;
-    let mut result = 0;
 
     while index < jump.len() {
         let next = index.wrapping_add(jump[index] as usize);
         jump[index] += 1;
+        total += 1;
         index = next;
-        result += 1;
     }
 
-    result
+    total
 }
 
-pub fn part2(input: &[i32]) -> u32 {
+#[expect(clippy::needless_range_loop)]
+pub fn part2(input: &[i32]) -> usize {
     let mut jump = input.to_vec();
+    let mut total = 0;
     let mut index = 0;
-    let mut result = 0;
+
+    let mut fine = 0;
+    let mut coarse = 0;
+    let mut compact = Vec::new();
+    let mut cache = vec![[(0_u16, 0_u8, 0_u8); LENGTH]; WIDTH];
+
+    // Precompute all possible combinations. For each binary starting number we can start at any
+    // offset from 0..16.
+    for i in 0..WIDTH {
+        for j in 0..LENGTH {
+            let mut offset = i as u16;
+            let mut value = j as u16;
+            let mut steps = 0;
+
+            while offset < 16 {
+                value ^= 1 << offset;
+                steps += 1;
+                offset += 3 - ((value >> offset) & 1);
+            }
+
+            cache[i][j] = (value, steps, offset as u8 - i as u8);
+        }
+    }
 
     while index < jump.len() {
-        let next = index.wrapping_add(jump[index] as usize);
-        if jump[index] < 3 {
-            jump[index] += 1;
+        if index < coarse {
+            // Index lies withing precomputed blocks.
+            let base = index / 16;
+            let offset = index % 16;
+            let value = compact[base] as usize;
+            let (next, steps, delta) = cache[offset][value];
+
+            compact[base] = next;
+            total += steps as usize;
+            index += delta as usize;
         } else {
-            jump[index] -= 1;
+            // Fall back to part one approach.
+            let next = index.wrapping_add(jump[index] as usize);
+            jump[index] += if jump[index] == 3 { -1 } else { 1 };
+            total += 1;
+
+            // The frontier of twos and threes advances through the jump offsets.
+            // Each time it crosses a block of 16 add to the compact binary representation.
+            if jump[index] == 2 && index == fine {
+                fine += 1;
+                if fine % 16 == 0 {
+                    let value = (coarse..fine).rev().fold(0, |acc, i| (acc << 1) | (jump[i] & 1));
+                    coarse = fine;
+                    compact.push(value as u16);
+                }
+            }
+
+            index = next;
         }
-        index = next;
-        result += 1;
     }
 
-    result
+    total
 }