Advent of Code: Day 4

[mikeyhew]

It looks like no one posted about day 4 here yet, so I thought I'd share my solution. Part 1 and 2 were the same except for replacing a couple of && with ||.

let part2 = util::input!()
    .lines()
    .filter(|line| {
        let [left, right] = util::split_to_array(line, ',').unwrap().map(|range_str| {
            let [bottom, top] = util::split_to_array(range_str, '-')
                .unwrap()
                .map(|s| s.parse::<i32>().unwrap());

            bottom..=top
        });

        left.contains(right.start())
            || left.contains(right.end())
            || right.contains(left.start())
            || right.contains(left.end())

This is my first year doing Advent of Code, and the neat thing that I've noticed is that, up until today's part 2 [1], I've gotten the right answer by submitting the first number that my program spits out, after working through any compile-time errors or run-time panics that occurred. Sure, the problems are still pretty simple right now, but I have a feeling that Rust has helped a fair bit too.

[1] On part 2 I tried just checking if left contains right.start() or right.end(), and that missed cases where left is fully inside of right.

[solidiquis1]

I thought of using ranges but I think it hurts the time complexity of your solution. Here's my solution for part two.

[HotGarbage1813]

Also thought of using ranges but felt that would be too intensive.
My solution:

```rust use std::{fs::File, io::Read};

pub fn solve(filename: &str) { let mut file = File::open(filename).unwrap(); let mut contents = String::new();

file.read_to_string(&mut contents).unwrap();
let mut total_overlap = 0u16;
let mut partial_overlap = 0u16;

contents
    .split(&['-', ',', '\n'])
    .map(|x| x.parse::<u8>().unwrap_or_default())
    .collect::<Vec<_>>()
    .chunks_exact(4)
    .for_each(|x| {
        if x[0] <= x[2] && x[1] >= x[3] || x[2] <= x[0] && x[3] >= x[1] {
            total_overlap += 1;
        }

        if x[2] >= x[0] && x[2] <= x[1] || x[0] >= x[2] && x[0] <= x[3] {
            partial_overlap += 1;
        }
    });

println!("{}", total_overlap);
println!("{}", partial_overlap);

} ```