Struct advent_of_code_2021::day_25::Grid

struct Grid {
    cells: Vec<Cell>,
    width: usize,
    height: usize,
    active_right: HashSet<(usize, usize)>,
    active_down: HashSet<(usize, usize)>,
}

Represent a grid as a vector of cells, with a width and height to enable quick lookups from x/y co-ordinates, and to help with wrapping around logic. Also keep HashSets of the RIGHT and DOWN cells that may be able to move, to limit the cells we need to check when iterating the grid

Fields

cells: Vec<Cell>

The cells of the grid as a single list

width: usize

Cache the grid width

height: usize

Cache teh grid height

active_right: HashSet<(usize, usize)>

The cells with a RIGHTwards moving sea cucumber that may be able to move

active_down: HashSet<(usize, usize)>

The cells with a DOWNwards moving sea cucumber that may be able to move

Implementations

impl Grid

fn get(&self, x: usize, y: usize) -> Option<&Cell>

Get the current value of a given cell co-ordinate, or None if it is out of bounds for the grid

fn pos_of(&self, x: usize, y: usize) -> usize

Convert x, y co-ordinates to an index in the underlying list of cells.

fn swap(&mut self, (x1, y1): (usize, usize), (x2, y2): (usize, usize))

Swap the values of two cells - used when sea cucumbers move

fn can_move(&self, x: usize, y: usize, direction: Cell) -> bool

We are overly optimistic when building the active sets. Given the co-ordinates of a sea cucumber and it’s direction of travel, check if it’s next cell is actually available to move into.

fn iterate(&mut self)

Do a full iteration of the grid in-place, moving RIGHTs that can move rightwards, then DOWNs that can move downwards. Calculate the new active set as all the cucumbers that moved, plus any that can move into the vacated space.

fn iterate_until_static(&mut self) -> usize

Trait Implementations

impl Debug for Grid

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Grid

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<&'_ String> for Grid

fn from(s: &String) -> Self

Parse the puzzle input as a grid, building the initial active sets to include all the sea cucumbers of the relevant type

impl PartialEq<Grid> for Grid

fn eq(&self, other: &Grid) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Grid) -> bool

This method tests for !=.

impl Eq for Grid

impl StructuralEq for Grid

impl StructuralPartialEq for Grid