Not too tricky today. Part 2 wasn’t as big of a curveball as yesterday thankfully. I don’t think it’s the cleanest code I’ve ever written, but hey - the whole point of this is to get better at Rust, so I’ll definitely be learning as I go, and coming back at the end to clean a lot of these up. I think for this one I’d like to look into a parsing crate like nom to clean up all the spliting and unwrapping in the two from() methods.

https://github.com/capitalpb/advent_of_code_2023/blob/main/src/solvers/day02.rs

#[derive(Debug)]
struct Hand {
    blue: usize,
    green: usize,
    red: usize,
}

impl Hand {
    fn from(input: &str) -> Hand {
        let mut hand = Hand {
            blue: 0,
            green: 0,
            red: 0,
        };

        for color in input.split(", ") {
            let color = color.split_once(' ').unwrap();
            match color.1 {
                "blue" => hand.blue = color.0.parse::().unwrap(),
                "green" => hand.green = color.0.parse::().unwrap(),
                "red" => hand.red = color.0.parse::().unwrap(),
                _ => unreachable!("malformed input"),
            }
        }

        hand
    }
}

#[derive(Debug)]
struct Game {
    id: usize,
    hands: Vec,
}

impl Game {
    fn from(input: &str) -> Game {
        let (id, hands) = input.split_once(": ").unwrap();
        let id = id.split_once(" ").unwrap().1.parse::().unwrap();
        let hands = hands.split("; ").map(Hand::from).collect();
        Game { id, hands }
    }
}

pub struct Day02;

impl Solver for Day02 {
    fn star_one(&self, input: &str) -> String {
        input
            .lines()
            .map(Game::from)
            .filter(|game| {
                game.hands
                    .iter()
                    .all(|hand| hand.blue <= 14 && hand.green <= 13 && hand.red <= 12)
            })
            .map(|game| game.id)
            .sum::()
            .to_string()
    }

    fn star_two(&self, input: &str) -> String {
        input
            .lines()
            .map(Game::from)
            .map(|game| {
                let max_blue = game.hands.iter().map(|hand| hand.blue).max().unwrap();
                let max_green = game.hands.iter().map(|hand| hand.green).max().unwrap();
                let max_red = game.hands.iter().map(|hand| hand.red).max().unwrap();

                max_blue * max_green * max_red
            })
            .sum::()
            .to_string()
    }
}