FROM LEARNING TO COMPETING

Beginner.
Your first challenges.

Bulgarian Informatics Group E · 2007–2026

270 independently explained problems: 54 Municipal, 54 Regional, 105 National Olympiad tasks and 57 Autumn Tournament tasks. Start with the easier tasks and work upwards. Difficulty labels are learning estimates, not official ratings; Group E also includes challenging national-level problems. Years follow Arena’s competition-season labels. Source clarifications are noted on affected tasks.

Search by name or topic

Round / tournamentYearContent

Easy149

Loops & simulation 26

Greedy 1

String parsing 1

Bitmask enumeration 1

Time arithmetic 1

Intervals 2

Exhaustive search 1

Counting 9

String checks 1

Running maximum 2

Sorting 5

Intervals 1

String construction 1

Digit patterns 1

Time arithmetic 1

Inverse operations 1

Unit conversion 1

Integer arithmetic 5

Comparisons 1

Running minimum 1

String parsing 1

Simulation 1

Geometry 1

Reverse simulation 1

Conditions 1

Enumeration 1

Conditional logic 1

Nested loops & patterns 1

String scanning 1

Intervals & counting 1

Strings & digits 2

Intervals & counting 1

Arrays & differences 1

Greedy comparison 1

Integer arithmetic 1

Counting 1

Counting formulas 2

Loops & modulo 1

String filtering 1

Enumeration 2

Sorting & geometry 1

Minima & maxima 1

Time arithmetic 4

Digits & comparison 1

Digit checks 1

Digit replacement 1

String scans 1

Streaming minimum & maximum 1

Loops & simulation 6

String scans 1

Frequency counting 1

Strings & sorting 1

Strings & scoring 1

Integer arithmetic 1

Running state 1

Sorting 1

Modular simulation 1

Exhaustive cases 1

Pattern reasoning 1

Prefix balances 1

Counting & frequencies 1

Digits & enumeration 1

Case analysis 1

Periodic counting 1

Circular distance 1

Digit arithmetic 1

Time simulation 1

Digits & arithmetic 1

Prefix sums & tie breaking 1

Arrays & simulation 1

String runs 1

Parity 1

Calendar simulation 1

Grids & bounds 1

Expression parsing 1

Binary representation 1

Digit prefix sums 1

Ceiling division & money 1

Time simulation 1

Bounded enumeration 1

Counting & filtering 1

String conversion 1

Occupancy arrays 1

Integer arithmetic 1

GCD & LCM 1

Presence tracking 1

GCD & LCM 1

Set bounds 1

State simulation 1

Expression parsing 1

Conservation of flow 1

GCD & LCM 1

Division with remainder 1

Grid neighbors 1

Medium96

Arithmetic 1

Piecewise arithmetic 1

Dynamic programming 1

Exhaustive search 1

Parsing & run-length encoding 1

Time arithmetic 2

Binary search 1

Counting multiples 1

Independent greedy choices 1

Greedy digit construction 1

Arithmetic progressions 1

Integer arithmetic 2

Arrays & scoring 1

Divisibility & GCD 4

Strings & runs 2

Loops & simulation 1

Loops & simulation 9

Counting formulas 3

Sorting & sets 1

Case analysis 1

Subset dynamic programming 2

State machines 1

Sequence simulation 1

Bounds & greedy 1

Binary search 1

Set elimination 1

Time & simulation 1

Greedy purchasing 1

Greedy counting 1

GCD & LCM 1

Greedy counting 2

Array scanning 1

Exhaustive search 1

Prime factors 1

Pattern reasoning 2

Prefix sums 2

Time & filtering 1

Runs & streaming 1

Decimal arithmetic 1

Number patterns 1

Exhaustive search 2

Parity counting 1

Time simulation 1

Calendar simulation 1

Bounded enumeration 1

Ratios & limiting resources 1

Two pointers 1

Time rounding 1

Running state 1

Geometry & greedy bounds 1

Circular intervals 1

Dynamic programming 1

