advent-of-code/aoc2020/src/day12.rs

301 lines
7.3 KiB
Rust
Raw Normal View History

2020-12-12 14:06:03 +01:00
use std::fmt::Write;
2020-12-14 18:08:16 +01:00
use anyhow::{bail, Context, Result};
2020-12-12 14:06:03 +01:00
const INPUT: &str = include_str!("../input/day12.txt");
2020-12-14 18:08:16 +01:00
pub fn run() -> Result<String> {
2020-12-12 14:06:03 +01:00
let mut res = String::with_capacity(128);
writeln!(res, "part 1: {}", part1(INPUT)?)?;
2020-12-12 15:39:09 +01:00
writeln!(res, "part 2: {}", part2(INPUT)?)?;
2020-12-12 14:06:03 +01:00
Ok(res)
}
2020-12-14 18:08:16 +01:00
fn part1(input: &str) -> Result<i64> {
let actions: Vec<Action> = input.lines().map(str::parse).collect::<Result<_>>()?;
2020-12-12 14:06:03 +01:00
let mut ship = Ship::new();
for a in actions {
ship.process(&a);
2020-12-12 14:06:03 +01:00
}
Ok(ship.manhattan_distance())
}
2020-12-14 18:08:16 +01:00
fn part2(input: &str) -> Result<i64> {
let actions: Vec<Action> = input.lines().map(str::parse).collect::<Result<_>>()?;
2020-12-12 15:39:09 +01:00
let mut ship = Ship::new();
for a in actions {
ship.process_with_waypoint(&a);
2020-12-12 15:39:09 +01:00
}
Ok(ship.manhattan_distance())
}
fn get_quadrants(degrees: i64) -> usize {
debug_assert!(degrees % 90 == 0, "only right angles are supported");
(degrees / 90) as usize
}
2020-12-12 14:06:03 +01:00
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Direction {
North,
South,
East,
West,
}
impl Direction {
const CLOCKWISE_DIRECTIONS: &'static [Direction] = &[
Direction::North,
Direction::East,
Direction::South,
Direction::West,
];
2020-12-12 17:06:08 +01:00
fn rotate(self, turn_dir: TurnDirection, degrees: i64) -> Direction {
let quadrants = get_quadrants(degrees);
let directions_iter = Self::CLOCKWISE_DIRECTIONS.iter().copied();
if turn_dir == TurnDirection::Left {
// go through cardinal directions the other way around, anti-clockwise
Self::find_direction(directions_iter.rev(), quadrants, self)
} else {
Self::find_direction(directions_iter, quadrants, self)
}
}
fn find_direction<I>(iter: I, quarters: usize, current_direction: Direction) -> Direction
where
I: Iterator<Item = Direction>,
I: std::clone::Clone,
{
iter
// this is litteraly a circle, reaching West and turning 90 degrees right means facing
// North again
.cycle()
// find our current ship direction
.skip_while(|dir| *dir != current_direction)
// skip as many quarters as needed
.nth(quarters)
// we can unwrap safely because we called .cycle() on a non empty iterator
.unwrap()
}
}
2020-12-12 15:48:15 +01:00
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum TurnDirection {
Left,
Right,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
2020-12-12 14:06:03 +01:00
enum ActionKind {
Move(Direction),
2020-12-12 15:48:15 +01:00
Turn(TurnDirection),
2020-12-12 14:06:03 +01:00
Forward,
}
#[derive(Debug, Clone)]
struct Action {
kind: ActionKind,
2020-12-12 17:06:08 +01:00
arg: i64,
2020-12-12 14:06:03 +01:00
}
impl std::str::FromStr for Action {
2020-12-14 18:08:16 +01:00
type Err = anyhow::Error;
2020-12-12 14:06:03 +01:00
2020-12-14 18:08:16 +01:00
fn from_str(s: &str) -> Result<Self> {
2020-12-12 14:06:03 +01:00
debug_assert!(
s.len() >= 2,
"tried to parse action but it is too short: `{}`",
s
);
let letter = s
.chars()
.next()
2020-12-14 18:08:16 +01:00
.context("couldn't parse action: empty string")?;
2020-12-12 14:06:03 +01:00
let kind = match letter {
'N' => ActionKind::Move(Direction::North),
'S' => ActionKind::Move(Direction::South),
'E' => ActionKind::Move(Direction::East),
'W' => ActionKind::Move(Direction::West),
2020-12-12 15:48:15 +01:00
'L' => ActionKind::Turn(TurnDirection::Left),
'R' => ActionKind::Turn(TurnDirection::Right),
2020-12-12 14:06:03 +01:00
'F' => ActionKind::Forward,
2020-12-14 18:08:16 +01:00
_ => bail!("couldn't parse action with letter `{}`", letter),
2020-12-12 14:06:03 +01:00
};
2020-12-14 18:08:16 +01:00
let arg = s[1..].parse().context("couldn't parse action arg")?;
2020-12-12 14:06:03 +01:00
Ok(Self { kind, arg })
}
}
#[derive(Debug, Clone)]
struct Coordinates {
2020-12-12 14:06:03 +01:00
x: i64,
y: i64,
}
impl Coordinates {
fn move_towards(&mut self, direction: Direction, distance: i64) {
match direction {
Direction::North => self.y -= distance,
Direction::South => self.y += distance,
Direction::West => self.x -= distance,
Direction::East => self.x += distance,
}
}
}
#[derive(Debug, Clone)]
struct Ship {
direction: Direction,
coordinates: Coordinates,
2020-12-12 15:39:09 +01:00
waypoint: Waypoint,
2020-12-12 14:06:03 +01:00
}
impl Ship {
fn new() -> Self {
Self {
direction: Direction::East,
coordinates: Coordinates { x: 0, y: 0 },
2020-12-12 15:39:09 +01:00
waypoint: Waypoint::new(),
2020-12-12 14:06:03 +01:00
}
}
fn manhattan_distance(&self) -> i64 {
self.coordinates.x.abs() + self.coordinates.y.abs()
2020-12-12 14:06:03 +01:00
}
fn process(&mut self, action: &Action) {
2020-12-12 14:06:03 +01:00
match action.kind {
2020-12-12 17:06:08 +01:00
ActionKind::Move(dir) => self.coordinates.move_towards(dir, action.arg),
2020-12-12 14:06:03 +01:00
2020-12-12 15:48:15 +01:00
ActionKind::Turn(turn_dir) => {
self.direction = self.direction.rotate(turn_dir, action.arg);
2020-12-12 14:06:03 +01:00
}
ActionKind::Forward => self.coordinates.move_towards(self.direction, action.arg),
2020-12-12 14:06:03 +01:00
}
}
fn process_with_waypoint(&mut self, action: &Action) {
2020-12-12 15:39:09 +01:00
match action.kind {
ActionKind::Move(dir) => self.waypoint.coordinates.move_towards(dir, action.arg),
2020-12-12 15:39:09 +01:00
2020-12-12 15:48:15 +01:00
ActionKind::Turn(turn_dir) => {
let quadrants = get_quadrants(action.arg);
2020-12-12 15:39:09 +01:00
2020-12-12 15:48:15 +01:00
self.waypoint.turn(turn_dir, quadrants);
2020-12-12 15:39:09 +01:00
}
ActionKind::Forward => {
for mv in &self.waypoint.as_moves(action.arg) {
self.process(mv);
}
2020-12-12 15:39:09 +01:00
}
}
}
2020-12-12 14:06:03 +01:00
}
2020-12-12 15:39:09 +01:00
#[derive(Debug, Clone)]
struct Waypoint {
coordinates: Coordinates,
2020-12-12 15:39:09 +01:00
}
impl Waypoint {
fn new() -> Self {
Self {
coordinates: Coordinates { x: 10, y: -1 },
}
2020-12-12 15:39:09 +01:00
}
/// as_moves returns Actions with ActionKind::Move representing the moves the ship should take
/// to reach the waypoint
///
/// this allows reusing the Forward logic of part 1 to move the ship towards the waypoint
fn as_moves(&self, steps: i64) -> [Action; 2] {
let west_east = if self.coordinates.x < 0 {
2020-12-12 15:39:09 +01:00
Direction::West
} else {
Direction::East
};
let north_south = if self.coordinates.y < 0 {
2020-12-12 15:39:09 +01:00
Direction::North
} else {
Direction::South
};
[
Action {
kind: ActionKind::Move(west_east),
arg: self.coordinates.x.abs() * steps,
},
Action {
kind: ActionKind::Move(north_south),
arg: self.coordinates.y.abs() * steps,
},
]
}
2020-12-12 15:48:15 +01:00
fn turn(&mut self, turn_dir: TurnDirection, quadrants: usize) {
let coords = &mut self.coordinates;
2020-12-12 15:48:15 +01:00
for _ in 0..quadrants {
let mut x = coords.x;
let mut y = coords.y;
2020-12-12 15:48:15 +01:00
match turn_dir {
TurnDirection::Left => x = -x,
TurnDirection::Right => y = -y,
}
coords.x = y;
coords.y = x;
2020-12-12 15:48:15 +01:00
}
}
2020-12-12 15:39:09 +01:00
}
2020-12-12 14:06:03 +01:00
#[cfg(test)]
mod tests {
use super::*;
const PROVIDED: &str = include_str!("../input/day12_provided.txt");
#[test]
fn part1_provided() {
assert_eq!(part1(PROVIDED).unwrap(), 25);
}
#[test]
fn part1_real() {
assert_eq!(part1(INPUT).unwrap(), 1589);
}
2020-12-12 15:39:09 +01:00
#[test]
fn part2_provided() {
assert_eq!(part2(PROVIDED).unwrap(), 286);
}
#[test]
fn part2_real() {
assert_eq!(part2(INPUT).unwrap(), 23960);
}
2020-12-12 14:06:03 +01:00
}