Enum advent_solutions::advent2017::day16::Move

pub enum Move {
    Spin(usize),
    Exchange(usize, usize),
    Partner(char, char),
}

The programs' dance consists of a sequence of dance moves:

• Spin, written sX, makes X programs move from the end to the front, but maintain their order otherwise. (For example, s3 on abcde produces cdeab).

  assert_eq!(
      Move::Spin(3).apply(vec!['a', 'b', 'c', 'd', 'e']),
      ['c', 'd', 'e', 'a', 'b']
  )

• Exchange, written xA/B, makes the programs at positions A and B swap places.

• Partner, written pA/B, makes the programs named A and B swap places.

For example, with only five programs standing in a line (abcde), they could do the following dance:

let starting_programs = vec!['a', 'b', 'c', 'd', 'e'];

• s1, a spin of size 1: eabcd.

  assert_eq!(
      Move::Spin(1).apply(starting_programs),
      ['e', 'a', 'b', 'c', 'd']
  )

• x3/4, swapping the last two programs: eabdc.

  assert_eq!(
      Move::Exchange(3, 4).apply(after_s1),
      ['e', 'a', 'b', 'd', 'c']
  )

• pe/b, swapping programs e and b: baedc.

  assert_eq!(
      Move::Partner('e', 'b').apply(after_x34),
      ['b', 'a', 'e', 'd', 'c']
  )

After finishing their dance, the programs end up in order baedc.

Variants

Spin(usize)Exchange(usize, usize)Partner(char, char)

Methods

impl Move

pub fn apply(&self, programs: Vec<char>) -> Vec<char>

pub fn list_from_bytes(i: &[u8]) -> IResult<&[u8], Vec<Move>, u32>

Trait Implementations

impl Copy for Move

impl Clone for Move

fn clone(&self) -> Move

Returns a copy of the value.

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

Performs copy-assignment from source.

impl PartialEq for Move

fn eq(&self, __arg_0: &Move) -> bool

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

fn ne(&self, __arg_0: &Move) -> bool

This method tests for !=.

impl Eq for Move

impl Debug for Move

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Hash for Move

fn hash<__H: Hasher>(&self, __arg_0: &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].