Tidy

Author: maneatingape

src/main.rs

@@ -3,7 +3,6 @@ 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() {
@@ -13,18 +12,23 @@ fn main() {
     let mut iter = args.iter().flat_map(|arg| arg.iter_unsigned::<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())
+    let (stars, duration) = solutions
+        .iter()
+        .flatten()
         .filter(|solution| year.is_none_or(|y| y == solution.year))
         .filter(|solution| day.is_none_or(|d| d == solution.day))
         .fold((0, Duration::ZERO), |(stars, duration), Solution { year, day, wrapper }| {

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;