Tidy code

Author: maneatingape

src/lib.rs

@@ -13,7 +13,9 @@
 macro_rules! library {
     ($year:tt $description:literal $($day:tt),*) => {
         #[doc = concat!("# ", $description)]
-        pub mod $year {$(pub mod $day;)*}
+        pub mod $year {
+            $(pub mod $day;)*
+        }
     }
 }
 

src/main.rs

@@ -3,30 +3,32 @@ use aoc::util::parse::*;
 use aoc::*;
 use std::env::args;
 use std::fs::read_to_string;
-use std::iter::empty;
 use std::time::{Duration, Instant};
 
 fn main() {
     // Parse command line options
-    let args: Vec<_> = args().collect();
-    let args: Vec<_> = args.iter().map(String::as_str).collect();
-    let mut iter = args.iter().flat_map(|arg| arg.iter_unsigned::<u32>());
+    let mut iter = args().flat_map(|arg| arg.as_str().iter_unsigned().collect::<Vec<u32>>());
     let (year, day) = (iter.next(), iter.next());
 
+    let solutions = [
+        year2015(),
+        year2016(),
+        year2017(),
+        year2018(),
+        year2019(),
+        year2020(),
+        year2021(),
+        year2022(),
+        year2023(),
+        year2024(),
+    ];
+
     // Filter solutions then pretty print output.
-    let (stars, duration) = empty()
-        .chain(year2015())
-        .chain(year2016())
-        .chain(year2017())
-        .chain(year2018())
-        .chain(year2019())
-        .chain(year2020())
-        .chain(year2021())
-        .chain(year2022())
-        .chain(year2023())
-        .chain(year2024())
-        .filter(|solution| year.is_none_or(|y| y == solution.year))
-        .filter(|solution| day.is_none_or(|d| d == solution.day))
+    let (stars, duration) = solutions
+        .into_iter()
+        .flatten()
+        .filter(|s| year.is_none_or(|y| y == s.year))
+        .filter(|s| day.is_none_or(|d| d == s.day))
         .fold((0, Duration::ZERO), |(stars, duration), Solution { year, day, wrapper }| {
             let path = format!("input/year{year}/day{day:02}.txt");
 
@@ -50,7 +52,7 @@ fn main() {
         });
 
     // Optionally print totals.
-    if args.contains(&"--totals") {
+    if args().any(|arg| arg == "--totals") {
         println!("{BOLD}{YELLOW}⭐ {}{RESET}", stars);
         println!("{BOLD}{WHITE}🕓 {} ms{RESET}", duration.as_millis());
     }

src/util/grid.rs

@@ -60,12 +60,11 @@ impl Grid<u8> {
 impl<T: Copy + PartialEq> Grid<T> {
     #[inline]
     pub fn find(&self, needle: T) -> Option<Point> {
-        let to_point = |index| {
+        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)
-        };
-        self.bytes.iter().position(|&h| h == needle).map(to_point)
+        })
     }
 }
 

src/util/parse.rs

@@ -105,16 +105,15 @@ fn try_unsigned<T: Unsigned<T>>(bytes: &mut Bytes<'_>) -> Option<T> {
         }
     };
 
-    loop {
-        let Some(byte) = bytes.next() else { break Some(n) };
+    for byte in bytes {
         let digit = byte.to_decimal();
-
-        if digit < 10 {
-            n = T::TEN * n + T::from(digit);
-        } else {
-            break Some(n);
+        if digit >= 10 {
+            break;
         }
+        n = T::TEN * n + T::from(digit);
     }
+
+    Some(n)
 }
 
 fn try_signed<T: Signed<T>>(bytes: &mut Bytes<'_>) -> Option<T> {
@@ -130,16 +129,13 @@ fn try_signed<T: Signed<T>>(bytes: &mut Bytes<'_>) -> Option<T> {
         }
     };
 
-    loop {
-        let Some(byte) = bytes.next() else {
-            break Some(if negative { -n } else { n });
-        };
+    for byte in bytes {
         let digit = byte.to_decimal();
-
-        if digit < 10 {
-            n = T::TEN * n + T::from(digit);
-        } else {
-            break Some(if negative { -n } else { n });
+        if digit >= 10 {
+            break;
         }
+        n = T::TEN * n + T::from(digit);
     }
+
+    Some(if negative { -n } else { n })
 }

src/util/thread.rs

@@ -87,7 +87,7 @@ impl<'a, T> Iterator for ParIter<'a, T> {
 
                     (size > 0).then_some((other, current, size))
                 })
-                .max_by_key(|t| t.2);
+                .max_by_key(|&(_, _, size)| size);
 
             if let Some((other, current, size)) = available {
                 // Split the work items into two roughly equal piles.

src/year2016/day06.rs

@@ -18,9 +18,9 @@ pub fn parse(input: &str) -> Input {
             input.iter().skip(offset).step_by(stride).for_each(|&b| freq[to_index(b)] += 1);
 
             let (max, _) =
-                freq.iter().enumerate().filter(|(_, f)| **f > 0).max_by_key(|(_, f)| **f).unwrap();
+                freq.iter().enumerate().filter(|&(_, &f)| f > 0).max_by_key(|&(_, &f)| f).unwrap();
             let (min, _) =
-                freq.iter().enumerate().filter(|(_, f)| **f > 0).min_by_key(|(_, f)| **f).unwrap();
+                freq.iter().enumerate().filter(|&(_, &f)| f > 0).min_by_key(|&(_, &f)| f).unwrap();
 
             (to_char(max), to_char(min))
         })

src/year2017/day07.rs

@@ -60,7 +60,7 @@ pub fn parse(input: &str) -> Input<'_> {
     }
 
     // The root is the only node without a parent.
