Struct advent_of_code_2021::day_23::Burrow

struct Burrow {
    len: usize,
    positions: u128,
}

Represents a burrow as an integer that can be used as a list of 3-bit sections. 0-6 are the 7 cells in the hallway where a Amphipod can stop, the cells adjacent to each side tunnel are not represented here, and instead handled by build_states accounting for them when calculating costs. The remaining cells represent the side-tunnels, reading like a book. You can walk down a tunnel by staring at indices 7, 8, 9 or 10, and increasing by 4 each step. It is possible to represent a burrow of up to depth 8 in the u128 used.

The cells themselves use the numbers 0-4 to represent the types, 5 - 7 are unused:

• 0 - Empty
• 1 - Amber
• 2 - Bronze
• 3 - Copper
• 4 - Desert

Fields

len: usize

The number of cells in the grid. 15 for depth 2 (part one) and 23 for depth 4 (part two)

positions: u128

Each cell maps to 3 bits in this integer

Implementations

impl Burrow

fn get_at(&self, pos: usize) -> u128

Return the number representing the state at a given cell offset.

fn set_at(&mut self, pos: usize, val: u128)

update the positions integer with the value in pos.

Set cell offset 1 in a 4-cell burrow to 4, original value = 4321 (100 011 010 001):

let offset = 6; // i.e. the first bit after the 3 bits of the cell.'
let bits = (1 << self.len /*4*/ * 3)       // 1 000 000 000 000
           -1;                             //   111 111 111 111

let hole = 7u128 << offset;                //   000 111 000 000

let mask = hole ^ bits;                    //   111 000 111 111

let zeroed = self.positions & mask;        //   100 011 010 001
                                           // & 111 000 111 111
                                           //   ---------------
                                           //   100 000 010 001

self.positions = zeroed | (val << offset); //   100 000 010 001
                                           // | 000 100 000 000
                                           //   ---------------
                                           //   100 100 010 001  
                                           // = 4421

fn swap(&self, a: usize, b: usize) -> Burrow

Return a new burrow with the values at a and b swapped

Trait Implementations

impl Clone for Burrow

fn clone(&self) -> Burrow

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Burrow

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

Formats the value using the given formatter.

impl Display for Burrow

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

Output a representation of the burrow in .......BCBDDCBADBACADCA format

impl From<&'_ String> for Burrow

fn from(str: &String) -> Self

Parses a string in the format .......BCBDDCBADBACADCA as a Burrow. Used mostly for testing. See `parse_input for parsing the actual puzzle input

impl Hash for Burrow

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl Ord for Burrow

fn cmp(&self, other: &Burrow) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl PartialEq<Burrow> for Burrow

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

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

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

This method tests for !=.

impl PartialOrd<Burrow> for Burrow

fn partial_cmp(&self, other: &Burrow) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for Burrow

impl StructuralEq for Burrow

impl StructuralPartialEq for Burrow