generated from janezicmatej/aoc-template
Compare commits
No commits in common. "00000330860e93a75a3ff6b8bc3a3639d8ec819f" and "0000030011b728f02b8fdfef0b824164ba4bd583" have entirely different histories.
0000033086
...
0000030011
|
|
@ -1,10 +0,0 @@
|
|||
.|...\....
|
||||
|.-.\.....
|
||||
.....|-...
|
||||
........|.
|
||||
..........
|
||||
.........\
|
||||
..../.\\..
|
||||
.-.-/..|..
|
||||
.|....-|.\
|
||||
..//.|....
|
||||
|
|
@ -1,13 +0,0 @@
|
|||
2413432311323
|
||||
3215453535623
|
||||
3255245654254
|
||||
3446585845452
|
||||
4546657867536
|
||||
1438598798454
|
||||
4457876987766
|
||||
3637877979653
|
||||
4654967986887
|
||||
4564679986453
|
||||
1224686865563
|
||||
2546548887735
|
||||
4322674655533
|
||||
|
|
@ -24,7 +24,7 @@ fn swap<T: Copy>(floor: &mut [Vec<T>], from: (usize, usize), to: (usize, usize))
|
|||
floor[to.0][to.1] = a;
|
||||
}
|
||||
|
||||
fn tilt(floor: &mut [Vec<char>], tilt: Tilt) {
|
||||
fn tilt(floor: &mut Vec<Vec<char>>, tilt: Tilt) {
|
||||
let (inner, outer) = match tilt {
|
||||
Tilt::North | Tilt::South => (floor[0].len(), floor.len()),
|
||||
Tilt::West | Tilt::East => (floor.len(), floor[0].len()),
|
||||
|
|
@ -54,7 +54,7 @@ fn tilt(floor: &mut [Vec<char>], tilt: Tilt) {
|
|||
}
|
||||
}
|
||||
|
||||
fn tilt_cycle(floor: &mut [Vec<char>]) {
|
||||
fn tilt_cycle(floor: &mut Vec<Vec<char>>) {
|
||||
use Tilt::*;
|
||||
tilt(floor, North);
|
||||
tilt(floor, West);
|
||||
|
|
|
|||
173
src/bin/16.rs
173
src/bin/16.rs
|
|
@ -1,173 +0,0 @@
|
|||
use std::collections::HashSet;
|
||||
|
||||
#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
|
||||
enum Direction {
|
||||
Up,
|
||||
Down,
|
||||
Left,
|
||||
Right,
|
||||
}
|
||||
|
||||
impl Direction {
|
||||
fn next(&self, (y, x): (usize, usize)) -> (usize, usize) {
|
||||
use Direction::*;
|
||||
match self {
|
||||
Up => (y.checked_sub(1).unwrap_or(usize::MAX), x),
|
||||
Down => (y + 1, x),
|
||||
Left => (y, x.checked_sub(1).unwrap_or(usize::MAX)),
|
||||
Right => (y, x + 1),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
enum Mirror {
|
||||
Vertical,
|
||||
Horizontal,
|
||||
EvenSymmetric,
|
||||
OddSymmetric,
|
||||
}
|
||||
|
||||
struct ParseMirrorError;
|
||||
|
||||
impl TryFrom<u8> for Mirror {
|
||||
type Error = ParseMirrorError;
|
||||
fn try_from(value: u8) -> Result<Self, Self::Error> {
|
||||
Ok(match value {
|
||||
b'|' => Self::Vertical,
|
||||
b'-' => Self::Horizontal,
|
||||
b'\\' => Self::EvenSymmetric,
|
||||
b'/' => Self::OddSymmetric,
|
||||
_ => return Err(ParseMirrorError),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl Mirror {
|
||||
fn bounce(&self, d: &Direction) -> (Direction, Option<Direction>) {
|
||||
use Direction::*;
|
||||
use Mirror::*;
|
||||
|
||||
match self {
|
||||
Vertical => match d {
|
||||
Up | Down => (*d, None),
|
||||
Left | Right => (Up, Some(Down)),
|
||||
},
|
||||
Horizontal => match d {
|
||||
Up | Down => (Left, Some(Right)),
|
||||
Left | Right => (*d, None),
|
||||
},
|
||||
EvenSymmetric => (
|
||||
match d {
|
||||
Up => Left,
|
||||
Down => Right,
|
||||
Left => Up,
|
||||
Right => Down,
|
||||
},
|
||||
None,
|
||||
),
|
||||
OddSymmetric => (
|
||||
match d {
|
||||
Up => Right,
|
||||
Down => Left,
|
||||
Left => Down,
|
||||
Right => Up,
|
||||
},
|
||||
None,
|
||||
),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn solve_with_start(layout: &[Vec<Option<Mirror>>], start: (usize, usize, Direction)) -> usize {
|
||||
let mut queue = vec![start];
|
||||
let mut visited = HashSet::new();
|
||||
|
||||
while let Some((y, x, d)) = queue.pop() {
|
||||
let point = layout.get(y).and_then(|row| row.get(x));
|
||||
|
||||
if point.is_none() {
|
||||
continue;
|
||||
}
|
||||
|
||||
if !visited.insert((y, x, d)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if let Some(Some(m)) = point {
|
||||
let (new_d, opt_new_d) = m.bounce(&d);
|
||||
let (ny, nx) = new_d.next((y, x));
|
||||
queue.push((ny, nx, new_d));
|
||||
|
||||
if let Some(od) = opt_new_d {
|
||||
let (ony, onx) = od.next((y, x));
|
||||
queue.push((ony, onx, od));
|
||||
}
|
||||
} else {
|
||||
let (ny, nx) = d.next((y, x));
|
||||
queue.push((ny, nx, d));
|
||||
}
|
||||
}
|
||||
|
||||
HashSet::<(usize, usize)>::from_iter(visited.into_iter().map(|(y, x, _)| (y, x))).len()
|
||||
}
|
||||
|
||||
pub fn part_one(input: &str) -> Option<usize> {
|
||||
let layout: Vec<Vec<_>> = input
|
||||
.lines()
|
||||
.map(|x| x.as_bytes().iter().map(|&x| x.try_into().ok()).collect())
|
||||
.collect();
|
||||
|
||||
Some(solve_with_start(&layout, (0, 0, Direction::Right)))
|
||||
}
|
||||
|
||||
pub fn part_two(input: &str) -> Option<usize> {
|
||||
let layout: Vec<Vec<_>> = input
|
||||
.lines()
|
||||
.map(|x| x.as_bytes().iter().map(|&x| x.try_into().ok()).collect())
|
||||
.collect();
|
||||
|
||||
let h = layout.len();
|
||||
let w = layout[0].len();
|
||||
|
||||
let mut scores = Vec::with_capacity(2 * (h + w) + 1);
|
||||
|
||||
for hh in 0..h {
|
||||
let left = solve_with_start(&layout, (hh, 0, Direction::Right));
|
||||
let right = solve_with_start(&layout, (hh, w - 1, Direction::Left));
|
||||
|
||||
scores.push(left);
|
||||
scores.push(right);
|
||||
}
|
||||
|
||||
for ww in 0..w {
|
||||
let downward = solve_with_start(&layout, (0, ww, Direction::Down));
|
||||
let upward = solve_with_start(&layout, (h - 1, ww, Direction::Up));
|
||||
|
||||
scores.push(downward);
|
||||
scores.push(upward);
|
||||
}
|
||||
|
||||
scores.into_iter().max()
|
||||
}
|
||||
|
||||
aoc::solution!(16);
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn test_part_one() {
|
||||
assert_eq!(
|
||||
part_one(&aoc::template::read_file("examples", 16)),
|
||||
Some(46)
|
||||
);
|
||||
}
|
||||
#[test]
|
||||
fn test_part_two() {
|
||||
assert_eq!(
|
||||
part_two(&aoc::template::read_file("examples", 16)),
|
||||
Some(51)
|
||||
);
|
||||
}
|
||||
}
|
||||
192
src/bin/17.rs
192
src/bin/17.rs
|
|
@ -1,192 +0,0 @@
|
|||
use std::{
|
||||
collections::{BinaryHeap, HashMap},
|
||||
ops::Neg,
|
||||
};
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
|
||||
enum Direction {
|
||||
Up,
|
||||
Down,
|
||||
Left,
|
||||
Right,
|
||||
}
|
||||
|
||||
impl Direction {
|
||||
const ALL: [Direction; 4] = [
|
||||
Direction::Up,
|
||||
Direction::Down,
|
||||
Direction::Left,
|
||||
Direction::Right,
|
||||
];
|
||||
}
|
||||
|
||||
impl Neg for Direction {
|
||||
type Output = Self;
|
||||
fn neg(self) -> Self::Output {
|
||||
use Direction::*;
|
||||
match self {
|
||||
Up => Down,
|
||||
Down => Up,
|
||||
Left => Right,
|
||||
Right => Left,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
struct State {
|
||||
heat: usize,
|
||||
position: (usize, usize),
|
||||
direction: Direction,
|
||||
steps: usize,
|
||||
}
|
||||
|
||||
impl PartialOrd for State {
|
||||
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
|
||||
Some(self.cmp(other))
|
||||
}
|
||||
}
|
||||
|
||||
impl Ord for State {
|
||||
fn cmp(&self, other: &Self) -> std::cmp::Ordering {
|
||||
other
|
||||
.heat
|
||||
.cmp(&self.heat)
|
||||
.then_with(|| self.position.cmp(&other.position))
|
||||
}
|
||||
}
|
||||
|
||||
fn find_path(
|
||||
grid: &[Vec<usize>],
|
||||
start: (usize, usize),
|
||||
target: (usize, usize),
|
||||
min_steps: usize,
|
||||
max_steps: usize,
|
||||
) -> Option<usize> {
|
||||
let valid_indexing = |y: usize, x: usize| grid.get(y).and_then(|row| row.get(x)).is_some();
|
||||
|
||||
let mut heap = BinaryHeap::new();
|
||||
heap.push(State {
|
||||
heat: 0,
|
||||
position: (0, 0),
|
||||
direction: Direction::Right,
|
||||
steps: 0,
|
||||
});
|
||||
|
||||
let mut heatmap = HashMap::new();
|
||||
heatmap.insert((start, Direction::Down, 0), 0);
|
||||
heatmap.insert((start, Direction::Up, 0), 0);
|
||||
|
||||
while let Some(State {
|
||||
heat,
|
||||
position,
|
||||
direction,
|
||||
steps,
|
||||
}) = heap.pop()
|
||||
{
|
||||
if position == target {
|
||||
return Some(heat);
|
||||
}
|
||||
|
||||
if *heatmap
|
||||
.get(&(position, direction, steps))
|
||||
.unwrap_or(&usize::MAX)
|
||||
< heat
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
let (y, x) = position;
|
||||
for d in Direction::ALL.iter().filter(|&x| *x != -direction) {
|
||||
if steps < min_steps && *d != direction {
|
||||
continue;
|
||||
}
|
||||
|
||||
let (ny, nx) = match d {
|
||||
Direction::Up => (y.wrapping_sub(1), x),
|
||||
Direction::Down => (y + 1, x),
|
||||
Direction::Left => (y, x.wrapping_sub(1)),
|
||||
Direction::Right => (y, x + 1),
|
||||
};
|
||||
|
||||
if !valid_indexing(ny, nx) {
|
||||
continue;
|
||||
}
|
||||
|
||||
let new_steps = if *d == direction { steps + 1 } else { 1 };
|
||||
|
||||
if new_steps > max_steps {
|
||||
continue;
|
||||
}
|
||||
|
||||
let state = State {
|
||||
heat: heat + grid[ny][nx],
|
||||
position: (ny, nx),
|
||||
direction: *d,
|
||||
steps: new_steps,
|
||||
};
|
||||
|
||||
if *heatmap
|
||||
.get(&((ny, nx), *d, new_steps))
|
||||
.unwrap_or(&usize::MAX)
|
||||
> state.heat
|
||||
{
|
||||
heatmap.insert(((ny, nx), *d, new_steps), state.heat);
|
||||
heap.push(state);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
None
|
||||
}
|
||||
|
||||
pub fn part_one(input: &str) -> Option<usize> {
|
||||
let grid: Vec<Vec<_>> = input
|
||||
.lines()
|
||||
.map(|x| {
|
||||
x.chars()
|
||||
.filter_map(|x| x.to_digit(10).map(|x| x as usize))
|
||||
.collect()
|
||||
})
|
||||
.collect();
|
||||
|
||||
let target = (grid.len() - 1, grid[0].len() - 1);
|
||||
|
||||
find_path(&grid, (0, 0), target, 0, 3)
|
||||
}
|
||||
|
||||
pub fn part_two(input: &str) -> Option<usize> {
|
||||
let grid: Vec<Vec<_>> = input
|
||||
.lines()
|
||||
.map(|x| {
|
||||
x.chars()
|
||||
.filter_map(|x| x.to_digit(10).map(|x| x as usize))
|
||||
.collect()
|
||||
})
|
||||
.collect();
|
||||
|
||||
let target = (grid.len() - 1, grid[0].len() - 1);
|
||||
|
||||
find_path(&grid, (0, 0), target, 4, 10)
|
||||
}
|
||||
|
||||
aoc::solution!(17);
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn test_part_one() {
|
||||
assert_eq!(
|
||||
part_one(&aoc::template::read_file("examples", 17)),
|
||||
Some(102)
|
||||
);
|
||||
}
|
||||
#[test]
|
||||
fn test_part_two() {
|
||||
assert_eq!(
|
||||
part_two(&aoc::template::read_file("examples", 17)),
|
||||
Some(94)
|
||||
);
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue