— Dark mode

Datatähti 2026 alku

Tulkki

  • Start: 2025-10-27 00:00:00
  • End: 2025-11-10 00:00:00
Submission details
Task:Tulkki
Sender:Jaksu
Submission time:2025-10-28 17:33:41 +0200
Language:Rust (2021)
Status:READY
Result:44
Feedback
groupverdictscore
#1ACCEPTED12
#2ACCEPTED32
#30
Test results
testverdicttimegroup
#1ACCEPTED0.00 s1, 2, 3details
#2ACCEPTED0.00 s1, 2, 3details
#3ACCEPTED0.00 s1, 2, 3details
#4ACCEPTED0.00 s1, 2, 3details
#5ACCEPTED0.00 s1, 2, 3details
#6ACCEPTED0.01 s1, 2, 3details
#7ACCEPTED0.00 s2, 3details
#8ACCEPTED0.00 s2, 3details
#9ACCEPTED0.00 s2, 3details
#10ACCEPTED0.00 s2, 3details
#11ACCEPTED0.00 s2, 3details
#12ACCEPTED0.00 s2, 3details
#13ACCEPTED0.00 s3details
#14ACCEPTED0.00 s3details
#15--3details
#16ACCEPTED0.00 s3details
#17ACCEPTED0.60 s3details
#18ACCEPTED0.05 s3details

Compiler report

warning: unused import: `str::SplitAsciiWhitespace`
 --> input/code.rs:1:15
  |
1 | use std::{io, str::SplitAsciiWhitespace};
  |               ^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

warning: 1 warning emitted

Code

use std::{io, str::SplitAsciiWhitespace};

fn main() {
    let mut command: String = String::from("");
    let mut variables: [usize; 26] = [0;26];
    let mut index: usize = 0;
    let mut emptylines: usize = 0;
    let mut ignorenext: usize = 0;
    let mut repeatmemory: Vec<String> = vec!();
    let mut repeating: bool = false;
    let mut leftbrackets: usize = 0;
    let mut rightbrackets: usize = 0;
    loop {
        let mut input = String::new();
        io::stdin().read_line(&mut input).expect("Failed to read input");

        if input.trim() == String::new() {
            emptylines += 1;
            if emptylines > 100 {
                break;
            }
        }

        let splitcode: Vec<String> = input.split("#").map(|e| e.to_string()).collect();
        let code = &splitcode[0];
        let instructionlist: Vec<String> = code.split_ascii_whitespace().map(|e| e.to_string()).collect();

        run(instructionlist, &mut ignorenext, &mut command, &mut index, &mut variables, &mut repeatmemory, &mut repeating, &mut leftbrackets, &mut rightbrackets);
    }
}

pub fn run(instructionlist: Vec<String>, ignorenext: &mut usize, command: &mut String, index: &mut usize, variables: &mut [usize;26], repeatmemory: &mut Vec<String>, repeating: &mut bool, leftbrackets: &mut usize, rightbrackets: &mut usize) {
    for instruction in instructionlist {
        if *ignorenext > 0 {
            *ignorenext -= 1;
            continue;
        }

        if !*repeating {
            if *command != String::from("") {
                *index = instruction.as_bytes()[0] as usize - 65;
                let val = command.as_str();

                match val {
                    // VAIHDA STRINGEIKSI
                    "CLEAR" => {variables[*index] = 0;},
                    "INCREASE" => {variables[*index] += 1;},
                    "PRINT" => {println!("{}", variables[*index]);},
                    "REPEAT" => {*ignorenext = 2; *repeating = true; *leftbrackets += 1},
                    _ => {},
                }
                if command != "REPEAT" {
                    *command = String::from("");
                }
            } else {
                *command = instruction;
            }
        } else {
            if instruction != String::from(")") {
                if instruction == String::from("(") {
                    *leftbrackets += 1;
                }
                repeatmemory.push(instruction);
            } else {
                *rightbrackets += 1;

                if leftbrackets == rightbrackets {
                    let mut repeatmemory2: Vec<String> = vec!();
                    let mut repeatignorenext: usize = 0;
                    let mut repeatcommand = "".to_string();
                    let mut repeatindex: usize = 0;
                    let mut repeatrepeating: bool = false;

                    let repeatamount = variables[*index].clone();
                    dbg!(&repeatmemory);
                    dbg!(&repeatamount);

                    for _i in 0..repeatamount {
                        run(repeatmemory.to_vec(), &mut repeatignorenext, &mut repeatcommand, &mut repeatindex, variables, &mut repeatmemory2, &mut repeatrepeating, leftbrackets, rightbrackets);
                    }

                    *repeating = false;
                    *command = "".to_string();
                    *repeatmemory = vec!();
                } else {
                    repeatmemory.push(instruction);
                }
            }
        }
    }
}

