84 lines
2.1 KiB
Rust
84 lines
2.1 KiB
Rust
#![warn(clippy::pedantic)]
|
|
use std::{
|
|
collections::HashMap,
|
|
convert::Infallible,
|
|
io::{stdin, BufRead},
|
|
str::FromStr,
|
|
};
|
|
use vector2d::Vector2D;
|
|
|
|
#[derive(Copy, Clone, Debug)]
|
|
struct Line {
|
|
start: Vector2D<usize>,
|
|
end: Vector2D<usize>,
|
|
}
|
|
|
|
impl Line {
|
|
pub fn is_straight(&self) -> bool {
|
|
self.start.x == self.end.x || self.start.y == self.end.y
|
|
}
|
|
|
|
pub fn expand(&self) -> Vec<Vector2D<usize>> {
|
|
let delta = self.end.as_isizes() - self.start.as_isizes();
|
|
|
|
#[allow(clippy::if_not_else)]
|
|
let len = if delta.x != 0 {
|
|
delta.x.abs()
|
|
} else if delta.y != 0 {
|
|
delta.y.abs()
|
|
} else {
|
|
unreachable!()
|
|
};
|
|
|
|
let step = delta / len;
|
|
|
|
(0..=len)
|
|
.scan(self.start, |acc, _| {
|
|
let prev = *acc;
|
|
*acc = (acc.as_isizes() + step).as_usizes();
|
|
Some(prev)
|
|
})
|
|
.collect()
|
|
}
|
|
}
|
|
|
|
impl FromStr for Line {
|
|
type Err = Infallible;
|
|
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
let parts: Vec<_> = s.split(' ').collect();
|
|
let start: Vec<_> = parts[0].split(',').map(|n| n.parse().unwrap()).collect();
|
|
let end: Vec<_> = parts[2].split(',').map(|n| n.parse().unwrap()).collect();
|
|
|
|
Ok(Line {
|
|
start: Vector2D::new(start[0], start[1]),
|
|
end: Vector2D::new(end[0], end[1]),
|
|
})
|
|
}
|
|
}
|
|
|
|
fn count_overlaps<'a>(it: impl IntoIterator<Item = &'a Line>) -> usize {
|
|
let counts: HashMap<(usize, usize), usize> =
|
|
it.into_iter()
|
|
.flat_map(Line::expand)
|
|
.fold(HashMap::new(), |mut map, point| {
|
|
*map.entry(point.into()).or_default() += 1;
|
|
map
|
|
});
|
|
counts.into_iter().filter(|&(_k, v)| v >= 2).count()
|
|
}
|
|
|
|
fn main() {
|
|
let lines: Vec<Line> = stdin()
|
|
.lock()
|
|
.lines()
|
|
.map(|s| s.unwrap().parse().unwrap())
|
|
.collect();
|
|
|
|
println!(
|
|
"{}",
|
|
count_overlaps(lines.iter().filter(|line| line.is_straight()))
|
|
);
|
|
println!("{}", count_overlaps(&lines));
|
|
}
|