-    let part_one = indices.iter().find(|(_, v)| !nodes[**v].has_parent).unwrap().0;
+    let part_one = indices.iter().find(|&(_, &v)| !nodes[v].has_parent).unwrap().0;
     let mut part_two = 0;
 
     while let Some(index) = todo.pop_front() {

src/year2018/day04.rs

@@ -43,7 +43,7 @@ fn choose(input: &Input, strategy: fn(&(&usize, &[u32; 60])) -> u32) -> usize {
     // Find the guard using a specific strategy.
     let (id, minutes) = input.iter().max_by_key(strategy).unwrap();
     // Find the minute spent asleep the most
-    let (minute, _) = minutes.iter().enumerate().max_by_key(|(_, m)| **m).unwrap();
+    let (minute, _) = minutes.iter().enumerate().max_by_key(|&(_, &m)| m).unwrap();
     // Return result
     id * minute
 }

src/year2023/day16.rs

@@ -58,7 +58,7 @@ impl BitSet {
     }
 
     fn union(&mut self, other: &BitSet) {
-        self.bits.iter_mut().zip(other.bits.iter()).for_each(|(a, b)| *a |= b);
+        self.bits.iter_mut().zip(&other.bits).for_each(|(a, b)| *a |= b);
     }
 
     fn size(&self) -> u32 {
@@ -236,8 +236,8 @@ fn strong_connect(graph: &mut Graph, position: Point) -> usize {
         {
             let other = &graph.nodes[next];
             node.tiles.union(&other.tiles);
-            node.from.extend(other.from.iter());
-            node.to.extend(other.to.iter());
+            node.from.extend(&other.from);
+            node.to.extend(&other.to);
         }
 
         // Mark node as done.

src/year2023/day23.rs

@@ -209,8 +209,8 @@ pub fn part1(input: &Input) -> u32 {
 
     for y in 0..6 {
         for x in 0..6 {
-            let left = if x == 0 { 0 } else { total[y][x - 1] + input.horizontal[y][x - 1] };
-            let above = if y == 0 { 0 } else { total[y - 1][x] + input.vertical[y - 1][x] };
+            let left = if x > 0 { total[y][x - 1] + input.horizontal[y][x - 1] } else { 0 };
+            let above = if y > 0 { total[y - 1][x] + input.vertical[y - 1][x] } else { 0 };
             total[y][x] = left.max(above);
         }
     }
@@ -255,15 +255,17 @@ pub fn part2(input: &Input) -> u32 {
         for ((row, gap), steps) in current.drain() {
             for &(next_row, next_gap, horizontal, vertical) in &graph[&row] {
                 // Only 1 gap total is allowed, otherwise we can make a longer path.
-                if !(gap && next_gap) {
-                    // The bit sets represent the horizonal and vertical moves from the
-                    // previous row.
-                    let extra = horizontal.biterator().map(|x| input.horizontal[y][x]).sum::<u32>()
-                        + vertical.biterator().map(|x| input.vertical[y][x]).sum::<u32>();
-
-                    let e = next.entry((next_row, gap || next_gap)).or_insert(0);
-                    *e = (*e).max(steps + extra);
+                if gap && next_gap {
+                    continue;
                 }
+
+                // The bit sets represent the horizontal and vertical moves from the previous row.
+                let extra = horizontal.biterator().map(|x| input.horizontal[y][x]).sum::<u32>()
+                    + vertical.biterator().map(|x| input.vertical[y][x]).sum::<u32>();
+
+                // De-duplicate states so that each row has at most 76 states.
+                let e = next.entry((next_row, gap || next_gap)).or_insert(0);
+                *e = (*e).max(steps + extra);
             }
         }
 
@@ -274,7 +276,7 @@ pub fn part2(input: &Input) -> u32 {
     input.extra + current[&(end, true)]
 }
 
-/// Convert maze to unidrected graph.
+/// Convert maze to undirected graph.
 fn compress(input: &str) -> Graph {
     let mut grid = Grid::parse(input);
     let width = grid.width;
@@ -390,7 +392,7 @@ fn graph_to_grid(graph: &Graph) -> Input {
 
             let (&next, _) = edges
                 .iter()
-                .find(|(k, v)| v.contains(&above) && v.contains(&left) && seen.insert(**k))
+                .find(|&(&k, v)| v.contains(&above) && v.contains(&left) && seen.insert(k))
                 .unwrap();
 
             grid[y][x] = next;