FROM LEARNING TO COMPETING

Intermediate.
Put your skills to the test.

Bulgarian Informatics Group D · 2007–2026

270 independently explained problems: 54 Municipal, 54 Regional, 105 National Olympiad and 57 Autumn Tournament tasks. Start with the easier tasks and work upwards. Difficulty labels are learning estimates, not official ratings; Group D also includes challenging national-level problems. The six 2017 National tasks shared by Groups C and D use their existing permanent URLs. Years follow Arena’s competition-season labels. Source clarifications and special grader requirements are noted on affected tasks.

Search by name or topic

Round / tournamentYearContent

Easy96

Counting 2

Digits 1

Arithmetic 1

Simulation 1

Sorting 2

Big integers 1

Counting 1

Number Theory 1

Strings 1

Arrays and counting 2

Simulation 1

Frequency counting 5

Grid simulation 1

Arithmetic indexing 1

Integer indexing 1

Sets and distinct values 1

Grid scanning 1

Sorting and checking 1

String conversion 1

Run counting 1

Arithmetic and greedy choice 1

Triangle inequalities 1

Combinatorial counting 1

Contribution counting 1

Geometry and boundary updates 1

Prefix sums 2

Arithmetic and digit scanning 1

String arithmetic 1

Digit sequences 1

Strings and positional weights 1

Character frequencies 1

String parsing 2

String scanning 2

Array scanning 2

Prime exponents 1

Permutations 1

Inverse permutations 1

Sequence scanning 1

Circular simulation 1

Digits and divisibility 1

Combinatorics 1

Number bases 1

Geometry enumeration 1

Digit frequency counting 1

Prefix sums and compact storage 1

Circular arrays 1

Periodic simulation 1

Digit arithmetic 1

Suffix maxima 1

Bounded enumeration 2

Sorting by elapsed time 1

Sequence simulation 2

Time simulation 1

Distinct graph neighbours 1

Coordinate geometry 1

Binary Search 1

Interval intersections 1

Calendar arithmetic 1

Geometric sums 1

Previous and next occurrence arrays 1

Precomputation 1

Sorting and simulation 1

Range queries 1

GCD and divisibility 1

Sequence generation 1

Grid rotation 1

Set intersection 1

LCM and arithmetic progressions 1

Euclidean algorithm 1

Window enumeration 1

Bijective base conversion 1

Frequency counting and sorting 1

Divisor enumeration 1

Two pointers on sorted arrays 1

Periodic prefix sums 1

Sorting distinct values 1

Numeral systems 1

Difference arrays 1

Digit sorting 1

Grid components 1

Sequence trend runs 1

Calendar simulation 1

Integer halving bounds 1

Medium142

Ranked Choice Simulation 1

Exhaustive search 2

Arrays and matrices 1

Number theory 1

Simulation 2

Sorting 1

Enumeration 1

Two Pointers 1

Number Theory 1

Strings and simulation 1

Big integers 1

Binary search 1

Binary Search 2

Strings 2

Arrays and counting 1

Sorting and greedy 1

Two pointers 1

Simulation 1

Rational Arithmetic 2

Combinatorial geometry 1

Invariants 1

Modular arithmetic 1

Arithmetic interval counting 1

Binary enumeration 1

Unbounded dynamic programming 1

Streaming digit sequence 1

Big integers 1

Digits and modular arithmetic 1

Fixed-event simulation 1

Frequency counting 2

Bounded-state simulation 1

Two-dimensional prefix sums 1

Prime factorization 3

Frequency inversion 1

Precomputation 1

Prefix and suffix maxima 1

Sorting and greedy 1

Bounding rectangles 1

String runs and simulation 1

Exact rational arithmetic 1

Permutation cycles 1

Partition dynamic programming 1

Sorting and runs 1

Greedy two pointers 1

Sorting and decimal subtraction 1

Boyer–Moore voting 1

Sieve and prefix sums 1

Functional graphs 1

Prime sieve and combinatorics 1

Packed presence bitmap 1

Counting formulas 1

Implicit sequence indexing 1

Constructive geometry 1

Big integer base conversion 1

Prime sieve and prefix sums 1

Geometry and indexing 1

Greedy interval traversal 1

Sorting by concatenation 1

Modular arithmetic and dates 1

Linear recurrence 1

Greedy representation 1

Two Pointers 2

Ordered set and streaming 1

Divisor enumeration 1

Cyclic shifts 1

Breadth-first search 1

Grid dynamic programming 2

Prime sieve 1

Area bounds and enumeration 1

Big integer arithmetic 1

Unbounded knapsack 1

Divisors and formulas 1

Local invariant updates 1

Divisor sieve and prefix sums 1

Sets and symmetry 1

Decimal arithmetic 1

Blocked-grid runs 1

Stacks and subset enumeration 1

Odd divisors 1

Prefix sums 2

Rectangle enumeration 1

Bitmask enumeration 1

Priority queue simulation 1

Big integer doubling 1

Prefix and suffix products 1

Greedy swaps 1

