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 E2011 · EasyUnit conversion

Rectangle Dimensions

Autumn Tournament (2011)

Submission name: rectangle.cpp

Solve in Editor →

Problem summary

A rectangle has perimeter x metres and y centimetres. Its longer side exceeds its shorter side by d centimetres. Recover both side lengths.

Source clarification. The PDF does not explicitly prescribe the order of the two sides; this solution follows its sample by printing the longer side first.

Input

Integers x and y on the first line; integer d on the second line.

Output

Print the longer side, then the shorter side, each on its own line as metres and remaining centimetres.

Constraints

The sought dimensions are no greater than 999,999,999 metres. The statement supplies no further numeric bounds; the data describe a rectangle.

Worked example

Original statement sample, translated without changing its numeric data.

Input

11 40
70

Output

3 20
2 50

Solution analysis

Convert the entire perimeter into centimetres: P = 100x + y. If the sides are L and S, then L + S = P/2 and L − S = d.
Adding the two equations gives L = (P/2 + d)/2. Then S = P/2 − L. Compute in long long, since even a valid side can have almost 10^11 centimetres.
For perimeter 11 m 40 cm, the half-perimeter is 570 cm. With difference 70 cm, the sides are 320 cm and 250 cm, printed as 3 20 and 2 50.

Why it works

The computed lengths have sum P/2 and difference d, so their perimeter and difference match the given data. These two equations have a unique solution, hence they recover the original dimensions.

Complexity: O(1) time and O(1) extra space: the input has a fixed number of values.

Watch out. Convert metres to centimetres before combining units. Split a length with /100 and %100; use long long for the perimeter.

Commented C++17 solution

An independently written complete program with standard headers.

#include<iostream>
using namespace std;
int main(){
    long long metres,centimetres,difference;
    cin>>metres>>centimetres>>difference;
    long long halfPerimeter=(100*metres+centimetres)/2;
    long long longer=(halfPerimeter+difference)/2;
    long long shorter=halfPerimeter-longer;
    // Quotient and remainder recover metres and centimetres.
    cout<<longer/100<<' '<<longer%100<<'\n';
    cout<<shorter/100<<' '<<shorter%100<<'\n';
}

Source: Arena Olimpiici ↗

Beginner.Your first challenges.

Rectangle Dimensions

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.