You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

140 lines
4.0 KiB

use std::collections::HashSet;
const INPUT: &str = include_str!("../../data/day24");
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
enum Direction {
East,
SouthEast,
SouthWest,
West,
NorthWest,
NorthEast,
}
impl Direction {
const ALL: [Direction; 6] = [
Self::East,
Self::SouthEast,
Self::SouthWest,
Self::West,
Self::NorthWest,
Self::NorthEast,
];
fn symbol(self) -> &'static str {
match self {
Self::East => "e",
Self::SouthEast => "se",
Self::SouthWest => "sw",
Self::West => "w",
Self::NorthWest => "nw",
Self::NorthEast => "ne",
}
}
fn parse_list(line: &str) -> Vec<Self> {
let mut line = line.trim();
let mut result = Vec::new();
'outer: while !line.is_empty() {
for &d in Self::ALL.iter() {
if let Some(rem) = line.strip_prefix(d.symbol()) {
result.push(d);
line = rem;
continue 'outer;
}
}
panic!("Invalid directions: {:?}", line);
}
result
}
// -> (row, col)
fn as_offset(self) -> (i32, i32) {
match self {
Self::East => (0, 1),
Self::SouthEast => (1, 1),
Self::SouthWest => (1, 0),
Self::West => (0, -1),
Self::NorthWest => (-1, -1),
Self::NorthEast => (-1, 0),
}
}
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Default, Debug)]
struct Position {
row: i32,
// the "0"-column goes from south-west to north-east through (0/0)
col: i32,
}
impl Position {
fn adjacent(self) -> impl Iterator<Item=Self> {
Direction::ALL.iter().map(move |&d| self + d)
}
}
impl std::ops::Add<Direction> for Position {
type Output = Position;
fn add(self, rhs: Direction) -> Self::Output {
let (row, col) = rhs.as_offset();
Self {
row: self.row + row,
col: self.col + col,
}
}
}
fn daily_flip(black_tiles: HashSet<Position>) -> HashSet<Position> {
let mut new_black_tiles: HashSet<Position> = HashSet::new();
let mut dont_flip_to_black: HashSet<Position> = HashSet::new();
for &tile in &black_tiles {
let mut count_adj_black = 0;
for adj_tile in tile.adjacent() {
if black_tiles.contains(&adj_tile) {
count_adj_black += 1;
} else if !new_black_tiles.contains(&adj_tile) && !dont_flip_to_black.contains(&adj_tile) {
// white adjacent: maybe needs to be flipped to black
let mut white_count_adj_black = 0;
for adj_tile_2 in adj_tile.adjacent() {
if black_tiles.contains(&adj_tile_2) {
white_count_adj_black += 1;
if white_count_adj_black > 2 { break; }
}
}
if white_count_adj_black == 2 {
new_black_tiles.insert(adj_tile);
} else {
// don't check again
dont_flip_to_black.insert(adj_tile);
}
}
}
if count_adj_black == 1 || count_adj_black == 2 {
new_black_tiles.insert(tile);
}
}
new_black_tiles
}
fn main() {
let directions = INPUT.lines().map(Direction::parse_list).collect::<Vec<_>>();
let flip_tiles = directions.iter().map(|tile| {
tile.iter().fold(Position::default(), |tile, &dir| tile + dir)
}).collect::<Vec<_>>();
let mut black_tiles = HashSet::new();
for &tile in &flip_tiles {
if black_tiles.contains(&tile) {
black_tiles.remove(&tile);
} else {
black_tiles.insert(tile);
}
}
println!("Black tiles: {}", black_tiles.len());
for _ in 0..100 {
black_tiles = daily_flip(black_tiles);
}
println!("Black tiles: {}", black_tiles.len());
}