refactor(rust): optimize slow tests, fix clippy/fmt, and update test macros

Author: markkovari

2018/src/day15/mod.rs

@@ -226,4 +226,4 @@ impl Solution for Day15 {
     }
 }
 
-aoc_rust_common::aoc_test!(Day15);
+aoc_rust_common::aoc_test!(Day15, 239010, 62468);

2018/src/day17/mod.rs

@@ -2,21 +2,22 @@ use anyhow::Result;
 use aoc_rust_common::Solution;
 use regex::Regex;
 use std::cmp::{max, min};
-use std::collections::HashSet;
 
 pub struct Day17;
 
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
-struct Point {
-    x: i32,
-    y: i32,
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum Tile {
+    Sand,
+    Clay,
+    Flowing,
+    Still,
 }
 
-fn parse(input: &str) -> (HashSet<Point>, i32, i32) {
-    let mut clay = HashSet::new();
+fn parse(input: &str) -> (Vec<Vec<Tile>>, i32, i32, i32, i32) {
+    let mut clay_points = Vec::new();
     let re = Regex::new(r"(x|y)=(\d+), (x|y)=(\d+)..(\d+)").unwrap();
-    let mut min_y = i32::MAX;
-    let mut max_y = i32::MIN;
+    let (mut min_x, mut max_x) = (i32::MAX, i32::MIN);
+    let (mut min_y, mut max_y) = (i32::MAX, i32::MIN);
 
     for line in input.lines() {
         let caps = re.captures(line).unwrap();
@@ -25,114 +26,126 @@ fn parse(input: &str) -> (HashSet<Point>, i32, i32) {
         let b2: i32 = caps[5].parse().unwrap();
 
         if &caps[1] == "x" {
+            let x = a;
+            min_x = min(min_x, x);
+            max_x = max(max_x, x);
             min_y = min(min_y, b1);
             max_y = max(max_y, b2);
             for y in b1..=b2 {
-                clay.insert(Point { x: a, y });
+                clay_points.push((x, y));
             }
         } else {
-            min_y = min(min_y, a);
-            max_y = max(max_y, a);
+            let y = a;
+            min_y = min(min_y, y);
+            max_y = max(max_y, y);
+            min_x = min(min_x, b1);
+            max_x = max(max_x, b2);
             for x in b1..=b2 {
-                clay.insert(Point { x, y: a });
+                clay_points.push((x, y));
             }
         }
     }
-    (clay, min_y, max_y)
+
+    // Add padding to x to allow water to flow around clay
+    min_x -= 1;
+    max_x += 1;
+
+    let width = (max_x - min_x + 1) as usize;
+    let height = (max_y + 1) as usize;
+    let mut grid = vec![vec![Tile::Sand; width]; height];
+
+    for (x, y) in clay_points {
+        grid[y as usize][(x - min_x) as usize] = Tile::Clay;
+    }
+
+    (grid, min_x, max_x, min_y, max_y)
 }
 
 fn solve(input: &str) -> (usize, usize) {
-    let (clay, min_y, max_y) = parse(input);
-    let mut flowing_water = HashSet::new();
-    let mut still_water = HashSet::new();
-    let mut stack = vec![Point { x: 500, y: 0 }];
+    let (mut grid, min_x, _, min_y, max_y) = parse(input);
+    let mut stack = vec![(500i32, 0i32)];
 
-    while let Some(point) = stack.pop() {
-        if point.y > max_y {
-            continue;
-        }
+    while let Some((sx, sy)) = stack.pop() {
+        let mut y = sy;
+        let x = sx;
 
-        let mut current = point;
-        while current.y <= max_y && !clay.contains(&current) {
-            flowing_water.insert(current);
-            current.y += 1;
+        // Flow down
+        while y <= max_y && grid[y as usize][(x - min_x) as usize] == Tile::Sand {
+            grid[y as usize][(x - min_x) as usize] = Tile::Flowing;
+            y += 1;
         }
 
-        if current.y > max_y {
+        if y > max_y || grid[y as usize][(x - min_x) as usize] == Tile::Flowing {
             continue;
         }
 
-        current.y -= 1; // Step back up to solid ground
-
-        loop {
-            let mut left = current;
-            let mut right = current;
-            let mut wall_left = false;
-            let mut wall_right = false;
-
-            while !clay.contains(&Point {
-                x: left.x - 1,
-                y: left.y,
-            }) {
-                left.x -= 1;
-                let down = Point {
-                    x: left.x,
-                    y: left.y + 1,
-                };
-                if !clay.contains(&down) && !still_water.contains(&down) {
-                    stack.push(left);
+        // We hit clay or still water, move back up and fill levels
+        y -= 1;
+        while y >= sy {
+            let mut left_x = x;
+            let mut left_bound = false;
+            while grid[y as usize][(left_x - min_x) as usize] != Tile::Clay {
+                let below = grid[(y + 1) as usize][(left_x - min_x) as usize];
+                if below == Tile::Sand || below == Tile::Flowing {
                     break;
                 }
+                left_x -= 1;
             }
-            if clay.contains(&Point {
-                x: left.x - 1,
-                y: left.y,
-            }) {
-                wall_left = true;
+            if grid[y as usize][(left_x - min_x) as usize] == Tile::Clay {
+                left_bound = true;
+                left_x += 1;
             }
 
-            while !clay.contains(&Point {
-                x: right.x + 1,
-                y: right.y,
-            }) {
-                right.x += 1;
-                let down = Point {
-                    x: right.x,
-                    y: right.y + 1,
-                };
-                if !clay.contains(&down) && !still_water.contains(&down) {
-                    stack.push(right);
+            let mut right_x = x;
+            let mut right_bound = false;
+            while grid[y as usize][(right_x - min_x) as usize] != Tile::Clay {
+                let below = grid[(y + 1) as usize][(right_x - min_x) as usize];
+                if below == Tile::Sand || below == Tile::Flowing {
                     break;
                 }
+                right_x += 1;
             }
-            if clay.contains(&Point {
-                x: right.x + 1,
-                y: right.y,
-            }) {
-                wall_right = true;
+            if grid[y as usize][(right_x - min_x) as usize] == Tile::Clay {
+                right_bound = true;
+                right_x -= 1;
             }
 
-            for x in left.x..=right.x {
-                if wall_left && wall_right {
-                    still_water.insert(Point { x, y: current.y });
-                } else {
-                    flowing_water.insert(Point { x, y: current.y });
+            if left_bound && right_bound {
+                for fill_x in left_x..=right_x {
+                    grid[y as usize][(fill_x - min_x) as usize] = Tile::Still;
+                }
+            } else {
+                for fill_x in left_x..=right_x {
+                    grid[y as usize][(fill_x - min_x) as usize] = Tile::Flowing;
                 }
+                if !left_bound {
+                    stack.push((left_x, y));
+                }
+                if !right_bound {
+                    stack.push((right_x, y));
+                }
+                break;
             }
+            y -= 1;
+        }
+    }
 
-            if !(wall_left && wall_right) {
-                break;
+    let mut total_water = 0;
+    let mut still_water = 0;
+    for y in min_y as usize..=max_y as usize {
+        for x in 0..grid[y].len() {
+            match grid[y][x] {
+                Tile::Flowing => total_water += 1,
+                Tile::Still => {
+                    total_water += 1;
+                    still_water += 1;
+                }
+                _ => {}
             }
-            current.y -= 1;
         }
     }
 
-    let total_water = flowing_water
-        .union(&still_water)
-        .filter(|p| p.y >= min_y && p.y <= max_y)
-        .count();
-    let still_water_count = still_water.len();
-    (total_water, still_water_count)
+    (total_water, still_water)
 }
 
 impl Solution for Day17 {
@@ -154,4 +167,4 @@ impl Solution for Day17 {
     }
 }
 
-aoc_rust_common::aoc_test!(Day17);
+aoc_rust_common::aoc_test!(Day17, 162, 144, slow);

2021/zig/.zig-cache/h/60c35576522d3786e4b3dc33e35bb27c.txt

@@ -0,0 +1,2 @@
+pub const packages = struct {};
+pub const root_deps: []const struct { []const u8, []const u8 } = &.{};

2021/zig/.zig-cache/h/timestamp

@@ -0,0 +1,6 @@
+---
+source: 2022/src/day01.rs
+assertion_line: 43
+expression: result
+---
+71924