Remainder counting 1

Algebra & enumeration 1

Prefix counts 1

Round simulation 1

Interval overlap 1

Prefix & suffix sums 1

Periodic sequences 1

Difference arrays 1

Queue simulation 1

Grid geometry 1

Primes & search 1

Running maximum 1

Sliding windows 1

Prime sieve 1

Arrays & simulation 1

Enumerating capacity 1

Time & exhaustive search 1

Prime factorization 2

Inclusion–exclusion 1

Factorization & simulation 1

Number theory 1

Hard23

GCD, LCM & parity 1

Prefix sums 1

Enumeration 1

Counting & frequencies 1

Greedy construction 2

Binary search 1

Two pointers 1

Sliding windows 1

Divisor sums & factorization 1

Geometry & money 1

GCD & divisors 1

Nested simulation 1

Pair enumeration 1

Frequency simulation 1

Two pointers 1

Frequency counting 1

Binary search 1

Palindrome generation 1

Dynamic programming 1

Interval reconstruction 1

Periodic counting 1

Number theory 1

Very hard2

Compressed suffix GCDs 1

Meet in the middle 1

Try the problem yourself before reading the analysis. Every solution uses standard C++17 headers.

GROUP E2013 · EasyExpression parsing

Check the Equality

National Olympiad — National round (2013 season)

Submission name: equ.cpp

Solve in Editor →

Problem summary

An equality contains one operation (+,−,*) and arbitrary lowercase letters mixed into the numbers. Remove the letters to recover the operands and claimed result. Check the equality.

Input

One line of digits, lowercase letters and the symbols +,−,*,=, without spaces.

Output

If correct, print Yes and the absolute difference of the two operands. If incorrect, print No and the correct operation result.

Constraints

0 ≤ numbers ≤ 1,000,000,000; 5 ≤ line length ≤ 100; for subtraction the first operand exceeds the second.

Worked example

An independently prepared example for this explanation.

Input

as4da5fd+xx2x3xx8xx=qw283

Output

Yes 193

Solution analysis

Ignore lowercase letters. Build each number digit by digit; an operation ends the first operand and = ends the second.
Evaluate the recovered operation in long long. If it matches the claimed result, output the absolute operand difference; otherwise output the computed result.
The sample becomes 45+238=283. It is true, so output Yes and 238−45=193, rather than the result 283.

Why it works

Discarding letters leaves the decimal digits of each original number in order. The delimiter scan separates exactly the two operands and claimed result. Evaluation and comparison establish truth, and the chosen output follows the corresponding rule.

Complexity: O(L) time; O(L) input storage and O(1) working space.

Watch out. On a true equality the requested number is the operand difference. Multiplication may reach 10^18.

Commented C++17 solution

An independently written complete program with standard headers.

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main() {
    string text;
    cin >> text;
    long long numbers[3] = {};
    int index = 0;
    char operation = '+';
    for (char symbol : text) {
        // Letters are ignored; delimiters alone select the next number.
        if (symbol >= '0' && symbol <= '9') {
            numbers[index] = numbers[index] * 10 + symbol - '0';
        } else if (symbol == '+' || symbol == '-' || symbol == '*') {
            operation = symbol;
            index = 1;
        } else if (symbol == '=') {
            index = 2;
        }
    }
    long long result;
    if (operation == '+') {
        result = numbers[0] + numbers[1];
    } else if (operation == '-') {
        result = numbers[0] - numbers[1];
    } else {
        result = numbers[0] * numbers[1];
    }
    if (result == numbers[2]) {
        cout << "Yes " << max(numbers[0], numbers[1]) - min(numbers[0], numbers[1]);
    } else {
        cout << "No " << result;
    }
    cout << '\n';
}

Source: Arena Olimpiici ↗

Beginner.Your first challenges.

Check the Equality

Problem summary

Input

Output

Constraints

Worked example

Input

Output

Solution analysis

Why it works

Commented C++17 solution

Start with a small challenge.

Beginner.
Your first challenges.