#[derive(PartialEq, Eq, Debug)]
pub enum Command {
    None,
    Clear,
    Increase,
    Print,
    Repeat,
}

Test details

Test 1 (public)

Group: 1, 2, 3

Verdict: ACCEPTED

input
PRINT X
INCREASE X
PRINT X
INCREASE X
PRINT X
...
view save

correct output
0 1 2 0 
view save

user output
0
1
2
0
view save

Test 2 (public)

Group: 1, 2, 3

Verdict: ACCEPTED

input
INCREASE
X
# aybabtu
   PRINT    X
INCREASE # test
...
view save

correct output
1 3 
view save

user output
1
3
view save

Test 3 (public)

Group: 1, 2, 3

Verdict: ACCEPTED

input
# Create number 3
INCREASE X
INCREASE X
INCREASE X

...
view save

correct output
3 
view save

user output
3
view save

Test 4 (public)

Group: 1, 2, 3

Verdict: ACCEPTED

input
INCREASE A
PRINT A
INCREASE B
PRINT B
INCREASE C
...
view save

correct output
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 ...
view save

user output
1
1
1
1
1
...
view save

Test 5 (public)

Group: 1, 2, 3

Verdict: ACCEPTED

input
INCREASE X
INCREASE X
INCREASE X
INCREASE X
INCREASE X
...
view save

correct output
999 
view save

user output
999
view save

Test 6 (public)

Group: 1, 2, 3

Verdict: ACCEPTED

input
PRINT X
PRINT X
PRINT X
PRINT X
PRINT X
...
view save

correct output
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ...
view save

user output
0
0
0
0
0
...
view save

Test 7 (public)

Group: 2, 3

Verdict: ACCEPTED

input
INCREASE A
INCREASE A
INCREASE A
INCREASE A
INCREASE A
...
view save

correct output
5 5 5 5 5 
view save

user output
5
5
5
5
5
view save

Error:
[input/code.rs:75] &repeatmemory = [
    "PRINT",
    "A",
]
[input/code.rs:76] &repeatamount = 5

Test 8 (public)

Group: 2, 3

Verdict: ACCEPTED

input
INCREASE A
INCREASE A
INCREASE A
INCREASE A
INCREASE A
...
view save

correct output
0 0 0 0 0 
view save

user output
0
0
0
0
0
view save

Error:
[input/code.rs:75] &repeatmemory = [
    "CLEAR",
    "A",
    "PRINT",
    "A",
]
[input/code.rs:76] &repeatamount = 5

Test 9 (public)

Group: 2, 3

Verdict: ACCEPTED

input
INCREASE A
INCREASE A
INCREASE A
INCREASE A
INCREASE A
...
view save

correct output
6 7 8 9 10 
view save

user output
6
7
8
9
10
view save

Error:
[input/code.rs:75] &repeatmemory = [
    "INCREASE",
    "A",
    "PRINT",
    "A",
]
[input/code.rs:76] &repeatamount = 5

Test 10 (public)

Group: 2, 3

Verdict: ACCEPTED

input
INCREASE A
INCREASE A
INCREASE A
INCREASE A
INCREASE A
...
view save

correct output
5 5 
view save

user output
5
5
view save

Error:
[input/code.rs:75] &repeatmemory = [
    "INCREASE",
    "B",
    "INCREASE",
    "C",
]
[input/code.rs:76] &repeatamount = 5

Test 11 (public)

Group: 2, 3

Verdict: ACCEPTED

input
INCREASE A
INCREASE A
INCREASE A
INCREASE A
INCREASE A
...
view save

correct output
20 
view save

user output
20
view save

Error:
[input/code.rs:75] &repeatmemory = [
    "INCREASE",
    "A",
]
[input/code.rs:76] &repeatamount = 5
[input/code.rs:75] &repeatmemory = [
    "INCREASE",
    "A",
]
[input/code.rs:76] &repeatamount = 10

Test 12 (public)

Group: 2, 3

