dumb_shit/2022-aoc/src/d4.rs

use std::ops::RangeInclusive;

use aoc_runner_derive::{aoc as aoc_run, aoc_generator};

type Contents = (RangeInclusive<u32>, RangeInclusive<u32>);

#[aoc_generator(day4)]
fn parse_input(input: &str) -> Vec<Contents> {
    let mut out = Vec::with_capacity(input.len());
    for line in input.lines() {
        let mut split = line.split(',');
        let a = split.next().unwrap();
        let b = split.next().unwrap();
        let mut asplit = a.split('-');
        let mut bsplit = b.split('-');
        let alo = asplit.next().unwrap().parse().unwrap();
        let ahi = asplit.next().unwrap().parse().unwrap();
        let blo = bsplit.next().unwrap().parse().unwrap();
        let bhi = bsplit.next().unwrap().parse().unwrap();
        out.push(((alo..=ahi), (blo..=bhi)));
    }

    out
}

// with tuples instead of ranges
type AltContents = ((u32, u32), (u32, u32));

#[aoc_generator(day4, part1, alt1)]
fn parse_input1a(input: &str) -> Vec<AltContents> {
    let mut out = Vec::with_capacity(input.len());
    for line in input.lines() {
        let (a, b) = line.split_once(',').unwrap();
        let (alo, ahi) = a.split_once('-').unwrap();
        let (alo, ahi) = (alo.parse().unwrap(), ahi.parse().unwrap());
        let (blo, bhi) = b.split_once('-').unwrap();
        let (blo, bhi) = (blo.parse().unwrap(), bhi.parse().unwrap());
        out.push(((alo, ahi), (blo, bhi)));
    }

    out
}

// can't define a blanket alt generator?
#[aoc_generator(day4, part2, alt1)]
fn p2a(input: &str) -> Vec<AltContents> {
    parse_input1a(input)
}

#[aoc_run(day4, part1)]
fn part1(scheds: &[Contents]) -> u32 {
    let mut out = 0;
    for (a, b) in scheds {
        if (a.contains(b.start()) && a.contains(b.end()))
            || (b.contains(a.start()) && b.contains(a.end()))
        {
            out += 1;
        }
    }
    out
}

#[aoc_run(day4, part2)]
fn part2(scheds: &[Contents]) -> u32 {
    let mut out = 0;
    for (a, b) in scheds {
        if (a.contains(b.start()) || a.contains(b.end()))
            || (b.contains(a.start()) || b.contains(a.end()))
        {
            out += 1;
        }
    }
    out
}

#[aoc_run(day4, part1, alt1)]
fn part1a(scheds: &[AltContents]) -> u32 {
    let mut out = 0;
    for (a, b) in scheds {
        if (a.0 <= b.0 && b.1 <= a.1) || (b.0 <= a.0 && a.1 <= b.1) {
            out += 1;
        }
    }
    out
}

#[aoc_run(day4, part2, alt1)]
fn part2a(scheds: &[AltContents]) -> u32 {
    let mut out = 0;
    for (a, b) in scheds {
        if (a.0 <= b.0 && b.0 <= a.1) || (b.0 <= a.0 && a.0 <= b.1) {
            out += 1;
        }
    }
    out
}