178 lines
3.7 KiB
Rust
178 lines
3.7 KiB
Rust
use std::{collections::HashSet, str::FromStr};
|
|
|
|
use serde::{
|
|
de::{value, IntoDeserializer},
|
|
Deserialize,
|
|
};
|
|
|
|
const INPUT: &str = include_str!("../../input/day09.txt");
|
|
|
|
fn main() {
|
|
println!("{}", part1(INPUT));
|
|
}
|
|
|
|
fn part1(input: &str) -> usize {
|
|
let steps = parse_input(input);
|
|
|
|
let num_knots = 10;
|
|
let tail = num_knots - 1;
|
|
|
|
let mut knots = vec![RC::new(0, 0); num_knots];
|
|
|
|
let mut tail_visited: HashSet<RC> = HashSet::new();
|
|
tail_visited.insert(knots[tail]);
|
|
|
|
// render(&knots, &tail_visited);
|
|
for step in steps {
|
|
println!("> {:?}, {}", step.d, step.n);
|
|
|
|
for _ in 0..(step.n) {
|
|
knots[0] = knots[0].mv(step.d.delta());
|
|
for i in 1..(knots.len()) {
|
|
knots[i] = knots[i].follow(knots[i - 1]);
|
|
}
|
|
// dbg!(head);
|
|
// dbg!(tail);
|
|
|
|
tail_visited.insert(knots[tail]);
|
|
|
|
// render(&knots, &tail_visited);
|
|
}
|
|
|
|
// render(&knots, &tail_visited);
|
|
// std::thread::sleep(std::time::Duration::from_millis(500));
|
|
}
|
|
|
|
render(&knots, &tail_visited);
|
|
tail_visited.len()
|
|
}
|
|
|
|
fn parse_input(input: &str) -> Vec<Step> {
|
|
aoc::split_lines(input)
|
|
.iter()
|
|
.map(|line| {
|
|
let words = aoc::split_words(line);
|
|
|
|
let d = Direction::from_str(words[0]).unwrap();
|
|
let n = words[1].parse::<i64>().unwrap();
|
|
|
|
Step { d, n }
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
|
|
struct Step {
|
|
d: Direction,
|
|
n: i64,
|
|
}
|
|
|
|
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
|
|
struct RC {
|
|
r: i64,
|
|
c: i64,
|
|
}
|
|
|
|
impl RC {
|
|
fn new(r: i64, c: i64) -> Self {
|
|
Self { r, c }
|
|
}
|
|
|
|
fn origin() -> Self {
|
|
Self::new(0, 0)
|
|
}
|
|
|
|
fn mv(&self, delta: RC) -> RC {
|
|
RC {
|
|
r: self.r + delta.r,
|
|
c: self.c + delta.c,
|
|
}
|
|
}
|
|
|
|
fn follow(&self, head: RC) -> RC {
|
|
// dbg!(head.r);
|
|
// dbg!(head.c);
|
|
// dbg!(self.r);
|
|
// dbg!(self.c);
|
|
|
|
let dr = head.r - self.r;
|
|
let dc = head.c - self.c;
|
|
|
|
// dbg!(dr);
|
|
// dbg!(dc);
|
|
|
|
// Adjacent
|
|
if dr.abs() < 2 && dc.abs() < 2 {
|
|
// dbg!("OK");
|
|
return *self;
|
|
}
|
|
|
|
// dbg!(sign(dr));
|
|
// dbg!(sign(dc));
|
|
|
|
RC::new(self.r + sign(dr), self.c + sign(dc))
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Deserialize)]
|
|
enum Direction {
|
|
U,
|
|
D,
|
|
L,
|
|
R,
|
|
}
|
|
|
|
impl Direction {
|
|
fn delta(&self) -> RC {
|
|
use Direction::*;
|
|
match self {
|
|
U => RC::new(1, 0),
|
|
D => RC::new(-1, 0),
|
|
L => RC::new(0, -1),
|
|
R => RC::new(0, 1),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl FromStr for Direction {
|
|
type Err = value::Error;
|
|
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
Self::deserialize(s.into_deserializer())
|
|
}
|
|
}
|
|
|
|
fn render(knots: &[RC], tail_visited: &HashSet<RC>) {
|
|
let rcs = knots.iter().chain(tail_visited.iter());
|
|
let (lo, hi) = rcs.fold((RC::origin(), RC::origin()), |(lo, hi), RC { r, c }| {
|
|
(
|
|
RC::new(lo.r.min(*r), lo.c.min(*c)),
|
|
RC::new(hi.r.max(*r), hi.c.max(*c)),
|
|
)
|
|
});
|
|
|
|
let chr = move |r: i64, c: i64| -> char {
|
|
for (i, rc) in knots.iter().enumerate() {
|
|
if (r, c) == (rc.r, rc.c) {
|
|
return char::from_digit(i as u32, 10).unwrap();
|
|
}
|
|
}
|
|
if tail_visited.contains(&RC::new(r, c)) {
|
|
'#'
|
|
} else {
|
|
'.'
|
|
}
|
|
};
|
|
|
|
for r in (lo.r..=hi.r).rev() {
|
|
for c in lo.c..=hi.c {
|
|
print!("{}", chr(r, c));
|
|
}
|
|
println!();
|
|
}
|
|
println!();
|
|
}
|
|
|
|
fn sign(n: i64) -> i64 {
|
|
n.cmp(&0) as i64
|
|
}
|