AOC 2023 Day 4

use std::env;
use std::io::{self, prelude::*, BufReader};
use std::fs::File;
use std::collections::{HashSet,HashMap};

extern crate regex;
use regex::Regex;

struct Card {
    id: usize,
    winning: HashSet<usize>,
    my_numbers: HashSet<usize>,
}
impl From<&String> for Card {
    fn from(s: &String) -> Self {
        let re = Regex::new(r"Card[\s]+(\d+): ([\d\s]+) \| ([\d\s]+)").unwrap();
        let matches = re.captures(&s).unwrap();
        Self {
            id:         matches[1].parse().unwrap(),
            winning:    matches[2].split_whitespace().map(|x| x.parse::<usize>().unwrap()).collect(),
            my_numbers: matches[3].split_whitespace().map(|x| x.parse::<usize>().unwrap()).collect(),
        }
    }
}
impl Card {
    pub fn matching_numbers(&self) -> usize {
        self.winning.iter().filter(|n| self.my_numbers.contains(n)).count()
    }
    pub fn score(&self) -> usize {
        let common = self.matching_numbers() as u32;
        if common == 0 { 0 } else { usize::pow(2,common-1) }
    }
}

fn solve(input: &str) -> io::Result<()> {
    let file = File::open(input).expect("Input file not found.");
    let reader = BufReader::new(file);

    // Input
    let input: Vec<String> = match reader.lines().collect() {
        Err(err) => panic!("Unknown error reading input: {}", err),
        Ok(result) => result,
    };
    let cards: Vec<_> = input.iter().map(Card::from).collect();

    // Part 1
    let part1: usize = cards.iter().map(|c| c.score()).sum();
    println!("Part 1: {part1}"); // 27454

    // Part 2
    let mut my_cards: HashMap<usize,usize> = HashMap::new();
    for card_id in 1..=cards.len() {
        my_cards.insert(card_id,1);
    }
    for card in cards {
        let count = *my_cards.get(&card.id).unwrap();
        for x in 1..=card.matching_numbers() {
            *my_cards.entry(&card.id+x).or_insert(0) += count;
        }
    }
    let part2: usize = my_cards.iter().map(|(_,v)| v).sum();
    println!("Part 2: {part2}"); // 6857330

    Ok(())
}

fn main() {
    let args: Vec<String> = env::args().collect();
    let filename = &args[1];
    solve(&filename).unwrap();
}