solve: day18

Author: tom-anders

Cargo.toml

@@ -2,7 +2,7 @@
 resolver = "2"
 members = [
     "utils",
-    "aoc_derive", "day1", "day2", "day3", "day4", "day5", "day6", "day7", "day8", "day9", "day10", "day11", "day12", "day13", "day14", "day15", "day16", "day17",
+    "aoc_derive", "day1", "day2", "day3", "day4", "day5", "day6", "day7", "day8", "day9", "day10", "day11", "day12", "day13", "day14", "day15", "day16", "day17", "day18",
 ]
 
 [workspace.dependencies]

aoc_derive/src/lib.rs

@@ -4,9 +4,13 @@ use syn::{parse_macro_input, Expr, ExprLit, Lit};
 
 // Uses syn (v2) to parse the macro #[aoc_main(1)]
 #[proc_macro_attribute]
-pub fn aoc_main(_args: TokenStream, item: TokenStream) -> TokenStream {
+pub fn aoc_main(args: TokenStream, item: TokenStream) -> TokenStream {
     let solve_fn = parse_macro_input!(item as syn::ItemFn);
 
+    let args = proc_macro2::TokenStream::from(args);
+
+    //let args = parse_macro_input!(args with Punctuated::<Meta, syn::Token![,]>::parse_terminated);
+
     let solve_fn_identifier = solve_fn.sig.ident.clone();
 
     quote! {
@@ -15,7 +19,7 @@ pub fn aoc_main(_args: TokenStream, item: TokenStream) -> TokenStream {
         fn main() {
             let input_file = std::env::args().nth(1).expect("Expect input file as first argument");
             let start_time = std::time::Instant::now();
-            let solution: Solution = #solve_fn_identifier(Input::new(&input_file)).into();
+            let solution: Solution = #solve_fn_identifier(Input::new(&input_file), #args).into();
             println!("{}", solution);
             println!("Time: {:.1?}", start_time.elapsed());
             solution.copy_to_clipboard();

day18/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "day18"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+aoc_derive.path = '../aoc_derive'
+utils.path = '../utils'
+derive_more.workspace = true
+itertools.workspace = true
+lazy-regex.workspace = true
+parse-display.workspace = true
+rayon.workspace = true
+regex.workspace = true
+num.workspace = true
+
+[dev-dependencies]
+pretty_assertions.workspace = true

day18/src/main.rs

@@ -0,0 +1,87 @@
+use std::iter::repeat_n;
+
+use aoc_derive::aoc_main;
+use derive_more::derive::{Deref, DerefMut, From};
+use graphs::{UnweightedGraph, bfs};
+use grid::Grid;
+use math::Vec2D;
+use utils::*;
+
+#[derive(Debug, Clone, Deref, DerefMut, From)]
+struct Map(Grid<char>);
+
+impl UnweightedGraph for Map {
+    type Node = Vec2D;
+
+    fn neighbors<'a, 'b: 'a>(&'a self, node: &'b Vec2D) -> impl Iterator<Item = Vec2D> + 'a {
+        self.orthogonal_neighbors(node).filter(|n| self.get(*n) == Some(&'.'))
+    }
+}
+
+#[aoc_main(70, 1024)]
+fn solve(input: Input, size: usize, num_bytes: usize) -> impl Into<Solution> {
+    let mut map = Map::from(repeat_n(repeat_n('.', size + 1), size + 1).collect::<Grid<char>>());
+    let mut bytes = input.lines().map(extract_two_numbers);
+
+    let (start, end) = ((0, 0), (size, size));
+
+    let part1 = {
+        let mut map = map.clone();
+        for byte in bytes.clone().take(num_bytes) {
+            map[byte] = '#';
+        }
+
+        bfs(&map, start, end).distance.unwrap()
+    };
+
+    let part2 = bytes
+        .find(|&byte| {
+            map[byte] = '#';
+            bfs(&map, start, end).distance.is_none()
+        })
+        .unwrap();
+
+    (part1, format!("{},{}", part2.x, part2.y))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_examples() {
+        assert_eq!(
+            solve(
+                r#"5,4
+4,2
+4,5
+3,0
+2,1
+6,3
+2,4
+1,5
+0,6
+3,3
+2,6
+5,1
+1,2
+5,5
+2,5
+6,5
+1,4
+0,4
+6,4
+1,1
+6,1
+1,0
+0,5
+1,6
+2,0"#
+                    .into(),
+                6,
+                12
+            )
+            .into(),
+            Solution::from((22, "6,1".to_string()))
+        );
+    }
+}

utils/src/graphs.rs

@@ -20,21 +20,22 @@ pub trait UnweightedGraph {
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct BfsResult<N: Node> {
-    distance: Option<usize>,
-    visited: HashSet<N>,
+    pub distance: Option<usize>,
+    pub visited: HashSet<N>,
 }
 
 pub fn bfs<N: Node>(
     graph: &impl UnweightedGraph<Node = N>,
     start: impl Into<N>,
-    end: impl Into<N>) -> BfsResult<N> {
+    end: impl Into<N>,
+) -> BfsResult<N> {
     bfs_impl(graph, start, Some(end.into()))
 }
 
-
 pub fn floodfill<N: Node>(
     graph: &impl UnweightedGraph<Node = N>,
-    start: impl Into<N>) -> HashSet<N> {
+    start: impl Into<N>,
+) -> HashSet<N> {
     bfs_impl(graph, start, None).visited
 }
 

utils/src/input.rs

@@ -4,6 +4,7 @@ use itertools::Itertools;
 
 use crate::{grid::Grid, math::Vec2D, sparse_grid::SparseGrid};
 
+#[derive(Debug, Clone)]
 pub struct Input {
     pub raw: String,
 }
@@ -31,7 +32,7 @@ impl Input {
         self.raw.len()
     }
 
-    pub fn lines(&self) -> impl Iterator<Item = &str> + '_ {
+    pub fn lines(&self) -> impl Iterator<Item = &str> + Clone + '_ {
         self.raw.lines()
     }