Faster approach using BitSet instead of HashMap

Author: maneatingape

README.md

@@ -217,7 +217,7 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 12 | [Rain Risk](https://adventofcode.com/2020/day/12) | [Source](src/year2020/day12.rs) | 12 |
 | 13 | [Shuttle Search](https://adventofcode.com/2020/day/13) | [Source](src/year2020/day13.rs) | 1 |
 | 14 | [Docking Data](https://adventofcode.com/2020/day/14) | [Source](src/year2020/day14.rs) | 83 |
-| 15 | [Rambunctious Recitation](https://adventofcode.com/2020/day/15) | [Source](src/year2020/day15.rs) | 147000 |
+| 15 | [Rambunctious Recitation](https://adventofcode.com/2020/day/15) | [Source](src/year2020/day15.rs) | 103000 |
 | 16 | [Ticket Translation](https://adventofcode.com/2020/day/16) | [Source](src/year2020/day16.rs) | 120 |
 | 17 | [Conway Cubes](https://adventofcode.com/2020/day/17) | [Source](src/year2020/day17.rs) | 443 |
 | 18 | [Operation Order](https://adventofcode.com/2020/day/18) | [Source](src/year2020/day18.rs) | 24 |

src/year2020/day15.rs

@@ -1,20 +1,17 @@
 //! # Rambunctious Recitation
 //!
-//! Hybrid solution that uses both a `vec` and [`FastMap`] to store previously seen values.
-//! This approach is faster than using either data structure alone. The threshold is chosen so that
-//! about 85% of values are stored in the `vec`.
+//! For efficiency the `vec` storing the last previously spoken turn of numbers is `u32`.
+//! Each difference is at least one so zero is used as a special value to indicate numbers not
+//! seen before.
 //!
-//! To save space the `vec` is `u32` instead of `usize`. Each difference is at least one so we can
-//! use zero as a special value to indicate numbers not seen before.
+//! To speed things up even more, we notice that most large numbers over a certain threshold are
+//! spoken only once. Storing if numbers have been seen before in a compact bitset prevents
+//! expensive reads to main memory and halves the time needed for the solution.
 //!
-//! Accessing the map uses the [`Entry`] method as this reduces two key lookups to one.
-//!
-//! [`FastMap`]: crate::util::hash
-//! [`Entry`]: std::collections::hash_map::Entry
-use crate::util::hash::*;
+//! Zero occurs the most so storing it as a dedicated variable saves another 2% of execution time.
 use crate::util::parse::*;
 
-const THRESHOLD: usize = 1_000_000;
+const THRESHOLD: usize = 0x10000;
 
 pub fn parse(input: &str) -> Vec<usize> {
     input.iter_unsigned().collect()
@@ -30,31 +27,48 @@ pub fn part2(input: &[usize]) -> usize {
 
 fn play(input: &[usize], rounds: usize) -> usize {
     let size = input.len() - 1;
-    let mut last = input[size];
 
-    let mut spoken_low = vec![0; rounds.min(THRESHOLD)];
-    let mut spoken_high = FastMap::with_capacity(rounds / 5);
+    let mut last = input[size];
+    let mut zeroth = 0;
+    let mut spoken = vec![0; rounds];
+    let mut seen = vec![0_u64; rounds / 64];
 
     for i in 0..size {
-        spoken_low[input[i]] = (i + 1) as u32;
+        if input[i] == 0 {
+            zeroth = i + 1;
+        } else {
+            spoken[input[i]] = (i + 1) as u32;
+        }
     }
 
     for i in input.len()..rounds {
-        if last < THRESHOLD {
-            let previous = spoken_low[last] as usize;
-            spoken_low[last] = i as u32;
+        if last == 0 {
+            // Handle zero specially as it occurs the most.
+            let previous = zeroth;
+            zeroth = i;
+            last = if previous == 0 { 0 } else { i - previous };
+        } else if last < THRESHOLD {
+            // Smaller numbers occur frequently so skip previously seen bitset check.
+            let previous = spoken[last] as usize;
+            spoken[last] = i as u32;
             last = if previous == 0 { 0 } else { i - previous };
         } else {
-            spoken_high
-                .entry(last as u32)
-                .and_modify(|previous| {
-                    last = i - *previous as usize;
-                    *previous = i as u32;
-                })
-                .or_insert_with(|| {
-                    last = 0;
-                    i as u32
-                });
+            // An array of 30 million `u32`s needs 120 MB of memory which exceeds most caches.
+            // Writing and reading to random locations in this large array goes to main memory
+            // which is slow. Store if a number has been seen before in a compact bitset,
+            // needing only a more cache friendly 4 MB.
+            let base = last / 64;
+            let mask = 1 << (last % 64);
+
+            if seen[base] & mask == 0 {
+                seen[base] |= mask;
+                spoken[last] = i as u32;
+                last = 0;
+            } else {
+                let previous = spoken[last] as usize;
+                spoken[last] = i as u32;
+                last = i - previous;
+            }
         }
     }