2023 Day 3.

Author: nerdatmath

2023/03/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "y2023d03"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

2023/03/data/example1

@@ -0,0 +1,10 @@
+467..114..
+...*......
+..35..633.
+......#...
+617*......
+.....+.58.
+..592.....
+......755.
+...$.*....
+.664.598..

2023/03/data/input

@@ -0,0 +1,5 @@
+#[cfg(test)]
+pub const EXAMPLE1: &'static str = include_str!("../data/example1");
+
+#[allow(unused)]
+pub const INPUT: &'static str = include_str!("../data/input");

2023/03/src/data.rs

@@ -0,0 +1,10 @@
+mod data;
+mod part1;
+mod part2;
+mod puzzle;
+
+fn main() {
+    use data::INPUT;
+    println!("Part 1: {}", part1::run(INPUT));
+    println!("Part 2: {}", part2::run(INPUT));
+}

2023/03/src/main.rs

@@ -0,0 +1,29 @@
+use crate::puzzle::{Part, Puzzle, Symbol};
+use std::collections::HashMap;
+
+fn adjacent_to_symbol(part: &Part, symbols: &HashMap<(usize, usize), Symbol>) -> bool {
+    part.adjacent_points()
+        .into_iter()
+        .any(|pos| symbols.contains_key(&pos))
+}
+
+pub fn run(input: &str) -> u32 {
+    let puzzle: Puzzle = input.parse().expect("parse failed");
+    puzzle
+        .parts
+        .into_iter()
+        .filter(|part| adjacent_to_symbol(part, &puzzle.symbols))
+        .map(|part| part.number)
+        .sum()
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::data::EXAMPLE1;
+
+    #[test]
+    fn test1() {
+        assert_eq!(run(EXAMPLE1), 4361);
+    }
+}

2023/03/src/part1/mod.rs

@@ -0,0 +1,37 @@
+use crate::puzzle::{Part, Puzzle, Symbol};
+use std::collections::HashMap;
+
+fn adjacent_gears(
+    part: &Part,
+    symbols: &HashMap<(usize, usize), Symbol>,
+) -> impl IntoIterator<Item = (usize, usize)> {
+    part.adjacent_points()
+        .into_iter()
+        .filter(|pos| symbols.get(pos).is_some_and(Symbol::is_gear))
+}
+
+pub fn run(input: &str) -> u32 {
+    let puzzle: Puzzle = input.parse().expect("parse failed");
+    let mut gears: HashMap<(usize, usize), Vec<&Part>> = <_>::default();
+    for part in &puzzle.parts {
+        for gear in adjacent_gears(part, &puzzle.symbols) {
+            gears.entry(gear).or_default().push(part);
+        }
+    }
+    gears
+        .values()
+        .filter(|parts| parts.len() == 2)
+        .map(|parts| parts[0].number * parts[1].number)
+        .sum()
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::data::EXAMPLE1;
+
+    #[test]
+    fn test1() {
+        assert_eq!(run(EXAMPLE1), 467835);
+    }
+}

2023/03/src/part2/mod.rs

@@ -0,0 +1,76 @@
+use std::collections::HashMap;
+use std::str::FromStr;
+
+#[derive(Debug)]
+pub struct ParseError;
+
+#[derive(Debug, Default)]
+pub struct Puzzle {
+    pub parts: Vec<Part>,
+    pub symbols: HashMap<(usize, usize), Symbol>,
+}
+
+impl FromStr for Puzzle {
+    type Err = ParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut puzzle = Puzzle::default();
+        for (row, line) in s.lines().enumerate() {
+            let mut parsing_part = false;
+            for (col, ch) in line.chars().enumerate() {
+                match ch {
+                    '0'..='9' => {
+                        if !parsing_part {
+                            parsing_part = true;
+                            puzzle.parts.push(Part {
+                                number: 0,
+                                row,
+                                col,
+                                len: 0,
+                            });
+                        }
+                        let part = puzzle.parts.last_mut().unwrap();
+                        part.number = part.number * 10 + ch.to_digit(10).unwrap();
+                        part.len += 1;
+                    }
+                    '.' => parsing_part = false,
+                    _ => {
+                        puzzle.symbols.insert((row, col), Symbol(ch));
+                        parsing_part = false;
+                    }
+                }
+            }
+        }
+        Ok(puzzle)
+    }
+}
+
+#[derive(Debug)]
+pub struct Part {
+    pub number: u32,
+    pub row: usize,
+    pub col: usize,
+    pub len: usize,
+}
+
+impl Part {
+    pub fn adjacent_points(&self) -> impl IntoIterator<Item = (usize, usize)> {
+        let min_col = self.col.saturating_sub(1);
+        let max_col = self.col + self.len;
+        let min_row = self.row.saturating_sub(1);
+        let max_row = self.row + 1;
+        let top = (min_col..=max_col).map(move |col| (min_row, col));
+        let mid = [min_col, max_col].map(|col| (self.row, col));
+        let bot = (min_col..=max_col).map(move |col| (max_row, col));
+        top.chain(mid).chain(bot)
+    }
+}
+
+#[derive(Debug)]
+pub struct Symbol(char);
+
+impl Symbol {
+    pub fn is_gear(&self) -> bool {
+        self.0 == '*'
+    }
+}