Date enumeration 1

Josephus formula 1

Hypothesis enumeration 1

Grid path invariants 1

Greedy 1

Big integer multiplication 1

Matrix exponentiation 1

String permutation 1

Sorting and two pointers 1

Digit arithmetic 1

Two pointers on positions 1

Stacks and dynamic programming 1

Dynamic programming 1

Sorting and sliding windows 1

Segmented multiple marking 1

Pair-sum preprocessing 1

Periodic indexing 1

Digit dynamic programming 1

Grid scanning 1

Positional digit counting 1

Integer binary search 1

Counting 1

Coprime directions and inclusion-exclusion 1

Multi-source BFS 1

Piecewise volume simulation 1

LCM and modular arithmetic 1

Decimal convolution 1

Number Theory 1

Divisor pairs and LCM 1

Greedy matching 1

Sorting and grouping 1

Graphs 1

Greedy stack simulation 1

Robot Without Reversing 12

Hard32

String algorithms 1

Prefix Sums 1

Number Theory 1

Bitmasks 1

Fenwick order statistics 1

Monotonic stack 1

Bitset dynamic programming 1

Digit constraints 1

Big integers and enumeration 1

Number Theory 1

Fibonacci enumeration 1

Geometry and arithmetic sums 1

Prime sieve 1

Exact rational arithmetic 1

Linear recurrence and counting 1

Greedy digit allocation 1

Flood fill and geometry 1

Suffix DP and lexicographic reconstruction 1

Simulation 1

Monotonic stacks and contributions 1

Greedy string repair 1

Exhaustive search and construction 1

Lexicographic unranking 1

Coordinate compression and BFS 1

Divisors and remainder pairing 1

Cached grid simulation 1

Dijkstra on a hexagonal grid 1

Digit DP and big integers 1

Grid Hamiltonian cycle 1

Divisors and packing 1

Geometry and sweep line 1

Minimum-cost bipartite matching 1

Try the problem yourself before reading the analysis. Solutions use C++17. Special grader headers and compiler requirements are explained on affected tasks.

GROUP D2019 · EasyCalendar simulation

First School Day after a Holiday

National Olympiad — Regional round (2019 season)

Submission name: grip.cpp

Solve in Editor →

Problem summary

A holiday starts on a given date and lasts a number of Monday–Friday school days, including its start when it is a weekday. Find the first school day afterwards.

Input

D/M/Y and school-day duration.

Output

Return date dd.mm.yyyy.

Constraints

Start date in 2019 or 2020; duration 1…45 school days.

Worked example

Input and output for the worked example discussed below.

Input

23/1/2019 8

Output

04.02.2019

Solution analysis

Track calendar date and weekday together. January 1,2019 was Tuesday; advancing from it determines the starting weekday.
Consume a holiday day only on Monday–Friday, always moving one calendar day. After all required days are consumed, skip any following weekend. Gregorian leap-year rules determine February’s length.
Starting Wednesday January 23, eight school days end on Friday February 1. The next weekday is Monday February 4. A weekend start consumes no school day until Monday.

Why it works

The simulation consumes exactly the requested weekdays and then returns the earliest subsequent weekday.

Complexity: O(D+K) time for at most 730 baseline days and the short calendar holiday; O(1) space.

Watch out. Handle February 29,2020, year rollover and zero padding.

Commented C++17 solution

An independently written complete program with standard headers.

// The simulation consumes exactly the requested weekdays and then returns the earliest subsequent weekday.
#include<iomanip>
#include<iostream>
using namespace std;
bool leap(int year){
    return year%400==0||(year%4==0&&year%100!=0);
}
void nextDay(int&day,int&month,int&year,int&weekday){
    const int lengths[12]={31,28,31,30,31,30,31,31,30,31,30,31};
    int limit=lengths[month-1]+(month==2&&leap(year));
    day++;
    if(day>limit){
        day=1;
        month++;
        if(month==13){
            month=1;
            year++;
        }
    }
    weekday=(weekday+1)%7;
}
int main(){
    int targetDay,targetMonth,targetYear,remaining;
    char separator;
    cin>>targetDay>>separator>>targetMonth>>separator>>targetYear>>remaining;
    int day=1;
    int month=1;
    int year=2019;
    int weekday=1;
    while(day!=targetDay||month!=targetMonth||year!=targetYear){
        nextDay(day,month,year,weekday);
    }
    while(remaining>0){
        if(weekday<5){
            remaining--;
        }
        nextDay(day,month,year,weekday);
    }
    while(weekday>=5){
        nextDay(day,month,year,weekday);
    }
    cout<<setfill('0')<<setw(2)<<day<<'.'<<setw(2)<<month<<'.'<<year<<'\n';
}

Source: Arena Olimpiici ↗

Intermediate.Put your skills to the test.

First School Day after a Holiday

Problem summary

Input

Output

Constraints

Worked example

Input

Output

Solution analysis

Why it works

Commented C++17 solution

Choose your next challenge.

Intermediate.
Put your skills to the test.