Verdict: ACCEPTED

input
INCREASE A
INCREASE A

INCREASE B
INCREASE B
...
view save

correct output
42 
view save

user output
42
view save

Error:
[input/code.rs:75] &repeatmemory = [
    "INCREASE",
    "A",
    "INCREASE",
    "B",
]
[input/code.rs:76] &repeatamount = 3
[input/code.rs:75] &repeatmemory = [
    "INCREASE",
    "A",
    "INCREASE",
    "A",
    "INCREASE",
    "A",
    "INCREASE",
    "B",
]
[input/code.rs:76] &repeatamount = 5
[input/code.rs:75] &repeatmemory = [
    "INCREASE",
    "A",
    "INCREASE",
    "A",
]
[input/code.rs:76] &repeatamount = 11

Test 13 (public)

Group: 3

Verdict: ACCEPTED

input
INCREASE A
INCREASE A
INCREASE A
INCREASE A
INCREASE A
...
view save

correct output
1 2 2 3 3 3 4 4 4 4 5 5 5 5 5 
view save

user output
1
2
2
3
3
...
view save

Error:
[input/code.rs:75] &repeatmemory = [
    "INCREASE",
    "B",
    "REPEAT",
    "B",
    "TIMES",
    "(",
    "PRINT",
    "B",
    ")",
]
[input/code.rs:76] &repeatamount = 5
[input/code.rs:75] &repeatmemory = [
    "PRINT",
    "B",
]
[input/code.rs:76] &repeatamount = 1
[input/code.rs:75] &repeatmemory = [
    "PRINT",
    "B",
]
[input/code.rs:76] &repeatamount = 2
[input/code.rs:75] &repeatmemory = [
    "PRINT",
    "B",
]
[input/code.rs:76] &repeatamount = 3
[input/code.rs:75] &repeatmemory = [
    "PRINT",
    "B",
]
[input/code.rs:76] &repeatamount = 4
[input/code.rs:75] &repeatmemory = [
    "PRINT",
    "B",
]
[input/code.rs:76] &repeatamount = 5

Test 14 (public)

Group: 3

Verdict: ACCEPTED

input
# Create number 3
INCREASE A INCREASE A INCREASE...
view save

correct output
12 
view save

user output
12
view save

Error:
[input/code.rs:75] &repeatmemory = [
    "REPEAT",
    "B",
    "TIMES",
    "(",
    "INCREASE",
    "C",
    ")",
]
[input/code.rs:76] &repeatamount = 3
[input/code.rs:75] &repeatmemory = [
    "INCREASE",
    "C",
]
[input/code.rs:76] &repeatamount = 4
[input/code.rs:75] &repeatmemory = [
    "INCREASE",
    "C",
]
[input/code.rs:76] &repeatamount = 4
[input/code.rs:75] &repeatmemory = [
    "INCREASE",
    "C",
]
[input/code.rs:76] &repeatamount = 4

Test 15 (public)

Group: 3

Verdict:

input
INCREASE X
INCREASE X
INCREASE X
INCREASE X
INCREASE X
...
view save

correct output
531441 
view save

user output
(empty)

Test 16 (public)

Group: 3

Verdict: ACCEPTED

input
INCREASE A
INCREASE A
INCREASE A
INCREASE A
INCREASE A
...
view save

correct output
1337 
view save

user output
1337
view save

