day6.rs

use std::collections::HashSet;
use super::*;
use std::collections::HashMap;

#[aoc_generator(day6)]
pub fn input_generator(input: &str) -> Vec<(usize, usize)> {
    parse_shit(input.trim()).iter()
        .map(|l| (l[0] + 1000, l[1] + 1000)).collect()
}

fn distance(input: &[(usize, usize)], p: (usize, usize)) -> Option<(usize, usize)> {
    let min = input.iter().map(|x| ((x.0 as isize- p.0 as isize).abs() + (x.1 as isize - p.1  as isize).abs()) as usize).min().unwrap();
    let count = input.iter().filter(|x| ((x.0 as isize- p.0 as isize).abs() + (x.1 as isize - p.1  as isize).abs()) as usize == min).count();
    // println!("{}, {}, {:?}", count, min, p);
    if count == 1 {
        Some(input.iter().filter(|x| ((x.0 as isize- p.0 as isize).abs() + (x.1 as isize - p.1  as isize).abs()) as usize == min).next().unwrap().clone())
    } else {
        // println!("{}, {}, {:?}", count, min, p);

        None
    }
}

fn total_distance(input: &[(usize, usize)], p: (usize, usize)) -> usize {
    input.iter().map(|x| ((x.0 as isize- p.0 as isize).abs() + (x.1 as isize - p.1  as isize).abs()) as usize).sum()
}

#[aoc(day6, part1)]
pub fn part1(input: &[(usize, usize)]) -> usize {
    let mut map = HashMap::new();
    let mut banned = HashSet::new();

    for i in 0..2500 {
        for j in 0..2500 {
            let distance = distance(input, (i, j));
            if let Some(distance) = distance {
                *map.entry(distance).or_insert(0) += 1;
                if i ==0 || i == 2499 || j == 0 || j == 2499 {
                    banned.insert(distance);
                }
            }
        }
    }

    println!("{:?}", map);
    println!("{:?}", banned);

    *map.iter().filter(|(k, v)| {!banned.contains(k)}).map(|(_, v)| v).max().unwrap()
}


#[aoc(day6, part2)]
pub fn part2(input: &[(usize, usize)]) -> usize {
    let mut sum = 0;
    for i in 0..2500 {
        for j in 0..2500 {
            if total_distance(input, (i, j)) < 10_000 {
                sum += 1;
            }
        }
    }

sum}