Year 2022 speed and code quality improvements

maneatingape · maneatingape · commit 2439fa7d8308 · 2025-08-24T12:32:28.000+01:00
diff --git a/README.md b/README.md
@@ -152,11 +152,11 @@ Performance is reasonable even on older hardware, for example a 2011 MacBook Pro
 | 11 | [Monkey in the Middle](https://adventofcode.com/2022/day/11) | [Source](src/year2022/day11.rs) | 1173 |
 | 12 | [Hill Climbing Algorithm](https://adventofcode.com/2022/day/12) | [Source](src/year2022/day12.rs) | 57 |
 | 13 | [Distress Signal](https://adventofcode.com/2022/day/13) | [Source](src/year2022/day13.rs) | 15 |
-| 14 | [Regolith Reservoir](https://adventofcode.com/2022/day/14) | [Source](src/year2022/day14.rs) | 205 |
+| 14 | [Regolith Reservoir](https://adventofcode.com/2022/day/14) | [Source](src/year2022/day14.rs) | 146 |
 | 15 | [Beacon Exclusion Zone](https://adventofcode.com/2022/day/15) | [Source](src/year2022/day15.rs) | 2 |
 | 16 | [Proboscidea Volcanium](https://adventofcode.com/2022/day/16) | [Source](src/year2022/day16.rs) | 59 |
 | 17 | [Pyroclastic Flow](https://adventofcode.com/2022/day/17) | [Source](src/year2022/day17.rs) | 71 |
-| 18 | [Boiling Boulders](https://adventofcode.com/2022/day/18) | [Source](src/year2022/day18.rs) | 121 |
+| 18 | [Boiling Boulders](https://adventofcode.com/2022/day/18) | [Source](src/year2022/day18.rs) | 52 |
 | 19 | [Not Enough Minerals](https://adventofcode.com/2022/day/19) | [Source](src/year2022/day19.rs) | 74 |
 | 20 | [Grove Positioning System](https://adventofcode.com/2022/day/20) | [Source](src/year2022/day20.rs) | 3785 |
 | 21 | [Monkey Math](https://adventofcode.com/2022/day/21) | [Source](src/year2022/day21.rs) | 64 |
diff --git a/src/year2022/day09.rs b/src/year2022/day09.rs
@@ -7,32 +7,26 @@ use crate::util::parse::*;
 use crate::util::point::*;
 
 type Pair = (Point, i32);
-type Input = ([i32; 4], Vec<Pair>);
+type Input = (i32, i32, i32, i32, Vec<Pair>);
 
 /// Converts input lines into a pair of [`Point`] and integer amount, to indicate direction and
 /// magnitude respectively. Then determines the maximum extent of the head so that we can allocate
 /// a two dimensional grid.
 pub fn parse(input: &str) -> Input {
     let first = input.bytes().filter(u8::is_ascii_alphabetic).map(Point::from);
     let second = input.iter_signed::<i32>();
-    let pairs = first.zip(second).collect();
+    let pairs: Vec<_> = first.zip(second).collect();
 
     // Determine maximum extents
-    let mut x1 = i32::MAX;
-    let mut y1 = i32::MAX;
-    let mut x2 = i32::MIN;
-    let mut y2 = i32::MIN;
-    let mut point = ORIGIN;
+    let (x1, y1, x2, y2, _) = pairs.iter().fold(
+        (i32::MAX, i32::MAX, i32::MIN, i32::MIN, ORIGIN),
+        |(x1, y1, x2, y2, point), &(step, amount)| {
+            let next = point + step * amount;
+            (x1.min(next.x), y1.min(next.y), x2.max(next.x), y2.max(next.y), next)
+        },
+    );
 
-    for &(step, amount) in &pairs {
-        point += step * amount;
-        x1 = x1.min(point.x);
-        y1 = y1.min(point.y);
-        x2 = x2.max(point.x);
-        y2 = y2.max(point.y);
-    }
-
-    ([x1, y1, x2, y2], pairs)
+    (x1, y1, x2, y2, pairs)
 }
 
 /// Simulate a rope length of 2
@@ -54,7 +48,7 @@ pub fn part2(input: &Input) -> u32 {
 /// Using const generics for the rope length allows the compiler to optimize the loop and speeds
 /// things up by about 40%.
 fn simulate<const N: usize>(input: &Input) -> u32 {
-    let ([x1, y1, x2, y2], pairs) = input;
+    let (x1, y1, x2, y2, pairs) = input;
     let width = x2 - x1 + 1;
     let height = y2 - y1 + 1;
     let start = Point::new(-x1, -y1);
diff --git a/src/year2022/day10.rs b/src/year2022/day10.rs
@@ -26,14 +26,14 @@ pub fn part1(input: &[i32]) -> i32 {
 
 /// Returns pixels as a multi-line [`String`] so that the entire function can be integration tested.
 pub fn part2(input: &[i32]) -> String {
-    let to_char = |(i, c): (usize, &i32)| {
-        if ((i as i32) - c).abs() <= 1 { '#' } else { '.' }
-    };
-    let mut result = input
-        .chunks_exact(40)
-        .map(|row| row.iter().enumerate().map(to_char).collect())
-        .collect::<Vec<String>>()
-        .join("\n");
-    result.insert(0, '\n');
+    let mut result = String::new();
+
+    for row in input.chunks_exact(40) {
+        result.push('\n');
+        for (i, &c) in row.iter().enumerate() {
+            result.push(if ((i as i32) - c).abs() <= 1 { '#' } else { '.' });
+        }
+    }
+
     result
 }
diff --git a/src/year2022/day14.rs b/src/year2022/day14.rs
@@ -15,7 +15,7 @@
 //! the whole pile.
 //!
 //! We instead simulate in `O(n)` complexity by recursively check each grain's underneath
-//! neighbors until we have a conclusive result then propagating that back up the call stack,
+//! neighbors until we have a conclusive result then propagating that back up the stack,
 //! for example:
 //!
 //! ```none
@@ -31,6 +31,7 @@
 //! * `Falling` Grains of sand that will continue to fall continously forever.
 //! * `Stopped` Both original rock walls and any grains of sand that have come to rest.
 use crate::util::parse::*;
+use Kind::*;
 
 #[derive(Clone, Copy, PartialEq, Eq)]
 enum Kind {
@@ -43,89 +44,86 @@ enum Kind {
 pub struct Cave {
     width: usize,
     height: usize,
-    size: usize,
     kind: Vec<Kind>,
-    floor: Kind,
-    count: u32,
-}
-
-impl Cave {
-    fn fall(&mut self, index: usize) -> Kind {
-        // Check in order: center, left then right
-        let result = self.check(index + self.width)
-            && self.check(index + self.width - 1)
-            && self.check(index + self.width + 1);
-
-        // If all 3 bottom neighbors are stopped then so are we.
-        // Cache the result into the grid then propagate result back up the call stack.
-        if result {
-            self.count += 1;
-            self.kind[index] = Kind::Stopped;
-            Kind::Stopped
-        } else {
-            self.kind[index] = Kind::Falling;
-            Kind::Falling
-        }
-    }
-
-    // Returns `true` if cell is stopped.
-    fn check(&mut self, index: usize) -> bool {
-        let kind = if index >= self.size {
-            // If we've reached the "floor" then return that.
-            self.floor
-        } else if self.kind[index] == Kind::Air {
-            // If we're unknown then recursively check our own underneath neighbors
-            self.fall(index)
-        } else {
-            // Otherwise use the cached value.
-            self.kind[index]
-        };
-        kind == Kind::Stopped
-    }
 }
 
 /// Creates a 2D grid cave exactly the maximum possible size.
 pub fn parse(input: &str) -> Cave {
     let unsigned = |line: &str| line.iter_unsigned().collect();
     let points: Vec<Vec<usize>> = input.lines().map(unsigned).collect();
     let max_y = points.iter().flat_map(|row| row.iter().skip(1).step_by(2)).max().unwrap();
+
     // Floor is 2 below the bottommost wall.
     let height = max_y + 2;
     // Allow enough horizontal room to spread out.
     let width = 2 * height + 1;
-    let size = width * height;
-    let mut kind = vec![Kind::Air; size];
 
     // Draw each of the walls.
+    let mut kind = vec![Air; width * height];
+
     for row in points {
         for window in row.windows(4).step_by(2) {
             if let &[x1, y1, x2, y2] = window {
-                for x in x1.min(x2)..=x1.max(x2) {
+                if x1 == x2 {
                     for y in y1.min(y2)..=y1.max(y2) {
-                        kind[(width * y) + (x + height - 500)] = Kind::Stopped;
+                        kind[width * y + x1 + height - 500] = Stopped;
+                    }
+                } else {
+                    for x in x1.min(x2)..=x1.max(x2) {
+                        kind[width * y1 + x + height - 500] = Stopped;
                     }
                 }
             }
         }
     }
 
-    Cave { width, height, size, kind, floor: Kind::Air, count: 0 }
+    Cave { width, height, kind }
 }
 
 /// If a grain of sand reaches the floor it will fall forever.
 pub fn part1(input: &Cave) -> u32 {
-    simulate(input, Kind::Falling)
+    simulate(input, Falling)
 }
 
 /// The floor is solid rock.
 pub fn part2(input: &Cave) -> u32 {
-    simulate(input, Kind::Stopped)
+    simulate(input, Stopped)
 }
 
 fn simulate(input: &Cave, floor: Kind) -> u32 {
-    let mut cave = input.clone();
-    cave.floor = floor;
+    let Cave { width, height, mut kind } = input.clone();
+    let mut count = 0;
+
     // Height is also the x coordinate of the central starting location for grains.
-    cave.fall(cave.height);
-    cave.count
+    let mut todo = Vec::with_capacity(1_000);
+    todo.push(height);
+
+    'outer: while let Some(index) = todo.pop() {
+        // Check in order: center, left then right
+        for next in [index + width, index + width - 1, index + width + 1] {
+            // If we've reached the "floor" then return that.
+            let tile = if next >= kind.len() { floor } else { kind[next] };
+
+            match tile {
+                // If we're unknown then check underneath neighbors first then re-check this tile.
+                Air => {
+                    todo.push(index);
+                    todo.push(next);
+                    continue 'outer;
+                }
+                // Any falling tile underneath means that this tile is also falling.
+                Falling => {
+                    kind[index] = Falling;
+                    continue 'outer;
+                }
+                Stopped => (),
+            }
+        }
+
+        // If all 3 tiles underneath are stopped then this tile is also stopped.
+        kind[index] = Stopped;
+        count += 1;
+    }
+
+    count
 }
diff --git a/src/year2022/day18.rs b/src/year2022/day18.rs
@@ -9,9 +9,9 @@
 use crate::util::iter::*;
 use crate::util::parse::*;
 
-const SIZE: usize = 22;
+const SIZE: usize = 24;
 
-pub fn parse(input: &str) -> Vec<u32> {
+pub fn parse(input: &str) -> Vec<u8> {
     let mut cube = vec![0; SIZE * SIZE * SIZE];
     // Leave a 1 layer boundary around the outside for the part two flood fill
     // and also so that we don't have to use boundary checks when checking neighbors.
@@ -21,49 +21,57 @@ pub fn parse(input: &str) -> Vec<u32> {
     cube
 }
 
-pub fn part1(input: &[u32]) -> u32 {
+pub fn part1(input: &[u8]) -> u32 {
     // The exposed surface area is the 6 faces of the cubes minus any neighbors.
     count(input, |x| 6 - x)
 }
 
-pub fn part2(input: &[u32]) -> u32 {
-    let mut cube = input.to_vec();
+pub fn part2(input: &[u8]) -> u32 {
     // "Paint" the outside of the cube with water drops.
-    flood_fill(&mut cube, 0);
+    // Use 8 as the nearest power of two greater than 6.
+    let mut cube = input.to_vec();
+    cube[0] = 8;
+
+    let mut todo = Vec::new();
+    todo.push(0);
+
+    while let Some(index) = todo.pop() {
+        let mut flood_fill = |next| {
+            if next < input.len() && cube[next] == 0 {
+                cube[next] = 8;
+                todo.push(next);
+            }
+        };
+
+        // We may wrap around but that index will be out of bounds.
+        flood_fill(index.wrapping_sub(1));
+        flood_fill(index + 1);
+        flood_fill(index.wrapping_sub(SIZE));
+        flood_fill(index + SIZE);
+        flood_fill(index.wrapping_sub(SIZE * SIZE));
+        flood_fill(index + SIZE * SIZE);
+    }
+
     // Divide by 8 so that we only count water cubes.
     count(&cube, |x| x >> 3)
 }
 
-fn count(cube: &[u32], adjust: fn(u32) -> u32) -> u32 {
+fn count(cube: &[u8], adjust: fn(u32) -> u32) -> u32 {
     let mut total = 0;
 
     for i in 0..cube.len() {
         if cube[i] == 1 {
             // No need for boundary checks as all cubes are at least 1 away from the edge.
             total += adjust(
-                cube[i - 1]
+                (cube[i - 1]
                     + cube[i + 1]
                     + cube[i - SIZE]
                     + cube[i + SIZE]
                     + cube[i - SIZE * SIZE]
-                    + cube[i + SIZE * SIZE],
+                    + cube[i + SIZE * SIZE]) as u32,
             );
         }
     }
 
     total
 }
-
-fn flood_fill(cube: &mut [u32], i: usize) {
-    if cube.get(i) == Some(&0) {
-        // Use 8 as the nearest power of two greater than 6.
-        cube[i] = 8;
-        // We may wrap around to an opposite edge but that will also be water.
-        flood_fill(cube, i.saturating_sub(1));
-        flood_fill(cube, i + 1);
-        flood_fill(cube, i.saturating_sub(SIZE));
-        flood_fill(cube, i + SIZE);
-        flood_fill(cube, i.saturating_sub(SIZE * SIZE));
-        flood_fill(cube, i + SIZE * SIZE);
-    }
-}
