day04.rs

use std::collections::HashSet;

pub struct Pair {
    one: HashSet<usize>,
    two: HashSet<usize>,
}

fn fill_hash(range: &str) -> HashSet<usize> {
    range
        .split_once('-')
        .and_then(|(start, end)| {
            start.parse().ok().zip(end.parse().ok())
        })
        .map(|(start, end)| (start..=end).collect())
        .unwrap()
}

#[aoc_generator(day4)]
pub fn input_generator(input: &str) -> Vec<Pair> {
    input
        .lines()
        .map(|line| {
            let (left, right) = line.split_once(',').unwrap();

            Pair {
                one: fill_hash(left),
                two: fill_hash(right),
            }
        })
        .collect()
}

#[aoc(day4, part1)]
pub fn solve_part1(input: &Vec<Pair>) -> usize {
    input
        .iter()
        .filter(|pair| pair.one.is_subset(&pair.two) || pair.one.is_superset(&pair.two))
        .count()
}

#[aoc(day4, part2)]
pub fn solve_part2(input: &Vec<Pair>) -> usize {
    input
        .iter()
        .filter(|pair| !pair.one.is_disjoint(&pair.two))
        .count()
}

#[cfg(test)]
mod tests {
    use super::*;

    const TEST: &str = "2-4,6-8
                        2-3,4-5
                        5-7,7-9
                        2-8,3-7
                        6-6,4-6
                        2-6,4-8";

    #[test]
    fn part1_test() {
        assert_eq!(solve_part1(&input_generator(TEST)), 2);
    }

    #[test]
    fn part2_test() {
        assert_eq!(solve_part2(&input_generator(TEST)), 4);
    }
}