Tulkki

use std::{char, collections::HashMap, io::{self, BufRead}};
#[derive(Debug)]
enum OPERATION{
    CLEAR(char),
    PRINT(char),
    INCREASE(char),
    REPEAT(char, Vec<OPERATION>),
}
fn run_operations(list: &Vec<OPERATION>, map: &mut HashMap<char,i32>){
    for command in list{
        match command {
            OPERATION::CLEAR(char) => if let Some(juusto) = map.get_mut(char){*juusto = 0},
            OPERATION::PRINT(char) => if let Some(juusto) = map.get_mut(char){print!("{} ", juusto)},
            OPERATION::INCREASE(char) => if let Some(juusto) = map.get_mut(char){*juusto += 1},
            OPERATION::REPEAT(char , juustot) => if let Some(juusto) = map.get_mut(char){let thing = *juusto as usize; for _i in 0..thing{run_operations(juustot, map);}},
        }
    }
}

fn find_match_index(txt: &Vec<char>, index:usize)->usize{
    let mut count = 1;
    let mut i = index + 1;
    while count != 0{
        if txt.len() > i{
            if txt[i] == '('{
                count += 1;
            }else if txt[i] == ')'{
                count -= 1;
            }
            i += 1;
        }else{
            //print!("error");
            break;
        }
    }
    return i-1;
}
fn string_to_operation(text: Vec<char>, start:usize, finish:usize) -> Vec<OPERATION>{
    let mut rtrn: Vec<OPERATION> = Vec::new();
    let mut j = start;
    while j < finish{
        if j + 6 < text.len(){
            if text[j] == 'C' && text[j+1] == 'L'{
                rtrn.push(OPERATION::CLEAR(text[j + 6]));
            }
            else if text[j] == 'P' && text[j+1] == 'R'{
                rtrn.push(OPERATION::PRINT(text[j + 6]));
            }
            else if text[j] == 'I' && text[j+1] == 'N' && text[j+2] == 'C'{
                rtrn.push(OPERATION::INCREASE(text[j + 9]));
            }
            else if text[j] == 'R' && text[j+1] == 'E' && text[j+2] == 'P'{
                let end:usize =find_match_index(&text, j + 16);
                rtrn.push(OPERATION::REPEAT(text[j + 7], string_to_operation(text.clone(), j + 16, end-1)));
                j = end;
            }
        }
        else{
            //print!("problem");
        }
        j += 1;
    }
    return rtrn;
}
fn main(){
    let mut variables: HashMap<char, i32> = HashMap::new();
    let alphabets: Vec<char> = vec!['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'];
    for letter in alphabets{
        variables.insert(letter, 0);
    }
    let stdin = io::stdin();
    let mut lines: Vec<String> = Vec::new();

    for line in stdin.lock().lines() {
        let l = line.unwrap();
        lines.push(l);
    }
    lines.retain(|l| !l.is_empty());
    lines.retain(|l| l.chars().next().unwrap() != '#');

    let input = lines.join(" ");
    //print!("{}", input);
    let chars:Vec<char> = input.chars().collect();
    //print!("{:?}", chars);
    let index = 0;
    let length = chars.len();
    let _ops= string_to_operation(chars, index, length);
    //println!("{:?}", _ops);
    run_operations(&_ops,&mut variables);
}

Test 1 (public)

Group: 1, 2, 3

Verdict: ACCEPTED

Test 2 (public)

Group: 1, 2, 3

Verdict: WRONG ANSWER

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