Tulkki

input/code.cpp: In function 'void process_token(std::vector<Token>&, std::vector<Token>&, std::array<long unsigned int, 26>&, std::vector<Repeat>&, const Token&)':
input/code.cpp:57:18: warning: format '%d' expects argument of type 'int', but argument 2 has type 'std::array<long unsigned int, 26>::value_type' {aka 'long unsigned int'} [-Wformat=]
   57 |         printf("%d ", vars[token.data - 'A']);
      |                 ~^
      |                  |
      |                  int
      |                 %ld

#include <array>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>
#include <stdint.h>
#include <vector>

enum class TokenType {
    CLEAR,
    INCREASE,
    PRINT,
    REPEAT,
};

struct Token {
    TokenType type;
    uint64_t data;
    size_t parent;
};

struct Repeat {
    size_t times;
    size_t start;
    size_t end;
};

int trim(char* str, int i) {
    while (true) {
        bool edited = false;
        while (isspace(str[i])) {
            i++;
            edited = true;
        }

        if (str[i] == '#') {
            while (str[i] != '\n') {
                i++;
                edited = true;
            }
        }

        if (!edited) {
            break;
        }
    }

    return i;
}

void process_token(std::vector<Token> &tokens, std::vector<Token> &repeat_tokens, std::array<uint64_t, 26> &vars, std::vector<Repeat> &repeats, const Token &token) {
    if (token.type == TokenType::CLEAR) {
        vars[token.data - 'A'] = 0;
    } else if (token.type == TokenType::INCREASE) {
        vars[token.data - 'A']++;
    } else if (token.type == TokenType::PRINT) {
        printf("%d ", vars[token.data - 'A']);
    } else if (token.type == TokenType::REPEAT) {
        const Repeat &repeat = repeats[token.data];
        const size_t repeat_times = vars[repeat.times - 'A'];

        for (size_t i = 0; i < repeat_times; i++) {
            for (size_t j = repeat.start; j < repeat.end; j++) {
                if (repeat_tokens[j].parent == token.data)
                    process_token(tokens, repeat_tokens, vars, repeats, repeat_tokens[j]);
            }
        }
    }
}

int main() {
    std::vector<Repeat> repeats;
    std::vector<Token> tokens;

    bool in_repeat = false;
    std::vector<Token> repeat_tokens;
    std::vector<size_t> repeat_stack;

    std::array<uint64_t, 26> vars = {0};

    char input[128*1000];
    char *ptr = input;
    size_t len = read(STDIN_FILENO, input, 128*1000);
    input[len] = '\0';
    while (true) {
        int i = 0;
        
        if (ptr[i] == '\0' or ptr[i] == EOF) {
            break;
        }

        i = trim(ptr, 0);

        Token token;
        token.data = 0;

        bool repeat_added = false;

        if (strncmp(ptr + i, "CLEAR", 5) == 0) {
            token.type = TokenType::CLEAR;
            i += 5;
        } else if (strncmp(ptr + i, "INCREASE", 8) == 0) {
            token.type = TokenType::INCREASE;
            i += 8;
        } else if (strncmp(ptr + i, "PRINT", 5) == 0) {
            token.type = TokenType::PRINT;
            i += 5;
        } else if (strncmp(ptr + i, "REPEAT", 6) == 0) {
            token.type = TokenType::REPEAT;
            i += 6;
            if (in_repeat) {
                repeats.push_back({0, repeat_tokens.size() + 1, 0});
            } else {
                repeats.push_back({0, repeat_tokens.size(), 0});
            }
            repeat_added = true;
        } else if (ptr[i] == '(') {
            ptr += i + 1;
            continue;
        } else if (ptr[i] == ')') {
            const size_t idx = repeat_stack.back();
            repeat_stack.pop_back();

            repeats[idx].end = repeat_tokens.size();
            ptr += i + 1;

            if (repeat_stack.empty()) {
                in_repeat = false;
            }
            continue;
        } else {
            break;
        }

        i = trim(ptr, i);

        token.data = ptr[i];

        int parent = -1;
        
        if (repeat_added) {
            i += 1;
            i = trim(ptr, i);
            if (strncmp(ptr + i, "TIMES", 5) != 0) {
                printf("Error: REPEAT must be followed by TIMES\n");
            }

            i += 5;
            i = trim(ptr, i);

            if (ptr[i] != '(') {
                printf("Error: TIMES must be followed by parentheses\n");
            }

            repeats.back().times = token.data;
            token.data = repeats.size() - 1;

            if (!repeat_stack.empty()) {
                parent = repeat_stack.back();
            }
            repeat_stack.push_back(repeats.size() - 1);
        }

        if (in_repeat) {
            if (parent == -1) {
                token.parent = repeat_stack.back();
            } else {
                token.parent = parent;
            }

            repeat_tokens.push_back(token);
        } else {
            tokens.push_back(token);

            if (repeat_added) {
                in_repeat = true;
            }
        }
        ptr += i + 1;
    }


    for (auto& token : tokens) {
        process_token(tokens, repeat_tokens, vars, repeats, token);
    }
}

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