Tulkki

warning: variant `REPEAT_START` should have an upper camel case name
 --> input/code.rs:9:5
  |
9 |     REPEAT_START,
  |     ^^^^^^^^^^^^ help: convert the identifier to upper camel case: `RepeatStart`
  |
  = note: `#[warn(non_camel_case_types)]` on by default

warning: variant `REPEAT_END` should have an upper camel case name
  --> input/code.rs:10:5
   |
10 |     REPEAT_END,
   |     ^^^^^^^^^^ help: convert the identifier to upper camel case: `RepeatEnd`

warning: value assigned to `data` is never read
  --> input/code.rs:49:14
   |
49 |     (output, data) = run(&all_components, output, data);
   |              ^^^^
   |
   = help: maybe it is overwritten before being read?
   = note: `#[warn(unused_assignments)]` on by default

warning: 3 warnings emitted

use std::io::{self, Read};

#[derive(PartialEq, Copy, Clone, Debug)]
enum Component {
    INCREASE,
    CLEAR,
    PRINT,
    REPEAT,
    REPEAT_START,
    REPEAT_END,
    VARIABLE(usize),
}

fn main() {
    let mut input = String::new();
    io::stdin().read_to_string(&mut input).unwrap();
    let lines: Vec<&str> = input.lines().collect();

    let mut all_components: Vec<Component> = Vec::with_capacity(1000);

    for line in lines {
        let mut line2 = line.to_string();
        let mut comment_index: usize = 0;
        // Remove useless stuff:
        for ch in line2.chars() {
            if ch == '#' {
                line2.replace_range(comment_index..line.len(), "");
                break;
            }
            comment_index += 1;
        }

        line2 = line2.replace("TIMES", "");
        let components: Vec<String> = line2.split_whitespace().map(|s| s.to_string()).collect();
        for component in components {
            all_components.push(match component.as_str() {
                "INCREASE" => Component::INCREASE,
                "CLEAR" => Component::CLEAR,
                "REPEAT" => Component::REPEAT,
                "(" => Component::REPEAT_START,
                ")" => Component::REPEAT_END,
                "PRINT" => Component::PRINT,
                _ => Component::VARIABLE(get_variable_index(&component)),
            })
        }
    }
    let mut data = [0; 26];
    let mut output = String::new();
    (output, data) = run(&all_components, output, data);

    output.pop();
    println!("{}", output);
}

fn get_variable_index(a: &String) -> usize {
    return ((a.chars().next().unwrap().to_ascii_lowercase()) as u8 - b'a') as usize;
}

// Use for recursion.
fn run(components: &Vec<Component>, mut output: String, mut data: [i32; 26]) -> (String, [i32; 26]) {
    let mut repeat_amount = 0;
    let mut catch_components = false;
    let mut caught_components: Vec<Component> = Vec::with_capacity(1000);
    let mut repeat_check = 1;
    for (i, component) in components.iter().enumerate() {
        if catch_components {
            if *component == Component::REPEAT_START {
                repeat_check += 1;
            }
            if *component == Component::REPEAT_END {
                repeat_check -= 1;
            }
            if repeat_check == 0 {
                catch_components = false;
                for _ in 0..repeat_amount {
                    (output, data) = run(&caught_components, output, data)
                }
                repeat_check = 1;
            }
            caught_components.push(*component);
        } else {
            match component {
                Component::INCREASE => data[return_index(&components[i+1])] += 1,
                Component::CLEAR => data[return_index(&components[i+1])] = 0,
                Component::PRINT => {
                    output.push_str(data[return_index(&components[i+1])].to_string().as_str());
                    output.push_str(" ");
                },
                Component::REPEAT => repeat_amount = data[return_index(&components[i+1])],
                Component::REPEAT_START => {
                    catch_components = true;
                    caught_components = Vec::with_capacity(1000);
                },
                _ => continue,
            }
        }
    }
    return (output, data);
}

fn return_index(comp: &Component) -> usize {
    if let Component::VARIABLE(idx) = comp {
        return *idx;
    } else {
        return 0;
    }
}

Test 1 (public)

Group: 1, 2, 3

Verdict: ACCEPTED

Test 2 (public)

Group: 1, 2, 3

Verdict: ACCEPTED

Test 3 (public)

Group: 1, 2, 3

Verdict: ACCEPTED

Test 4 (public)

Group: 1, 2, 3

Verdict: ACCEPTED

Test 5 (public)

Group: 1, 2, 3

Verdict: ACCEPTED

Test 6 (public)

Group: 1, 2, 3

Verdict: ACCEPTED

Test 7 (public)

Group: 2, 3

Verdict: ACCEPTED

Test 8 (public)

Group: 2, 3

Verdict: ACCEPTED

Test 9 (public)

Group: 2, 3

Verdict: ACCEPTED

Test 10 (public)

Group: 2, 3

Verdict: ACCEPTED

Test 11 (public)

Group: 2, 3

Verdict: ACCEPTED

Test 12 (public)

Group: 2, 3

Verdict: ACCEPTED

Test 13 (public)

Group: 3

Verdict: ACCEPTED

Test 14 (public)

Group: 3

Verdict: ACCEPTED

Test 15 (public)

Group: 3

Verdict: ACCEPTED

Test 16 (public)

Group: 3

Verdict: ACCEPTED

Test 17 (public)

Group: 3

Verdict: ACCEPTED

Test 18 (public)

Group: 3

Verdict: ACCEPTED