151 lines
4.5 KiB
Rust
151 lines
4.5 KiB
Rust
use crate::utils;
|
|
extern crate regex;
|
|
use regex::Regex;
|
|
|
|
pub fn task1() {
|
|
let input = utils::read_file("input/day23.txt");
|
|
let regex =
|
|
Regex::new(r"^pos=<(?P<x>-?\d+),(?P<y>-?\d+),(?P<z>-?\d+)>, r=(?P<range>\d+)$").unwrap();
|
|
let bots: Vec<Bot> = input
|
|
.lines()
|
|
.map(|line| {
|
|
let m = regex.captures(line).unwrap();
|
|
let x = m["x"].parse::<isize>().unwrap();
|
|
let y = m["y"].parse::<isize>().unwrap();
|
|
let z = m["z"].parse::<isize>().unwrap();
|
|
let range = m["range"].parse::<usize>().unwrap();
|
|
|
|
Bot { x, y, z, range }
|
|
})
|
|
.collect();
|
|
|
|
let big_bot = bots.iter().max_by_key(|it| it.range).unwrap();
|
|
println!("The bot with largest range is {:?}", big_bot);
|
|
|
|
let bots_in_range = bots
|
|
.iter()
|
|
.filter(|other| big_bot.distance(other) <= big_bot.range)
|
|
.count();
|
|
|
|
println!("There are {} bots in range of the big bot.", bots_in_range);
|
|
}
|
|
|
|
pub fn task2() {
|
|
let input = utils::read_file("input/day23.txt");
|
|
let regex =
|
|
Regex::new(r"^pos=<(?P<x>-?\d+),(?P<y>-?\d+),(?P<z>-?\d+)>, r=(?P<range>\d+)$").unwrap();
|
|
let bots: Vec<Bot> = input
|
|
.lines()
|
|
.map(|line| {
|
|
let m = regex.captures(line).unwrap();
|
|
let x = m["x"].parse::<isize>().unwrap();
|
|
let y = m["y"].parse::<isize>().unwrap();
|
|
let z = m["z"].parse::<isize>().unwrap();
|
|
let range = m["range"].parse::<usize>().unwrap();
|
|
|
|
Bot { x, y, z, range }
|
|
})
|
|
.collect();
|
|
|
|
// let r_min = bots.iter().min_by_key(|it| it.range).unwrap().range;
|
|
// let r_max = bots.iter().max_by_key(|it| it.range).unwrap().range;
|
|
// println!("Radius min max: {}/{}", r_min, r_max);
|
|
// let x_min = bots.iter().min_by_key(|it| it.x).unwrap().x;
|
|
// let x_max = bots.iter().max_by_key(|it| it.x).unwrap().x;
|
|
// println!("X range: {}", x_max - x_min);
|
|
// let y_min = bots.iter().min_by_key(|it| it.y).unwrap().y;
|
|
// let y_max = bots.iter().max_by_key(|it| it.y).unwrap().y;
|
|
// println!("Y range: {}", y_max - y_min);
|
|
// let z_min = bots.iter().min_by_key(|it| it.z).unwrap().z;
|
|
// let z_max = bots.iter().max_by_key(|it| it.z).unwrap().z;
|
|
// println!("Z range: {}", z_max - z_min);
|
|
|
|
let neighbor_counts: Vec<(Bot, usize)> = bots
|
|
.iter()
|
|
.flat_map(|bot| bot.corners())
|
|
.map(|corner| {
|
|
let count = bots
|
|
.iter()
|
|
.filter(|bot| bot.distance(&corner) <= bot.range)
|
|
.count();
|
|
(corner, count)
|
|
})
|
|
.collect();
|
|
|
|
let max = neighbor_counts.iter().max_by_key(|it| it.1).unwrap().1;
|
|
|
|
let start = Bot {
|
|
x: 0,
|
|
y: 0,
|
|
z: 0,
|
|
range: 0,
|
|
};
|
|
let candidates = neighbor_counts.iter().filter(|it| it.1 == max).count();
|
|
println!("{} points in range of {} bots", candidates, max);
|
|
let candidate = neighbor_counts
|
|
.iter()
|
|
.filter(|it| it.1 == max)
|
|
.min_by_key(|it| it.0.distance(&start));
|
|
|
|
println!(
|
|
"Corner with most bots in range: {:?}",
|
|
candidate.unwrap().0.distance(&start)
|
|
);
|
|
// wrong: 37446460,43177892,57318660; 137943012; 102224079;
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct Bot {
|
|
x: isize,
|
|
y: isize,
|
|
z: isize,
|
|
range: usize,
|
|
}
|
|
|
|
impl Bot {
|
|
fn distance(&self, other: &Self) -> usize {
|
|
((other.x - self.x).abs() + (other.y - self.y).abs() + (other.z - self.z).abs()) as usize
|
|
}
|
|
|
|
fn corners(&self) -> Vec<Self> {
|
|
vec![
|
|
Bot {
|
|
x: self.x + self.range as isize,
|
|
y: self.y,
|
|
z: self.z,
|
|
range: 0,
|
|
},
|
|
Bot {
|
|
x: self.x - self.range as isize,
|
|
y: self.y,
|
|
z: self.z,
|
|
range: 0,
|
|
},
|
|
Bot {
|
|
x: self.x,
|
|
y: self.y + self.range as isize,
|
|
z: self.z,
|
|
range: 0,
|
|
},
|
|
Bot {
|
|
x: self.x,
|
|
y: self.y - self.range as isize,
|
|
z: self.z,
|
|
range: 0,
|
|
},
|
|
Bot {
|
|
x: self.x,
|
|
y: self.y,
|
|
z: self.z + self.range as isize,
|
|
range: 0,
|
|
},
|
|
Bot {
|
|
x: self.x,
|
|
y: self.y,
|
|
z: self.z - self.range as isize,
|
|
range: 0,
|
|
},
|
|
]
|
|
}
|
|
}
|