Error:
[input/code.rs:75] &repeatmemory = [
    "REPEAT",
    "B",
    "TIMES",
    "(",
    "INCREASE",
    "B",
    ")",
    "INCREASE",
    "B",
]
[input/code.rs:76] &repeatamount = 5
[input/code.rs:75] &repeatmemory = [
    "INCREASE",
    "B",
]
[input/code.rs:76] &repeatamount = 5
[input/code.rs:75] &repeatmemory = [
    "INCREASE",
    "B",
]
[input/code.rs:76] &repeatamount = 11
[input/code.rs:75] &repeatmemory = [
    "INCREASE",
    "B",
]
[input/code.rs:76] &repeatamount = 23
[input/code.rs:75] &repeatmemory = [
    "INCREASE",
    "B",
]
[input/code.rs:76] &repeatamount = 47
[input/code.rs:75] &repeatmemory = [
    "INCREASE",
    "B",
]
[input/code.rs:76] &repeatamount = 95
[input/code.rs:75] &repeatmemory = [
    "REPEAT",
    "B",
    "TIMES",
    "(",
    "INCREASE",
    "C",
    ")",
]
[input/code.rs:76] &repeatamount = 7
[input/code.rs:75] &repeatmemory = [
    "INCREASE",
    "C",
]
[input/code.rs:76] &repeatamount = 191
[input/code.rs:75] &repeatmemory = [
    "INCREASE",...

Test 17 (public)

Group: 3

Verdict: ACCEPTED

input
INCREASE A
INCREASE A

REPEAT A TIMES (
    REPEAT A TIMES (
...
view save

correct output
1 2 1 2 1 1 3 4 3 4 3 4 3 4 3 ...
view save

user output
1
2
1
2
1
...
view save

Error:
[input/code.rs:75] &repeatmemory = [
    "REPEAT",
    "A",
    "TIMES",
    "(",
    "INCREASE",
    "B",
    "CLEAR",
    "C",
    "REPEAT",
    "B",
    "TIMES",
    "(",
    "INCREASE",
    "C",
    ")",
    "PRINT",
    "C",
    "REPEAT",
    "C",
    "TIMES",
    "(",
    "CLEAR",
    "C",
    "REPEAT",
    "A",
    "TIMES",
    "(",
    "PRINT",
    "A",
    "PRINT",
    "B",
    ")",
    ")",
    "REPEAT",
    "B",
    "TIMES",
    "(",
    "INCREASE",
    "D",
    "PRINT",
    "D",
    ")",
    "INCREASE",
    "B",
    "CLEAR",
    "A",
    "REPEAT",
    "B",
    "TIMES",
    "(",
    "REPEAT",
    "B",
    "TIMES",
    "(",
    "INCREASE",
    "A",
    ")",
    ")",
    ")",
]
[input/code.rs:76] &repeatamount = 2
[input/code.rs:75] &repeatmemory = [
    "INCREASE",
    "B",
    "CLEAR",
    "C",
    "REPEAT",
    "B",
    "TIMES",
    "(",
    "INCREASE",
    "C",
    ")",
    "PRINT",
    "C",
    "REPEAT",
    "C",
    "TIMES",
    "(",
    "CLEAR",
    "C",
    "REPEAT",...

Test 18 (public)

Group: 3

Verdict: ACCEPTED

input
# Efficient algorithm for find...
view save

correct output
2 3 5 7 11 13 17 19 23 29 31 3...
view save

user output
2
3
5
7
11
...
view save

Error:
[input/code.rs:75] &repeatmemory = [
    "INCREASE",
    "X",
    "CLEAR",
    "A",
    "REPEAT",
    "B",
    "TIMES",
    "(",
    "INCREASE",
    "A",
    ")",
    "REPEAT",
    "A",
    "TIMES",
    "(",
    "INCREASE",
    "X",
    "INCREASE",
    "C",
    ")",
    "REPEAT",
    "B",
    "TIMES",
    "(",
    "CLEAR",
    "A",
    "REPEAT",
    "X",
    "TIMES",
    "(",
    "INCREASE",
    "A",
    "INCREASE",
    "Q",
    ")",
    "CLEAR",
    "X",
    "REPEAT",
    "A",
    "TIMES",
    "(",
    "INCREASE",
    "X",
    "INCREASE",
    "K",
    ")",
    ")",
    "INCREASE",
    "G",
    "CLEAR",
    "C",
    "CLEAR",
    "D",
    "INCREASE",
    "F",
    "REPEAT",
    "X",
    "TIMES",
    "(",
    "INCREASE",
    "D",
    "REPEAT",
    "F",
    "TIMES",
    "(",
    "CLEAR",
    "Y",
    "INCREASE",
    "D",
    ")",
    "CLEAR",
    "F",
    "INCREASE",
    "D",
    "INCREASE",
    "F",
    "REPEAT",
    "C",
    "TIMES",
    "(",
    "CLEAR",
    "D",
    "INCREASE",
    "I"...

Tasks

A Palindromi-B Monikulmio-C Tulkki-D Maalaus-E Hypyt-F Lukujono-

Submissions (Jaksu)

2025-10-28 17:36:13 1002025-10-28 17:33:41 442025-10-28 14:41:39 442025-10-28 14:38:46 442025-10-28 13:52:05 122025-10-28 12:26:15 122025-10-28 12:24:00 02025-10-28 12:02:20 0