133 lines
4.2 KiB
Rust
133 lines
4.2 KiB
Rust
use grid::*;
|
|
use intcode::*;
|
|
use itertools::Itertools;
|
|
use std::char;
|
|
use std::collections::{HashMap, HashSet};
|
|
use std::fmt;
|
|
|
|
#[derive(Debug, PartialEq, Eq, Hash, Clone)]
|
|
struct Movement {
|
|
rotation: i8,
|
|
distance: u8,
|
|
}
|
|
|
|
impl fmt::Display for Movement {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
|
|
let dir_char = if self.rotation == 1 { 'R' } else { 'L' };
|
|
write!(f, "{},{}", dir_char, self.distance)
|
|
}
|
|
}
|
|
|
|
#[rustfmt::skip]
|
|
fn find_commands(field: &HashMap<Position2D, char>) -> Vec<Movement> {
|
|
let mut robot_position = field.iter().find(|(_, c)| *c == &'^').unwrap().0.to_owned();
|
|
let mut robot_direction = Direction::Up;
|
|
let mut commands = Vec::new();
|
|
loop {
|
|
let mut steps = 0;
|
|
let turn = ((field.get(&(robot_position + (robot_direction + 1))) == Some(&'#')) as i8) * 2 - 1;
|
|
robot_direction += turn;
|
|
while field.get(&(robot_position + robot_direction)) == Some(&'#') {
|
|
robot_position += robot_direction;
|
|
steps += 1;
|
|
}
|
|
commands.push(Movement {
|
|
distance: steps,
|
|
rotation: turn,
|
|
});
|
|
if robot_position.neighbors().iter().filter(|(_, p)| field.get(p) == Some(&'#')).count() == 1 {
|
|
break;
|
|
}
|
|
}
|
|
commands
|
|
}
|
|
|
|
fn main() {
|
|
// The main reason I use a hashmap here (instead of a 2D vector) is that my abstractions for
|
|
// ascii stuff all use maps ヽ( ﾟヮ・)ノ
|
|
let mut input = read_input();
|
|
let field: HashMap<Position2D, char> = IntComputer::without_params(input.clone())
|
|
.get_all_outputs()
|
|
.iter()
|
|
.map(|n| char::from_u32(*n as u32).unwrap())
|
|
.collect::<String>()
|
|
.lines()
|
|
// this rev breaks part 1 but is necessary for part 2. remove it to get the part 1 solution
|
|
.rev()
|
|
.enumerate()
|
|
.flat_map(move |(y, s)| s.chars().enumerate().map(move |(x, c)| ((x, y).into(), c)))
|
|
.collect();
|
|
let p1 = field
|
|
.iter()
|
|
.filter(|(pos, obj)| {
|
|
*obj == &'#'
|
|
&& pos
|
|
.neighbors()
|
|
.iter()
|
|
.all(|(_, p)| field.get(&p) == Some(&'#'))
|
|
})
|
|
.fold(0, |acc, (pos, _)| acc + pos.x * pos.y);
|
|
println!("Part 1: {}", p1);
|
|
|
|
let commands = find_commands(&field);
|
|
let mut pos = 0;
|
|
let mut segments = Vec::new();
|
|
while pos < commands.len() - 4 {
|
|
if let Some((n, mov)) = (2..=4)
|
|
.filter_map(|i| {
|
|
let reference = commands[pos..].windows(i).next();
|
|
if segments.contains(&reference.unwrap()) {
|
|
Some(((i, 99), reference))
|
|
} else {
|
|
let dupes = commands[pos..]
|
|
.windows(i)
|
|
.filter(|&w| Some(w) == reference)
|
|
.count();
|
|
if dupes > 0 {
|
|
Some(((i, dupes), reference))
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
})
|
|
.max_by_key(|((x, y), _)| x * y)
|
|
{
|
|
pos += n.0;
|
|
segments.push(mov.unwrap());
|
|
}
|
|
}
|
|
let filtered: HashSet<_> = segments.clone().into_iter().collect();
|
|
let mut filtered: Vec<_> = filtered.into_iter().zip(['A', 'B', 'C'].iter()).collect();
|
|
filtered.sort_by_key(|(_, c)| c.to_owned());
|
|
let mut instructions = Vec::new();
|
|
let mut pos = 0;
|
|
while pos < commands.len() {
|
|
for i in 1.. {
|
|
if filtered.iter().any(|(c, _)| c == &&commands[pos..pos + i]) {
|
|
instructions.push(&commands[pos..pos + i]);
|
|
pos += i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
input[0] = 2;
|
|
let path: Vec<i64> = (instructions
|
|
.iter()
|
|
.map(|i| filtered.iter().find(|(f, _)| i == f).unwrap().1)
|
|
.join(",")
|
|
+ "\n"
|
|
+ &filtered
|
|
.into_iter()
|
|
.map(|(f, _)| f.iter().map(|m| m.to_string()).join(","))
|
|
.join("\n")
|
|
+ "\nn\n")
|
|
.chars()
|
|
.map(|c| c as i64)
|
|
.rev()
|
|
.collect();
|
|
println!(
|
|
"Part 2: {:?}",
|
|
IntComputer::new(input, 0, path).get_all_outputs().pop().unwrap()
|
|
);
|
|
}
|