Code shared from the Rust Playground

playground.rs

fn main() {
    // Linjie Zhang 2020
    //
    // 3-state busy beaver
    // https://en.wikipedia.org/wiki/Turing_machine

    let rules = vec!["A01RB", "A11LC", "B01LA", "B11RB", "C01LB", "C11RH"]
        .iter()
        .map(|x| x.chars().collect::<Vec<char>>())
        .collect::<Vec<_>>();

    #[derive(Debug)]
    struct Machine {
        s1: Vec<char>,
        s2: Vec<char>,
    }

    impl Machine {
        fn new(state: char, symbols: Vec<char>) -> Self {
            Self {
                s1: vec![state],
                s2: symbols,
            }
        }

        fn state(&self) -> char {
            *self.s1.last().unwrap()
        }

        fn symbol(&self) -> char {
            *self.s2.last().unwrap()
        }

        fn set_state(&mut self, state: char) {
            self.s1.pop();
            self.s1.push(state);
        }

        fn set_symbol(&mut self, symbol: char) {
            self.s2.pop();
            self.s2.push(symbol);
        }

        fn print_tape(&self) {
            let mut tape_left = self.s1.iter().collect::<String>();
            let l = tape_left.len();
            tape_left.truncate(l - 1);
            let tape_right = self.s2.iter().rev().skip(1).collect::<String>();
            println!(
                "state: {}\ntape: {}[{}]{}\n",
                self.state(),
                tape_left,
                self.symbol(),
                tape_right
            );
        }

        fn to_left(&mut self) {
            let state = self.s1.pop().unwrap();
            let n = self.s1.pop().unwrap();
            self.s2.push(n);
            self.s1.push(state);
        }

        fn to_right(&mut self) {
            let state = self.s1.pop().unwrap();
            let n = self.s2.pop().unwrap();
            self.s1.push(n);
            self.s1.push(state);
        }

        fn transition(&mut self, rules: &Vec<Vec<char>>) {
            let state = self.state();
            if state == 'H' {
                panic!("halt");
            }
            let symbol = self.symbol();
            for rule in rules {
                if rule[0] == state && rule[1] == symbol {
                    self.print_tape();
                    self.set_symbol(rule[2]);
                    if rule[3] == 'L' {
                        self.to_left();
                    } else {
                        self.to_right();
                    }
                    self.set_state(rule[4]);
                    return;
                }
            }
        }
    }

    let mut left = vec!['0'; 6];
    left.push('A');
    let mut t_simple = Machine {
        s1: left,
        s2: vec!['0'; 6],
    };

    loop {
        t_simple.transition(&rules);
    }
}