Compiler Explorer

Source code

use std::{cmp::{max, min}, ops::RangeInclusive};

pub fn input_generator(input: &str) -> (isize, isize, isize, isize) {
    let (_, coords) = input.split_once(": ").expect("valid message");
    let (xcoords, ycoords) = coords.split_once(", ").expect("valid message");
    let xcoords = xcoords.strip_prefix("x=").expect("valid message");
    let ycoords = ycoords.strip_prefix("y=").expect("valid message");
    let (xmin, xmax) = xcoords.split_once("..").expect("valid message");
    let (ymin, ymax) = ycoords.split_once("..").expect("valid message");
    let xmin = xmin.parse().expect("valid message");
    let xmax = xmax.parse().expect("valid message");
    let ymin = ymin.parse().expect("valid message");
    let ymax = ymax.parse().expect("valid message");
    (xmin, xmax, ymin, ymax)
}

macro_rules! all_x {
    ($xmin:expr, $xmax:expr) => {{
        let xmin = { $xmin };
        let xmax = { $xmax };
        assert!(xmin >= 0);
        assert!(xmin <= xmax);
        
        let mut startx = 0usize;
        let mut maxdistancex = 0usize;
        while maxdistancex < xmin as usize {
            startx += 1;
            maxdistancex += startx;
        }
        (startx..xmax as usize + 1)
            .filter_map(move |dx| {
                let mut distance = 0usize;
                let mut startstep = usize::MAX;
                let mut endstep = 0;
                for (step, moveamt) in (0..dx + 1).rev().enumerate() {
                    if distance < xmin as usize {
                        distance += moveamt;
                        continue;
                    } else if distance <= xmax as usize {
                        distance += moveamt;
                        startstep = min(startstep, step);
                        endstep = max(endstep, step);
                    } else {
                        break;
                    }
                }
                if startstep == usize::MAX {
                    None
                } else if endstep == dx {
                    Some((startstep..=usize::MAX, dx))
                } else {
                    Some((startstep..=endstep, dx))
                }
            })
    }};
}

macro_rules! all_y {
    ($ymin:expr, $ymax:expr) => {{
        let ymin = { $ymin };
        let ymax = { $ymax };
        assert!(ymin <= ymax);
        let targety = ymin..=ymax;
        let yrangemax = match (ymin < 0, ymax < 0) {
            (true, true) => -ymin,
            (true, false) => max(-ymin, ymax),
            (false, false) => ymax,
            (false, true) => unreachable!(),
        };

(-yrangemax..yrangemax + 1)
            .filter_map(move |dy| {
                let mut firstrange = None;
                let mut secondrange = None;
                let mut distance = 0;
                let mut prevhit = false;
                let mut hitfrom = 0;
                for (step, moveamt) in (isize::MIN..dy + 1).rev().enumerate() {
                    let hit = targety.contains(&distance);
                    if prevhit != hit {
                        if hit {
                            hitfrom = step;
                        } else {
                            firstrange = Some(hitfrom..=step - 1);
                            if moveamt > 0 {
                                let refect = dy as usize * 2 + 1;
                                let hitfrom2 = refect - (step - 1);
                                let step2 = refect - (hitfrom);
                                secondrange = Some(hitfrom2..=step2);
                            };
                            break;
                        }
                        prevhit = hit;
                    } else if moveamt < 0 && distance < ymin {
                        break;
                    }
                    distance += moveamt;
                }
                if let Some(firstrange) = firstrange {
                    Some(((firstrange, secondrange), dy))
                } else {
                    None
                }
            })
    }};
}

macro_rules! all_velocity {
    ($all_x:expr, $all_y:expr) => {{
        let all_x = { $all_x };
        { $all_y }
            .map(|((range1, range2), dy)| {
                let minstart = *range1.start();
                all_x.iter()
                    .take_while(move |(rangex, _)| *rangex.end() >= minstart)
                    .filter_map(move |(rangex, dx)| {
                        get_first_step(rangex, (&range1, range2.as_ref())).map(|step| (*dx, dy, step))
                    })
            })
            .flatten()
    }};
}

fn get_first_step(xrange: &RangeInclusive<usize>, (yrange1, yrange2): (&RangeInclusive<usize>, Option<&RangeInclusive<usize>>)) -> Option<usize> {
    if yrange1.start() <= xrange.end() && xrange.start() <= yrange1.end() {
        Some(max(*yrange1.start(), *xrange.start()))
    } else if let Some(yrange2) = &yrange2 {
        if yrange2.start() <= xrange.end() && xrange.start() <= yrange2.end() {
            Some(max(*yrange2.start(), *xrange.start()))
        } else {
            None
        }
    } else {
        None
    }
}

pub fn solve_part1(&(xmin, xmax, ymin, ymax): &(isize, isize, isize, isize)) -> Option<isize> {
    let possiblex: Vec<_> = all_x!(xmin, xmax).collect();
    let possiblevelocity = all_velocity!(&possiblex, all_y!(ymin, ymax));
    possiblevelocity
        .map(|(_dx, dy, step)| {
            if dy <= 0 {
                0
            } else if step >= dy as usize {
                (dy * dy + dy) / 2
            } else {
                ((step * step + step) / 2) as isize
            }
        })
        .max()
}

pub fn solve_part2(&(xmin, xmax, ymin, ymax): &(isize, isize, isize, isize)) -> Option<usize> {
    let possiblex: Vec<_> = all_x!(xmin, xmax).collect();
    let possiblevelocity = all_velocity!(&possiblex, all_y!(ymin, ymax));
    Some(possiblevelocity.count())
}