2022 Day 04

use std::env;
use std::io::{self, prelude::*, BufReader};
use std::fs::File;
use std::ops::RangeInclusive;

extern crate regex;
use regex::Regex;

struct Team {
    elf1: RangeInclusive<usize>,
    elf2: RangeInclusive<usize>,
}
impl Team {
    pub fn has_overlaps1(&self) -> bool {
        (self.elf1.contains(&self.elf2.start()) && self.elf1.contains(&self.elf2.end())) ||
        (self.elf2.contains(&self.elf1.start()) && self.elf2.contains(&self.elf1.end()))
    }
    pub fn has_overlaps2(&self) -> bool {
        self.elf1.contains(&self.elf2.start()) || self.elf1.contains(&self.elf2.end()) ||
        self.elf2.contains(&self.elf1.start()) || self.elf2.contains(&self.elf1.end())
    }
}
impl From<&String> for Team {
    fn from(s: &String) -> Self {
        let re = Regex::new(r"(\d+)\-(\d+),(\d+)\-(\d+)").unwrap();
        let matches = re.captures(s).unwrap();
        Self {
            elf1: RangeInclusive::new(matches[1].parse().unwrap(),matches[2].parse().unwrap()),
            elf2: RangeInclusive::new(matches[3].parse().unwrap(),matches[4].parse().unwrap()),
        }
    }
}

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,
    };

    // Part 1
    let part1 = input
        .iter()
        .map(Team::from)
        .filter(|x| x.has_overlaps1())
        .count();
    println!("Part 1: {:?}", part1); // 450

    // Part 2
    let part2 = input
        .iter()
        .map(Team::from)
        .filter(|x| x.has_overlaps2())
        .count();
    println!("Part 2: {:?}", part2); // 837

    Ok(())
}

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