Struct Computer

struct Computer {
    register_a: usize,
    register_b: usize,
    register_c: usize,
    program: Vec<u8>,
    instruction_pointer: usize,
}

Represents a computer and the program it will run

Fields

register_a: usize

register_b: usize

register_c: usize

program: Vec<u8>

instruction_pointer: usize

Implementations

impl Computer

fn with_register_a(&self, value: usize) -> Computer

Create a copy of this computer with the A register set to the provided value

fn next_instruction(&self) -> Option<(u8, u8)>

Read the instruction at the instruction_pointer, and the next number as the operand

fn deref_combo(&self, operand: u8) -> usize

Combo operands 0 through 3 represent literal values 0 through 3. Combo operand 4 represents the value of register A. Combo operand 5 represents the value of register B. Combo operand 6 represents the value of register C. Combo operand 7 is reserved and will not appear in valid programs.

fn adv(&mut self, operand: u8)

The adv instruction (opcode 0) performs division. The numerator is the value in the A register. The denominator is found by raising 2 to the power of the instruction’s combo operand. (So, an operand of 2 would divide A by 4 (2^2) ; an operand of 5 would divide A by 2^B.) The result of the division operation is truncated to an integer and then written to the A register

fn bxl(&mut self, operand: u8)

The bxl instruction (opcode 1) calculates the bitwise XOR of register B and the instruction’s literal operand, then stores the result in register B.

fn bst(&mut self, operand: u8)

The bst instruction (opcode 2) calculates the value of its combo operand modulo 8 (thereby keeping only its lowest 3 bits), then writes that value to the B register.

fn jnz(&mut self, operand: u8)

The jnz instruction (opcode 3) does nothing if the A register is 0. However, if the A register is not zero, it jumps by setting the instruction pointer to the value of its literal operand; if this instruction jumps, the instruction pointer is not increased by 2 after this instruction.

fn bxc(&mut self, _: u8)

The bxc instruction (opcode 4) calculates the bitwise XOR of register B and register C, then stores the result in register B. (For legacy reasons, this instruction reads an operand but ignores it.)

fn out(&mut self, operand: u8) -> u8

The out instruction (opcode 5) calculates the value of its combo operand modulo 8, then outputs that value. (If a program outputs multiple values, they are separated by commas.)

fn bdv(&mut self, operand: u8)

The bdv instruction (opcode 6) works exactly like the adv instruction except that the result is stored in the B register. (The numerator is still read from the A register.)

fn cdv(&mut self, operand: u8)

The cdv instruction (opcode 6) works exactly like the adv instruction except that the result is stored in the C register. (The numerator is still read from the A register.)

fn run(&mut self) -> Vec<u8>

Run the provided program unt the instruction pointer increments beyond the end of the program. Outputting any digits that result from Computer::out

Trait Implementations

impl Clone for Computer

fn clone(&self) -> Computer

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Computer

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

Formats the value using the given formatter.

impl PartialEq for Computer

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Computer

impl StructuralPartialEq for Computer