Struct advent_solutions::advent2017::day08::Instruction

pub struct Instruction<'a> { /* fields omitted */ }

Each instruction consists of several parts: the register to modify, whether to increase or decrease that register's value, the amount by which to increase or decrease it, and a condition. If the condition fails, skip the instruction without modifying the register. The registers all start at 0. The instructions look like this:

b inc 5 if a > 1
a inc 1 if b < 5
c dec -10 if a >= 1
c inc -20 if c == 10

These instructions would be processed as follows:

• Because a starts at 0, it is not greater than 1, and so b is not modified.
• a is increased by 1 (to 1) because b is less than 5 (it is 0).
• c is decreased by -10 (to 10) because a is now greater than or equal to 1 (it is 1).
• c is increased by -20 (to -10) because c is equal to 10.

After this process, the largest value in any register is 1.

You might also encounter <= (less than or equal to) or != (not equal to). However, the CPU doesn't have the bandwidth to tell you what all the registers are named, and leaves that to you to determine.

Methods

impl<'a> Instruction<'a>

pub fn from_bytes(i: &[u8]) -> IResult<&[u8], Instruction, u32>

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

pub fn exec(&self, registers: &mut HashMap<&'a str, isize>)

Trait Implementations

impl<'a> Copy for Instruction<'a>

impl<'a> Clone for Instruction<'a>

fn clone(&self) -> Instruction<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> PartialEq for Instruction<'a>

fn eq(&self, __arg_0: &Instruction<'a>) -> bool

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

fn ne(&self, __arg_0: &Instruction<'a>) -> bool

This method tests for !=.

impl<'a> Eq for Instruction<'a>

impl<'a> Debug for Instruction<'a>

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

Formats the value using the given formatter.

impl<'a> Hash for Instruction<'a>

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].