Tulkki

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

warning: 1 warning emitted

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

/*#[derive(PartialEq, Clone, Debug, Copy)]
enum Command {
    INCREASE,
    CLEAR,
    PRINT,
    REPEAT,
    NONE
}

#[derive(PartialEq, Clone, Debug)]
enum Value {
    CMD(Command),
    REPEAT((usize, Vec<(Box<Value>, Box<Value>)>)),
    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 commands: Vec<(Value, Value)> = Vec::new();
    let mut all_components: Vec<String> = Vec::new();

    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();
        all_components.extend(components.clone());
    }
    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<String>, 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<String> = Vec::new();


    let mut test = 1;
    for (i, component) in components.iter().enumerate() {
        /*commands.push(match component.as_str() {
            "INCREASE" => (Value::CMD(Command::INCREASE), Value::VARIABLE(get_variable_index(&all_components[i+1]))),
            "PRINT" => (Value::CMD(Command::PRINT), Value::VARIABLE(get_variable_index(&all_components[i+1]))),
            "CLEAR" => (Value::CMD(Command::CLEAR), Value::VARIABLE(get_variable_index(&all_components[i+1]))),
            "REPEAT" => (Value::CMD(Command::REPEAT), Value::REPEAT((get_variable_index(&all_components[i+1]), Vec::new()))),
            "(" => (is_repeat = true)
            _ => continue,
        })*/
        if catch_components {
            if component.to_string() == "REPEAT" {
                test += 1;
            }
            if component.to_string() == ")"  {
                test -= 1;
            }
            if test == 0 {
                catch_components = false;
                for _ in 0..repeat_amount {
                    (output, data) = run(caught_components.clone(), output, data)
                }
            }
            caught_components.push(component.to_string());
        } else {
            match component.as_str() {
                "INCREASE" => data[get_variable_index(&components[i+1])] += 1,
                "CLEAR" => data[get_variable_index(&components[i+1])] = 0,
                "PRINT" => output = format!("{}{} ", output, data[get_variable_index(&components[i+1])]),
                "REPEAT" => repeat_amount = data[get_variable_index(&components[i+1])],
                "(" => {
                    catch_components = true;
                    caught_components = Vec::new()
                },
                _ => continue,
            }
        }
    }
    return (output, data);
}

/*fn run(components: Vec<&str>, mut current_component: Command, mut current_cmd: Command, mut data: [i32; 26]) -> (String, [i32; 26]) {
  let mut output = String::new();
  let mut repeat_amount = 0;
  let mut collect_repeat = false;
  let mut collected_repeat: Vec<String> = Vec::new();
  for component in components {
  current_component = match component {
  "INCREASE" => Command::INCREASE,
  "CLEAR" => Command::CLEAR,
  "PRINT" => Command::PRINT,
  "REPEAT" => Command::REPEAT,
  _ => Command::NONE,
  };
  println!("{}", component);
  if current_component != Command::NONE {
  current_cmd = current_component;
  } else {
  if component == "(" {
  collect_repeat = true;
  } else if component == ")" {
  collect_repeat = false;
  output = format!("{}{} ", output, "a");
  } else {
  let index = ((component.chars().next().unwrap().to_ascii_lowercase()) as u8 - b'a') as usize;
  if current_cmd == Command::INCREASE {
  data[index] += 1;
  } else if current_cmd == Command::CLEAR {
  data[index] = 0;
  } else if current_cmd == Command::PRINT {
  output.push_str(&format!("{} ", data[index]));
  } else if current_cmd == Command::REPEAT {
  repeat_amount = component.parse().unwrap();
  }
  }
  }

  }
  return (output, data);
  }*/

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: WRONG ANSWER

Test 12 (public)

Group: 2, 3

Verdict: WRONG ANSWER

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: WRONG ANSWER

Test 17 (public)

Group: 3

Verdict: WRONG ANSWER

Test 18 (public)

Group: 3

Verdict: WRONG ANSWER