327 lines
9.1 KiB
Rust
327 lines
9.1 KiB
Rust
use super::template::{DayTrait, ResultType};
|
|
use crate::common::{file::split_lines, pos::Pos};
|
|
use itertools::Itertools;
|
|
use once_cell::sync::Lazy;
|
|
use regex::Regex;
|
|
use std::{collections::HashSet, num::ParseIntError};
|
|
use thiserror::Error;
|
|
|
|
const DAY_NUMBER: usize = 15;
|
|
|
|
pub struct Day;
|
|
|
|
impl DayTrait for Day {
|
|
fn get_day_number(&self) -> usize {
|
|
DAY_NUMBER
|
|
}
|
|
|
|
fn part1(&self, lines: &str) -> anyhow::Result<ResultType> {
|
|
let lines = split_lines(lines).collect_vec();
|
|
if lines.len() < 2 {
|
|
Err(SensorError::ToFewLines)?;
|
|
}
|
|
let row = lines[0].parse()?;
|
|
let (sensors, beacons) = Day::parse_all(&lines[1..])?;
|
|
let result = Day::count_coverage_at(&sensors, &beacons, row);
|
|
Ok(ResultType::Integer(result))
|
|
}
|
|
|
|
fn part2(&self, lines: &str) -> anyhow::Result<ResultType> {
|
|
let lines = split_lines(lines).collect_vec();
|
|
if lines.len() < 2 {
|
|
Err(SensorError::ToFewLines)?;
|
|
}
|
|
let (sensors, _) = Day::parse_all(&lines[1..])?;
|
|
let mid_lines = Day::dividing_lines(&sensors);
|
|
let points = mid_lines
|
|
.iter()
|
|
.tuple_combinations()
|
|
.filter_map(|(first, second)| first.cross(second))
|
|
.filter(|pos| sensors.iter().all(|sensor| !sensor.contains(pos)))
|
|
.dedup()
|
|
.collect::<Vec<_>>();
|
|
|
|
if points.len() != 1 {
|
|
Err(SensorError::NotExactlyOneResult(points.len()))?;
|
|
}
|
|
|
|
let point = points.first().unwrap();
|
|
Ok(ResultType::Integer(point.x() * 4000000 + point.y()))
|
|
}
|
|
}
|
|
|
|
impl Day {
|
|
fn parse_all(lines: &[&str]) -> Result<(HashSet<Sensor>, HashSet<Pos<i64>>), SensorError> {
|
|
let mut sensors = HashSet::new();
|
|
let mut beacons = HashSet::new();
|
|
for line in lines {
|
|
let (sensor, beacon) = Sensor::parse(line)?;
|
|
sensors.insert(sensor);
|
|
beacons.insert(beacon);
|
|
}
|
|
Ok((sensors, beacons))
|
|
}
|
|
|
|
fn count_coverage_at(sensors: &HashSet<Sensor>, beacons: &HashSet<Pos<i64>>, row: i64) -> i64 {
|
|
let ranges = sensors
|
|
.iter()
|
|
.filter_map(|sensor| sensor.range_at(row))
|
|
.collect::<Vec<_>>();
|
|
let merged: i64 = Range::merge_all(&ranges)
|
|
.iter()
|
|
.map(|range| range.width())
|
|
.sum();
|
|
let sensors = sensors
|
|
.iter()
|
|
.filter(|sensor| sensor.pos.y() == row)
|
|
.count() as i64;
|
|
let beacons = beacons.iter().filter(|beacons| beacons.y() == row).count() as i64;
|
|
|
|
merged - (sensors + beacons)
|
|
}
|
|
|
|
fn dividing_lines(sensors: &HashSet<Sensor>) -> Vec<Line> {
|
|
sensors
|
|
.iter()
|
|
.tuple_combinations()
|
|
.filter_map(|(first, second)| Line::create(first, second))
|
|
.collect()
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Error)]
|
|
enum SensorError {
|
|
#[error("Not an Integer")]
|
|
NotAnInt(#[from] ParseIntError),
|
|
|
|
#[error("Unknown line: {0}")]
|
|
UnknownLine(String),
|
|
|
|
#[error("Did not find exactly one point for the sensor: {0}")]
|
|
NotExactlyOneResult(usize),
|
|
|
|
#[error("Too few lines in input.txt")]
|
|
ToFewLines,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct Line {
|
|
start: Pos<i64>,
|
|
is_up: bool,
|
|
steps: i64,
|
|
}
|
|
|
|
impl Line {
|
|
pub fn create(first: &Sensor, second: &Sensor) -> Option<Line> {
|
|
if first.border_distance(second) != 2 {
|
|
return None;
|
|
}
|
|
|
|
let (one, two) = if first.pos.x() < second.pos.x() {
|
|
(first, second)
|
|
} else {
|
|
(second, first)
|
|
};
|
|
|
|
let start;
|
|
let is_up;
|
|
if one.pos.y() < two.pos.y() {
|
|
is_up = true;
|
|
if one.pos.y() + one.radius <= two.pos.y() {
|
|
start = Pos::new(one.pos.x(), one.pos.y() + one.radius + 1);
|
|
} else {
|
|
start = Pos::new(two.pos.x() - two.radius - 1, two.pos.y());
|
|
}
|
|
} else {
|
|
is_up = false;
|
|
if one.pos.y() - one.radius >= two.pos.y() {
|
|
start = Pos::new(one.pos.x(), one.pos.y() - one.radius - 1);
|
|
} else {
|
|
start = Pos::new(two.pos.x() - two.radius - 1, two.pos.y());
|
|
}
|
|
}
|
|
let steps = two.pos.x().min(one.pos.x() + one.radius) - start.x();
|
|
|
|
Some(Line {
|
|
start,
|
|
is_up,
|
|
steps,
|
|
})
|
|
}
|
|
|
|
fn cross(&self, other: &Line) -> Option<Pos<i64>> {
|
|
if self.is_up == other.is_up {
|
|
return None;
|
|
}
|
|
let (bottom_up, top_down) = if self.is_up {
|
|
(self, other)
|
|
} else {
|
|
(other, self)
|
|
};
|
|
|
|
let r2 =
|
|
bottom_up.start.x() + bottom_up.start.y() - (top_down.start.x() + top_down.start.y());
|
|
if r2 % 2 != 0 {
|
|
return None;
|
|
}
|
|
|
|
let r = r2 / 2;
|
|
if r < 0 || r > top_down.steps {
|
|
return None;
|
|
}
|
|
|
|
let pos = top_down.start + Pos::splat(r);
|
|
Some(pos)
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
|
|
struct Range(i64, i64);
|
|
|
|
impl Range {
|
|
fn overlaps(&self, other: &Range) -> bool {
|
|
self.0 <= other.1 && other.0 <= self.1
|
|
}
|
|
|
|
pub fn width(&self) -> i64 {
|
|
self.1 - self.0 + 1
|
|
}
|
|
|
|
pub fn merge_all(ranges: &[Range]) -> Vec<Range> {
|
|
let mut ranges: Vec<Range> = ranges.iter().sorted().copied().collect();
|
|
assert!(!ranges.is_empty());
|
|
loop {
|
|
let mut next = vec![];
|
|
let mut merged = false;
|
|
let mut current = ranges[0];
|
|
for range in &ranges[1..] {
|
|
if current.overlaps(range) {
|
|
current = Range(current.0, current.1.max(range.1));
|
|
merged = true;
|
|
} else {
|
|
next.push(current);
|
|
current = *range;
|
|
}
|
|
}
|
|
next.push(current);
|
|
|
|
if merged {
|
|
ranges = next;
|
|
} else {
|
|
return next;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Eq, Copy, Clone, Hash)]
|
|
struct Sensor {
|
|
pos: Pos<i64>,
|
|
radius: i64,
|
|
}
|
|
|
|
static SENSOR: Lazy<Regex> =
|
|
Lazy::new(|| Regex::new(r"x=(-?\d+), y=(-?\d+).*x=(-?\d+), y=(-?\d+)").unwrap());
|
|
|
|
impl Sensor {
|
|
pub fn parse(line: &str) -> Result<(Sensor, Pos<i64>), SensorError> {
|
|
let caps = SENSOR
|
|
.captures(line)
|
|
.ok_or(SensorError::UnknownLine(line.to_owned()))?;
|
|
let sensor_x = caps.get(1).unwrap().as_str().parse()?;
|
|
let sensor_y = caps.get(2).unwrap().as_str().parse()?;
|
|
let beacon_x = caps.get(3).unwrap().as_str().parse()?;
|
|
let beacon_y = caps.get(4).unwrap().as_str().parse()?;
|
|
let sensor = Pos::new(sensor_x, sensor_y);
|
|
let beacon = Pos::new(beacon_x, beacon_y);
|
|
let radius = sensor.taxicab(&beacon);
|
|
Ok((
|
|
Sensor {
|
|
pos: sensor,
|
|
radius,
|
|
},
|
|
beacon,
|
|
))
|
|
}
|
|
|
|
pub fn range_at(&self, y: i64) -> Option<Range> {
|
|
let distance = (self.pos.y() - y).abs();
|
|
if distance > self.radius {
|
|
None
|
|
} else {
|
|
let extent = self.radius - distance;
|
|
Some(Range(self.pos.x() - extent, self.pos.x() + extent))
|
|
}
|
|
}
|
|
|
|
pub fn border_distance(&self, other: &Sensor) -> i64 {
|
|
let distance = self.pos.taxicab(&other.pos);
|
|
distance - self.radius - other.radius
|
|
}
|
|
|
|
pub fn contains(&self, pos: &Pos<i64>) -> bool {
|
|
self.pos.taxicab(pos) <= self.radius
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use super::*;
|
|
use crate::common::file::read_string;
|
|
use anyhow::Result;
|
|
#[test]
|
|
fn test_parse() -> Result<()> {
|
|
let input = "Sensor at x=2, y=18: closest beacon is at x=-2, y=15";
|
|
let expected = (
|
|
Sensor {
|
|
pos: Pos::new(2, 18),
|
|
radius: 7,
|
|
},
|
|
Pos::new(-2, 15),
|
|
);
|
|
let result = Sensor::parse(input)?;
|
|
assert_eq!(result, expected);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn test_width() {
|
|
let sensor = Sensor {
|
|
pos: Pos::new(8, 7),
|
|
radius: 9,
|
|
};
|
|
assert_eq!(sensor.range_at(17), None);
|
|
assert_eq!(sensor.range_at(7), Some(Range(-1, 17)));
|
|
assert_eq!(sensor.range_at(10), Some(Range(2, 14)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_merge() {
|
|
let input = vec![Range(4, 10), Range(1, 3), Range(5, 9), Range(8, 12)];
|
|
let expected = vec![Range(1, 3), Range(4, 12)];
|
|
assert_eq!(Range::merge_all(&input), expected);
|
|
}
|
|
|
|
#[test]
|
|
fn test_part1() -> Result<()> {
|
|
let day = Day {};
|
|
let lines = read_string(day.get_day_number(), "example01.txt")?;
|
|
let expected = ResultType::Integer(26);
|
|
let result = day.part1(&lines)?;
|
|
assert_eq!(result, expected);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn test_part2() -> Result<()> {
|
|
let day = Day {};
|
|
let lines = read_string(day.get_day_number(), "example01.txt")?;
|
|
let expected = ResultType::Integer(56000011);
|
|
let result = day.part2(&lines)?;
|
|
assert_eq!(result, expected);
|
|
|
|
Ok(())
|
|
}
|
|
}
|