day_03.rs

use std::collections::HashMap;

use aoc_lib::regex;
use common::{solution, Answer};
use nd_vec::{vector, Vec2};

type Pos = Vec2<usize>;

solution!("Gear Ratios", 3);

fn part_a(input: &str) -> Answer {
    parse(input)
        .gears
        .iter()
        .filter(|x| x.part_number)
        .map(|x| x.value)
        .sum::<u32>()
        .into()
}

fn part_b(input: &str) -> Answer {
    parse(input)
        .ratios
        .iter()
        .filter(|(_, vals)| vals.len() == 2)
        .map(|(_, vals)| vals[0] * vals[1])
        .sum::<u32>()
        .into()
}

struct ParseResult {
    gears: Vec<Gear>,
    ratios: HashMap<Pos, Vec<u32>>,
}

fn parse(input: &str) -> ParseResult {
    let mut symbols = HashMap::new();
    for (y, line) in input.lines().enumerate() {
        for (x, c) in line.char_indices() {
            if !c.is_ascii_digit() && c != '.' {
                symbols.insert(vector!(x, y), c);
            }
        }
    }

    let mut gears = Vec::new();
    let mut ratios = HashMap::new();
    for (y, line) in input.lines().enumerate() {
        for m in regex!(r"\d+").find_iter(line) {
            let value = m.as_str().parse().unwrap();

            let mut part_number = false;
            for nx in m.start().saturating_sub(1)..=m.end() {
                for ny in y.saturating_sub(1)..=y + 1 {
                    let pos = vector!(nx, ny);
                    let symbol = symbols.get(&pos);
                    part_number |= symbol.is_some();

                    if symbol == Some(&'*') {
                        ratios.entry(pos).or_insert(Vec::new()).push(value);
                    }
                }
            }

            gears.push(Gear { value, part_number });
        }
    }

    ParseResult { gears, ratios }
}

#[derive(Debug)]
struct Gear {
    value: u32,
    part_number: bool,
}

#[cfg(test)]
mod test {
    use indoc::indoc;

    const CASE: &str = indoc! {"
        467..114..
        ...*......
        ..35..633.
        ......#...
        617*......
        .....+.58.
        ..592.....
        ......755.
        ...$.*....
        .664.598..
    "};

    #[test]
    fn part_a() {
        assert_eq!(super::part_a(CASE), 4361.into());
    }

    #[test]
    fn part_b() {
        assert_eq!(super::part_b(CASE), 467835.into());
    }
}