Simplify code

Author: maneatingape

benches/benchmark.rs

@@ -13,13 +13,9 @@ macro_rules! benchmark {
                 use test::Bencher;
 
                 static DATA: LazyLock<String> = LazyLock::new(|| {
-                    let year = stringify!($year);
-                    let day = stringify!($day);
-                    let path = format!("input/{year}/{day}.txt");
-
-                    read_to_string(&path).unwrap_or_else(|_| {
-                        panic!("Missing input file {BOLD}{WHITE}{path}{RESET}");
-                    })
+                    let path = format!("input/{}/{}.txt", stringify!($year), stringify!($day));
+                    read_to_string(&path)
+                        .unwrap_or_else(|_| panic!("Missing input file {BOLD}{WHITE}{path}{RESET}"))
                 });
 
                 #[bench]

src/util/grid.rs

@@ -64,9 +64,8 @@ impl<T: Copy + PartialEq> Grid<T> {
     #[must_use]
     pub fn find(&self, needle: T) -> Option<Point> {
         self.bytes.iter().position(|&h| h == needle).map(|index| {
-            let x = (index as i32) % self.width;
-            let y = (index as i32) / self.width;
-            Point::new(x, y)
+            let index = index as i32;
+            Point::new(index % self.width, index / self.width)
         })
     }
 }

src/year2016/day01.rs

@@ -32,8 +32,10 @@ impl Segment {
 
     // Return the point of intersection between two orthogonal segments, if there is one.
     fn intersects(&self, other: &Segment) -> Option<Point> {
-        let overlap =
-            !(other.x2 < self.x1 || other.x1 > self.x2 || other.y2 < self.y1 || other.y1 > self.y2);
+        let overlap = other.x2 >= self.x1
+            && other.x1 <= self.x2
+            && other.y2 >= self.y1
+            && other.y1 <= self.y2;
         overlap.then_some(Point::new(self.x1.max(other.x1), self.y1.max(other.y1)))
     }
 }

src/year2016/day04.rs

@@ -33,7 +33,7 @@ pub fn parse(input: &str) -> Vec<Room<'_>> {
             if b != b'-' {
                 let index = to_index(b);
                 let current = freq[index];
-                let next = freq[index] + 1;
+                let next = current + 1;
 
                 freq[index] = next;
                 fof[current] -= 1;

src/year2017/day07.rs

@@ -15,8 +15,7 @@ use std::collections::VecDeque;
 
 #[derive(Clone, Copy, Default)]
 struct Node {
-    has_parent: bool,
-    parent: usize,
+    parent: Option<usize>,
     children: usize,
     processed: usize,
     weight: i32,
@@ -49,8 +48,7 @@ pub fn parse(input: &str) -> Input<'_> {
         for edge in iter {
             nodes[i].children += 1;
             let child = indices[edge];
-            nodes[child].parent = i;
-            nodes[child].has_parent = true;
+            nodes[child].parent = Some(i);
         }
 
         // Start with leaf nodes.
@@ -62,14 +60,15 @@ pub fn parse(input: &str) -> Input<'_> {
     // The root is the only node without a parent. Start from any node, and walk up the
     // tree until finding the root.
     let mut candidate = 0;
-    while nodes[candidate].has_parent {
-        candidate = nodes[candidate].parent;
+    while let Some(parent) = nodes[candidate].parent {
+        candidate = parent;
     }
     let part_one = pairs[candidate].0;
     let mut part_two = 0;
 
     while let Some(index) = todo.pop_front() {
         let Node { parent, weight, total, .. } = nodes[index];
+        let parent = parent.unwrap();
         let node = &mut nodes[parent];
 
         if node.processed < 2 {

src/year2021/day13.rs

@@ -74,13 +74,9 @@ pub fn part2(input: &Input) -> String {
 
 #[inline]
 fn apply_fold(fold: Fold, point: Point) -> Point {
-    let horizontal = |p: Point, x: i32| if p.x < x { p } else { Point::new(2 * x - p.x, p.y) };
-    let vertical = |p: Point, y: i32| if p.y < y { p } else { Point::new(p.x, 2 * y - p.y) };
-
     match fold {
-        // Fold point at `x` coordinate, doing nothing if the point is to the left of the fold line.
-        Fold::Horizontal(x) => horizontal(point, x),
-        // Fold point at `y` coordinate, doing nothing if the point is above the fold line.
-        Fold::Vertical(y) => vertical(point, y),
+        Fold::Horizontal(x) if point.x >= x => Point::new(2 * x - point.x, point.y),
+        Fold::Vertical(y) if point.y >= y => Point::new(point.x, 2 * y - point.y),
+        _ => point,
     }
 }

src/year2021/day22.rs

@@ -38,9 +38,7 @@ pub struct RebootStep {
 
 impl RebootStep {
     fn from((command, points): (&str, [i32; 6])) -> RebootStep {
-        let on = command == "on";
-        let cube = Cube::from(points);
-        RebootStep { on, cube }
+        RebootStep { on: command == "on", cube: Cube::from(points) }
     }
 }
 

src/year2022/day17.rs

@@ -35,7 +35,7 @@
 //! We choose an arbitrary length and generate a sequence of that size then search
 //! for repeating patterns. Once we find the length of the cycle then we can extrapolate for
 //! any `n` greater than the start of the cycle.
-use std::iter::{Copied, Cycle};
+use std::iter::{Copied, Cycle, once};
 use std::slice::Iter;
 
 /// Convenience alias to shorten type name.
@@ -135,14 +135,8 @@ pub fn part2(input: &[u8]) -> usize {
     let guess = 1000;
     let height: Vec<_> = State::new(input).take(5 * guess).collect();
     // We compare based on the *delta* between rows instead of absolute heights.
-    let deltas: Vec<_> = height
-        .iter()
-        .scan(0, |state, &height| {
-            let delta = height - *state;
-            *state = height;
-            Some(delta)
-        })
-        .collect();
+    let deltas: Vec<_> =
+        once(height[0]).chain(height.array_windows().map(|[a, b]| b - a)).collect();
 
     // Simple brute force check, instead of a
     // [cycle detection](https://en.wikipedia.org/wiki/Cycle_detection) algorithm.

src/year2025/day09.rs

@@ -142,9 +142,7 @@ pub fn part2(tiles: &[Tile]) -> u64 {
     let mut intervals_from_descending_edges = vec![];
 
     // Invariants on the input data (defined by the puzzle) result in points arriving in pairs on the same y line:
-    let mut it = tiles.iter();
-
-    while let (Some(&[x0, y]), Some(&[x1, y1])) = (it.next(), it.next()) {
+    for [&[x0, y], &[x1, y1]] in tiles.iter().chunk::<2>() {
         debug_assert_eq!(y, y1);
 
         // Update the descending edges; since we are scanning from top to bottom, and within each line left to right,