Hello Codeforces!

We're glad to invite you to the Eolymp Blitz Round #18 on 19th April 2026, at 11:00 UTC, a regular programming contest for beginners!

This is rated competition for members with rating $$$\le 1750$$$.

Format and Difficulty

The competition is meant help you get started with competitive programming and improve your problem solving skills. You will be given $$$ \color{red}{\textbf{1.5}}$$$ hours to solve 5 problems of easy difficulty.

The scoring for each task being block-based, meaning points are awarded for each block of tests separately, and only if the solution passes all tests in the block. If there is a tie between two participants, the one whose last productive submission (i.e., a submission that added at least one point) was made earlier will be ranked higher in the leaderboard.

Score distribution:

Prizes

The top-10 participants (with rating $$$\le 1750$$$) of the competition will receive 200 Eolymp Mints.

10 random participants among Top-100 (with rating $$$\le 1750$$$) who scored at least $$$51$$$ points will receive 100 Eolymp Mints each..

Call for Tasks

We are looking for problem setters to help us prepare for the upcoming rounds. Learn more about how to submit problem.

Credits

• MathModel for coordinating the round.
• MathModel , Davy_D._Kaosar , Mohammed_Nasserr , AzeTurk810 for authoring problems.
• FBI , Mohammed_Nasserr , JustFady and Titan493ASST for testing the contest.
• Sergey Kolodyazhnyy for creating Eolymp 😎.
• Connectus for Ukrainian Translations.

We're looking forward for your participation!

Well, In Case you've not already noticed , Now you can copy the test you're failing on some problem and run it locally and see what's going wrong.

Same goes for all tests.

Thanks for this cool addition :) !.

UPD: It kinda only works when you view from standings ig

Hello Codeforces!

We're excited to invite you to Weekend Practice round #22 , taking place on 12th April, at 10:00 UTC. This is a rated contest at Eolymp.

Format and Difficulty

Same as in previous rounds, the competition is primarily aimed at improving practical skills. There will be $$$\LARGE \color{red}{\textbf{2}}$$$ hours for $$$5$$$ tasks of varying difficulty, the easiest of which can even be solved by beginners.

The scoring for each task being block-based (meaning points are awarded for each block of tests separately, and only if the solution passes all tests in the block). If there is a tie between two participants, the one whose last productive submission (i.e., a submission that added at least one point) was made earlier will be ranked higher in the leaderboard.

The statements will be available in the following languages: English, Ukrainian, Azerbaijani.

Registration

You can join the competition on the competition page.

Prizes

The winners of the contest will receive Eolymp Mints.

Visit Frequently Asked Questions section to learn more.

Credits

• Sergey Kolodyazhnyy for creating Eolymp 😎.
• Denisov , Connectus For Coordinating The Round.
• Connectus , pcheloveks and mattgryts for authoring problems.

Hello Codeforces!

We're glad to invite you to the Eolymp Blitz Round #17 on 5th April 2026, at 11:00 UTC, a regular programming contest for beginners!

This is rated competition for members with rating $$$\le 1900$$$.

Format and Difficulty

The competition is meant help you get started with competitive programming and improve your problem solving skills. You will be given $$$ \color{red}{\textbf{1.5}}$$$ hours to solve 5 problems of easy difficulty.

The scoring for each task being block-based, meaning points are awarded for each block of tests separately, and only if the solution passes all tests in the block. If there is a tie between two participants, the one whose last productive submission (i.e., a submission that added at least one point) was made earlier will be ranked higher in the leaderboard.

Score distribution:

Prizes

The top-10 participants (with rating $$$\le 1900$$$) of the competition will receive 200 Eolymp Mints.

10 random participants among Top-100 (with rating $$$\le 1900$$$) who scored at least $$$51$$$ points will receive 100 Eolymp Mints each..

Call for Tasks

We are looking for problem setters to help us prepare for the upcoming rounds. Learn more about how to submit problem.

Credits

• MathModel for coordinating the round.
• De3b0o for authoring problems.
• Sergey Kolodyazhnyy for creating Eolymp 😎.
• Connectus for Ukrainian Translations. .

We're looking forward for your participation!

Congratulations to Winners :

1. Timosh
2. Rmelamud
3. Sacha
4. JustFady
5. hieptk
6. balakrishnan
7. Frus
8. NPsolved.cpp
9. Liudas
10. chyckchyryk

Hello Codeforces!

We're excited to invite you to Weekend Practice round #21 , taking place on 29th March, at 08:00 UTC. This is a rated contest at Eolymp.

Format and Difficulty

Same as in previous rounds, the competition is primarily aimed at improving practical skills. There will be $$$\LARGE \color{red}{\textbf{2.25}}$$$ hours for $$$5$$$ tasks of varying difficulty, the easiest of which can even be solved by beginners.

The scoring for each task being block-based (meaning points are awarded for each block of tests separately, and only if the solution passes all tests in the block). If there is a tie between two participants, the one whose last productive submission (i.e., a submission that added at least one point) was made earlier will be ranked higher in the leaderboard.

The statements will be available in the following languages: English, Ukrainian, Azerbaijani.

Registration

You can join the competition on the competition page.

Prizes

The winners of the contest will receive Eolymp Mints.

Visit Frequently Asked Questions section to learn more.

Credits

• MathModel For Coordinating The Round.
• Sergey Kolodyazhnyy for creating Eolymp 😎.
• turneja for authoring Problems.
• Connectus for Ukrainian Translations.
• Denisov , Triseedot , kimononawa , Mohammed_Nasserr for testing the contest.

Scoring

We Hope you enjoyed the round ! :

Congratulations to Winners $$$!!$$$ :

1. potato167 (Orz , AK at 01:23)

2. Egor (Orz , AK at 02:03)

3. Liudas

4. Noobish_Monk

5. pcheloveks

6. tolbi

Editorials to be published later today.

Hello Codeforces!

We're glad to invite you to the Eolymp Blitz Round #16 on 22nd March 2026, at 11:00 UTC, a regular programming contest for beginners!

This is rated competition for members with rating $$$\le 1750$$$.

Format and Difficulty

The competition is meant help you get started with competitive programming and improve your problem solving skills. You will be given $$$ \color{red}{\textbf{1.5}}$$$ hours to solve 5 problems of easy difficulty.

The scoring for each task being block-based, meaning points are awarded for each block of tests separately, and only if the solution passes all tests in the block. If there is a tie between two participants, the one whose last productive submission (i.e., a submission that added at least one point) was made earlier will be ranked higher in the leaderboard.

Score distribution:

Prizes

The top-10 participants (with rating $$$\le 1750$$$) of the competition will receive 200 Eolymp Mints.

10 random participants among Top-100 (with rating $$$\le 1750$$$) who scored at least $$$51$$$ points will receive 100 Eolymp Mints each..

Call for Tasks

We are looking for problem setters to help us prepare for the upcoming rounds. Learn more about how to submit problem.

Credits

• MathModel for coordinating the round.
• late_night_dreams and NPsolved.cpp for authoring problems.
• Sergey Kolodyazhnyy for creating Eolymp 😎.
• Connectus for Ukrainian Translations.
• Denisov , nyavim , Mousa_Aboubaker , Mohammed_Nasserr , chyckchyryk , Titan493ASST ,Davy_D._Kaosar , Ramen , Aritro_ for testing the contest.

We're looking forward for your participation!

Congratulations to Winners $$$!$$$ :

1. Egor
2. Liudas
3. balakrishnan
4. tohoshinki254
5. Lucifer_K
6. Nasa

Hello Codeforces!

We're excited to invite you to Weekend Practice round #20 , taking place on 15th March, at 15:00 UTC. This is a rated contest at Eolymp.

Format and Difficulty

Same as in previous rounds, the competition is primarily aimed at improving practical skills. There will be $$$\LARGE \color{red}{\textbf{2}}$$$ hours for $$$5$$$ tasks of varying difficulty, the easiest of which can even be solved by beginners.

The scoring for each task being block-based (meaning points are awarded for each block of tests separately, and only if the solution passes all tests in the block). If there is a tie between two participants, the one whose last productive submission (i.e., a submission that added at least one point) was made earlier will be ranked higher in the leaderboard.

The statements will be available in the following languages: English, Ukrainian, Azerbaijani.

Registration

You can join the competition on the competition page.

Prizes

The winners of the contest will receive Eolymp Mints.

Visit Frequently Asked Questions section to learn more.

Credits

• Sergey Kolodyazhnyy for creating Eolymp 😎.
• Connectus For Coordinating The Round and authoring problems.
• Denisov , Connectus , ginger__ , slave for testing the contest.

Scoring

Hello Codeforces!

We're glad to invite you to the Eolymp Blitz Round #15 on 8th March 2026, at 11:00 UTC, a regular programming contest for beginners!

This is rated competition for members with rating $$$\le 1750$$$.

Format and Difficulty

The competition is meant help you get started with competitive programming and improve your problem solving skills. You will be given $$$ \color{red}{\textbf{1.5}}$$$ hours to solve 5 problems of easy difficulty.

The scoring for each task being block-based, meaning points are awarded for each block of tests separately, and only if the solution passes all tests in the block. If there is a tie between two participants, the one whose last productive submission (i.e., a submission that added at least one point) was made earlier will be ranked higher in the leaderboard.

Score distribution:

Prizes

The top-10 participants (with rating $$$\le 1750$$$) of the competition will receive 200 Eolymp Mints.

10 random participants among Top-100 (with rating $$$\le 1750$$$) who scored at least $$$51$$$ points will receive 100 Eolymp Mints each..

Call for Tasks

We are looking for problem setters to help us prepare for the upcoming rounds. Learn more about how to submit problem.

Credits

• MathModel for coordinating the round.
• MathModel , frostcat , Davy_D._Kaosar , Ramen and Aritro_ for authoring problems.
• Sergey Kolodyazhnyy for creating Eolymp 😎.
• Connectus for Ukrainian Translations.
• Denisov , nyavim , Ajay_2705 , Mohammed_Nasserr , chyckchyryk , Titan493ASST ,calm_pizza for testing the contest.

We're looking forward for your participation!

Congratulations to Winners:

1. FFTotoro
2. Sul_A.
3. Mousa_Aboubaker
4. chinesedfan

Hello Codeforces!

We're glad to invite you to the Eolymp Blitz Round #14 on 1st March 2026, at 13:00 UTC, a regular programming contest for beginners!

This is rated competition for members with rating $$$\le 1750$$$.

Format and Difficulty

The competition is meant help you get started with competitive programming and improve your problem solving skills. You will be given $$$ \color{red}{\textbf{1}}$$$ hours to solve 5 problems of easy difficulty.

The scoring for each task being block-based, meaning points are awarded for each block of tests separately, and only if the solution passes all tests in the block. If there is a tie between two participants, the one whose last productive submission (i.e., a submission that added at least one point) was made earlier will be ranked higher in the leaderboard.

Score distribution:

Prizes

The top-10 participants (with rating $$$\le 1750$$$) of the competition will receive 200 Eolymp Mints.

10 random participants among Top-100 (with rating $$$\le 1750$$$) who scored at least $$$51$$$ points will receive 100 Eolymp Mints each..

Call for Tasks

We are looking for problem setters to help us prepare for the upcoming rounds. Learn more about how to submit problem.

Credits

• MathModel for coordinating the round.
• Younis_DY , Mohammed_Nasserr and MathModel for authoring problems.
• Sergey Kolodyazhnyy for creating Eolymp 😎.
• Connectus for Ukrainian Translations.
• Mousa_Aboubaker , Mohammed_Nasserr , nyavim , Ajay_2705 , Ramen , chyckchyryk , Davy_D._Kaosar for testing the contest.

We're looking forward for your participation!

Congratulations to Winners !

Official :

1. yanb0

2. Frus

3. Pie_TealCompressorDragon

4. gultai4ukr

Unofficial

1. ococonomy1

2. Egor

3. ajinkya1p3

4. late_night_dreams

5. hieptk

Hello Codeforces!

We're glad to invite you to the Eolymp Blitz Round #13 on 22nd February 2026, at 11:30 UTC, a regular programming contest for beginners!

This is rated competition for members with rating $$$\le 1750$$$.

Format and Difficulty

The competition is meant help you get started with competitive programming and improve your problem solving skills. You will be given 1.5 hours to solve 5 problems of easy difficulty.

The scoring for each task being block-based, meaning points are awarded for each block of tests separately, and only if the solution passes all tests in the block. If there is a tie between two participants, the one whose last productive submission (i.e., a submission that added at least one point) was made earlier will be ranked higher in the leaderboard.

Score distribution:

Prizes

The top-10 participants (with rating $$$\le 1750$$$) of the competition will receive 200 Eolymp Mints.

10 random participants among Top-100 (with rating $$$\le 1750$$$) who scored at least $$$51$$$ points will receive 100 Eolymp Mints each..

Call for Tasks

We are looking for problem setters to help us prepare for the upcoming rounds. Learn more about how to submit problem.

Credits

• MathModel for coordinating the round.
• Mohammed_Nasserr and MathModel for authoring problems.
• Sergey Kolodyazhnyy for creating Eolymp 😎.
• Connectus for Ukrainian Translations.
• Mousa_Aboubaker , Mohammed_Nasserr , nyavim , Ajay_2705 ,arpit_kr , Ramen , Davy_D._Kaosar for testing the contest.

We're looking forward for your participation!

The legends say that participating Blitz Rounds , Increases your choice of getting a higher rank on competitions in general.

In the honor of kimononawa , the writer of Eolymp Blitz 12 , and the main lore goes to D. Permutation Minimize Product where it used the same idea and framework of Today's 2D/1B .

Editorial of The origin problem : Editorial

So , Indeed If you've seen the task (the technique in general tbf) , then it's very doable in this case.

The problems are similar because they both are using the fact that if $$$a \times b \lt n$$$ then one of $$$a$$$ and $$$b$$$ should be less than $$$\sqrt{n}$$$, hence in each pair $$$(i,j)$$$ one of $$$a_i$$$ or $$$a_j$$$ is less than $$$\sqrt{n}$$$

Hello Codeforces!

We're glad to invite you to the Eolymp Blitz Round #12 on 8th February 2026, at 11:30 UTC, a regular programming contest for beginners!

This is rated competition for members with rating $$$\le 1750$$$.

Format and Difficulty

The competition is meant help you get started with competitive programming and improve your problem solving skills. You will be given 1.5 hours to solve 5 problems of easy difficulty.

The scoring for each task being block-based, meaning points are awarded for each block of tests separately, and only if the solution passes all tests in the block. If there is a tie between two participants, the one whose last productive submission (i.e., a submission that added at least one point) was made earlier will be ranked higher in the leaderboard.

Score distribution:

Prizes

The top-10 participants (with rating $$$\le 1750$$$) of the competition will receive 200 Eolymp Mints.

10 random participants among Top-100 (with rating $$$\le 1750$$$) who scored at least $$$51$$$ points will receive 100 Eolymp Mints each..

Call for Tasks

We are looking for problem setters to help us prepare for the upcoming rounds. Learn more about how to submit problem.

Credits

• MathModel for coordinating the round.
• kimononawa for authoring problems.
• Sergey Kolodyazhnyy for creating Eolymp 😎.
• Connectus for Ukrainian Translations.
• Mousa_Aboubaker , Mohammed_Nasserr , al95ireyiz , Titan493ASST , HickWhither , MathModel ,arpit_kr for testing the contest.

We're looking forward for your participation!

Congrats to Winners :

1. Egor (Congrats ! , AK after $$$30$$$ minutes !)

2. nyavim (Congrats ! , AK after $$$1$$$ Hour and $$$20$$$ minutes)

3. NPsolved.cpp (Congrats ! , AK after $$$1$$$ Hour and $$$35$$$ minutes)

4. balakrishnan (Congrats ! , AK after $$$1$$$ Hour and $$$37$$$ minutes)

5. AbdullahIshfaq

6. Nasa

7. late_night_dreams

Congrats to First Solvers :

A : NPsolved.cpp

B : late_night_dreams

C : Egor

D : Egor

E : Egor

Hello Codeforces!

I'm excited to invite you to Weekend Practice round #18 , taking place on 1st February, at 15:00 UTC. This is a rated contest at Eolymp.

Format and Difficulty

Same as in previous rounds, the competition is primarily aimed at improving practical skills. There will be $$$\LARGE \color{red}{\textbf{2}}$$$ hours for $$$5$$$ tasks of varying difficulty, the easiest of which can even be solved by beginners.

The scoring for each task being block-based (meaning points are awarded for each block of tests separately, and only if the solution passes all tests in the block). If there is a tie between two participants, the one whose last productive submission (i.e., a submission that added at least one point) was made earlier will be ranked higher in the leaderboard.

The statements will be available in the following languages: English, Ukrainian, Azerbaijani.

Registration

You can join the competition on the competition page.

Prizes

The winners of the contest will receive Eolymp Mints.

Visit Frequently Asked Questions section to learn more.

Credits

• MathModel For Coordinating The Round.
• Sergey Kolodyazhnyy for creating Eolymp 😎.
• Davy_D._Kaosar , De3b0o , TaklaOI for authoring Problems.
• Connectus for Ukrainian Translations.
• Davy_D._Kaosar, kimononawa , arpit_kr , Mohammed_Nasserr and chyckchyryk , Aritro_ , Ramen for testing the contest.

Scoring

Congrats to Winners

1. potato167

2. Andres_Alumets

3. MAKMED1337

4. physics0523

5. pkhaustov

6. vid

7. JustFady

8. Kerw1l

9. Liudas

10. AkbarKING

Congrats to First Solvers

A : TheFuturoma

B : physics0523

C : Horka

D : potato167

E : potato167

Editorials

Problem A

Problem B

Problem C

Problem D

Problem E

Hello Codeforces!

We're glad to invite you to the Eolymp Blitz Round #11 on 25th January 2026, at 13:00 UTC, a regular programming contest for beginners!

PLEASE NOTE THE CHANGED START TIMING OF THE ROUND !!

This is rated competition for members with rating $$$\le 1750$$$.

Format and Difficulty

The competition is meant help you get started with competitive programming and improve your problem solving skills. You will be given 1.5 hours to solve 5 problems of easy difficulty.

The scoring for each task being block-based, meaning points are awarded for each block of tests separately, and only if the solution passes all tests in the block. If there is a tie between two participants, the one whose last productive submission (i.e., a submission that added at least one point) was made earlier will be ranked higher in the leaderboard.

Score distribution:

Prizes

The top-10 participants (with rating $$$\le 1750$$$) of the competition will receive 200 Eolymp Mints.

10 random participants among Top-100 (with rating $$$\le 1750$$$) who scored at least $$$51$$$ points will receive 100 Eolymp Mints each..

Call for Tasks

We are looking for problem setters to help us prepare for the upcoming rounds. Learn more about how to submit problem.

Credits

• MathModel for coordinating the round.
• MathModel and Davy_D._Kaosar for authoring problems.
• Sergey Kolodyazhnyy for creating Eolymp 😎.
• Connectus for Ukrainian Translations.
• kimononawa, Aritro_, arpit_kr,Mohammed_Nasserr and Ramen for testing the contest.

We're looking forward for your participation!

Congratulations to Winners :

1. Dec0Dedd

2. late_night_dreams

3. balakrishnan

4. NPsolved.cpp

5. buko

6. pkhaustov

7. Nasa

8. gultai4ukr

9. Maryan_Shyika

10. nyavim

Hello Codeforces!

We're glad to invite you to the Eolymp Blitz Round #10 on 11th January, at 11:00 UTC, a regular programming contest for beginners!

This is rated competition for members with rating $$$\le 1750$$$.

Format and Difficulty

The competition is meant help you get started with competitive programming and improve your problem solving skills. You will be given 1.5 hours to solve 5 problems of easy difficulty.

The scoring for each task being block-based, meaning points are awarded for each block of tests separately, and only if the solution passes all tests in the block. If there is a tie between two participants, the one whose last productive submission (i.e., a submission that added at least one point) was made earlier will be ranked higher in the leaderboard.

Score distribution:

Prizes

The top-10 participants (with rating $$$\le 1750$$$) of the competition will receive 200 Eolymp Mints.

10 random participants among Top-100 (with rating $$$\le 1750$$$) who scored at least $$$51$$$ points will receive 100 Eolymp Mints each..

Call for Tasks

We are looking for problem setters to help us prepare for the upcoming rounds. Learn more about how to submit problem.

Credits

• MathModel for coordinating the round and authoring the problems.
• Sergey Kolodyazhnyy for creating Eolymp 😎.
• Connectus for Ukrainian Translations.
• kimononawa, arpit_kr, Davy_D._Kaosar, Mohammed_Nasserr for testing the contest.

We're looking forward for your participation!

Congratulations to Our First Solvers

Problem A : Nasa

Problem B : Nasa

Problem C : Nasa

Problem D : maomao90

Problem E : NPsolved.cpp

Congratulations to Our Winners !

1. maomao90

2. Yixiong

3. NPsolved.cpp

4. late_night_dreams

Hello Codeforces!

I'm excited to invite you to Weekend Practice round #16 , taking place on 4th January, at 15:00 UTC. This is a rated contest at Eolymp.

Format and Difficulty

Same as in previous rounds, the competition is primarily aimed at improving practical skills. There will be $$$2$$$ hours for $$$5$$$ tasks of varying difficulty, the easiest of which can even be solved by beginners.

The scoring for each task being block-based (meaning points are awarded for each block of tests separately, and only if the solution passes all tests in the block). If there is a tie between two participants, the one whose last productive submission (i.e., a submission that added at least one point) was made earlier will be ranked higher in the leaderboard.

The statements will be available in the following languages: English, Ukrainian, Azerbaijani.

Registration

You can join the competition on the competition page.

Prizes

The winners of the contest will receive Eolymp Mints.

Visit Frequently Asked Questions section to learn more.

Credits

• MathModel For Coordinating The Round and Authoring the Problems 😎.
• Sergey Kolodyazhnyy for creating Eolymp 😎.
• Connectus for Ukrainian Translations.
• Denisov , cadmiumky , tibinyte2006 , kimononawa , turneja , De3b0o , arpit_kr , Haidora , cowthecow , Mohammed_Nasserr , 0pt1mus23 for testing the contest.

Scoring

Congratulations to our First Solvers :

A : Away_in_the_heavens

B : _Robi

C : potato167

D : potato167

E : potato167

Congratulations to our Winners ! :

1. potato167

2. ococonomy1

3. Aokana

4. Liudas

5. late_night_dreams

6. Away_in_the_heavens

7. pcheloveks

8. VladProg

9. physics0523

10. 36champ

Hello Codeforces!

We're glad to invite you to the Eolymp Blitz Round #9 on 28th December, at 11:00 UTC, a regular programming contest for beginners!

This is rated competition for members with rating $$$\le 1750$$$.

Format and Difficulty

The competition is meant help you get started with competitive programming and improve your problem solving skills. You will be given 1.5 hours to solve 5 problems of easy difficulty.

The scoring for each task being block-based, meaning points are awarded for each block of tests separately, and only if the solution passes all tests in the block. If there is a tie between two participants, the one whose last productive submission (i.e., a submission that added at least one point) was made earlier will be ranked higher in the leaderboard.

Score distribution:

Prizes

The top-10 participants (with rating $$$\le 1750$$$) of the competition will receive 200 Eolymp Mints.

10 random participants among Top-100 (with rating $$$\le 1750$$$) who scored at least $$$51$$$ points will receive 100 Eolymp Mints each..

Call for Tasks

We are looking for problem setters to help us prepare for the upcoming rounds. Learn more about how to submit problem.

Credits

• MathModel for coordinating the round.
• MathModel, omaralimm, Ekber_Ekber, AzeTurk810, Osman_112, tuncypasha for authoring problems.
• Sergey Kolodyazhnyy for creating Eolymp 😎.
• Denisov for Ukrainian Translations.
• kimononawa, omaralimm, Ekber_Ekber, AzeTurk810, Osman_112, tuncypasha, al95ireyiz, arpit_kr, Davy_D._Kaosar, Mohammed_Nasserr , chyckchyryk for testing the contest.

We're looking forward for your participation!

Congrats to Winners ! :

• _Masum_Billah

• balakrishnan

• Timosh

• Sofapuden

• Nika533

Hello Codeforces!

I'm excited to invite you to Weekend Practice round #15 , taking place on 21st December , at 15:00 UTC. This is a rated contest at Eolymp.

Format and Difficulty

Same as in previous rounds, the competition is primarily aimed at improving practical skills. There will be $$$2$$$ hours for $$$5$$$ tasks of varying difficulty, the easiest of which can even be solved by beginners.

The scoring for each task being block-based (meaning points are awarded for each block of tests separately, and only if the solution passes all tests in the block). If there is a tie between two participants, the one whose last productive submission (i.e., a submission that added at least one point) was made earlier will be ranked higher in the leaderboard.

The statements will be available in the following languages: English, Ukrainian, Azerbaijani.

Registration

You can join the competition on the competition page.

Prizes

The winners of the contest will receive Eolymp Mints.

Visit Frequently Asked Questions section to learn more.

Credits

• MathModel For Coordinating The Round 😎.
• De3b0o for authoring problems 🔥 .
• Sergey Kolodyazhnyy for creating Eolymp 😎.
• Connectus for Ukrainian Translations.
• Triseedot , VladProg , Timosh , Haidora , harmito , TaklaOI , arpit_kr , Mohammed_Nasserr for testing the contest.

Scoring

Winners

Congratulations to Winners ! :

1. kimononawa

2. liympanda

3. mwen

4. ErikJ

5. Fdg

Editorials :

Problem A

Problem B

Problem C

Problem D

Problem E

Hello Codeforces !

I'm glad to invite you to the Eolymp Blitz Round #8 on 14th December, at 11:00 UTC , a regular programming contest for beginners!

This is rated competition for members with rating $$$\le 1750$$$.

Format and Difficulty

The competition is meant help you get started with competitive programming and improve your problem solving skills. You will be given 1.5 hours to solve 5 problems of easy difficulty.

The scoring for each task being block-based, meaning points are awarded for each block of tests separately, and only if the solution passes all tests in the block. If there is a tie between two participants, the one whose last productive submission (i.e., a submission that added at least one point) was made earlier will be ranked higher in the leaderboard.

Score distribution :

Prizes

The top-10 participants (with rating $$$\le 1750$$$) of the competition will receive 200 Eolymp Mints.

10 random participants among Top-100 (with rating $$$\le 1750$$$) who scored at least $$$51$$$ points will receive 100 Eolymp Mints each..

Call for Tasks

We are looking for problem setters to help us prepare for the upcoming rounds. Learn more about how to submit problem.

Credits

• MathModel for coordinating the round.
• Haidora for authoring problems.
• Sergey Kolodyazhnyy for creating Eolymp 😎.
• Denisov for Ukrainian and Russian Translations.
• Denisov , Timosh , cowthecow , Mohammed_Nasserr , Titan493ASST , De3b0o , wuwang2002xyaptrickstar , frostcat for testing the contest.

We're looking forward for your participation !

Congrats to Winners :

1. paulo.pr

2. Pie_TealCompressorDragon

3. balakrishnan

4. YaLong

5. ococonomy1

6. Horka

7. NPsolved.cpp

Today, after a great performance in the Div. 1 round and after 125 rated contests, alexwice finally pulled off the Grandmaster title , and absolutely nailed it.

As an author who has set multiple contests on KEP, CodeChef, and Eolymp, where alexwice regularly participated and dominated the standings, I feel it’s my duty to congratulate him.

Congratulations ! and Hope you'll reach better scores in the near future !.

Hello Codeforces !

I'm glad to invite you to the Seventh Eolymp Blitz Round #7 on 30th November, at 11:00 UTC , a regular programming contest for beginners!

This is rated competition for members with rating $$$\le \color{red}{\bf{1750}}$$$.

Format and Difficulty

The competition is meant help you get started with competitive programming and improve your problem solving skills. You will be given 1.5 hours to solve 5 problems of easy difficulty.

The scoring for each task being block-based, meaning points are awarded for each block of tests separately, and only if the solution passes all tests in the block. If there is a tie between two participants, the one whose last productive submission (i.e., a submission that added at least one point) was made earlier will be ranked higher in the leaderboard.

Prizes

The top-10 participants (with rating $$$\le \color{red}{\bf{1750}}$$$) of the competition will receive 200 Eolymp Mints.

10 random participants among Top-100 (with rating $$$\le \color{red}{\bf{1750}}$$$) who scored at least $$$51$$$ points will receive 100 Eolymp Mints each..

Call for Tasks

We are looking for problem setters to help us prepare for the upcoming rounds. Learn more about how to submit problem.

Credits

• MathModel for coordinating the round.
• MathModel , Mohammed_Nasserr , Haidora and Titan493ASST for authoring problems.
• Sergey Kolodyazhnyy for creating Eolymp 😎.
• Denisov for Ukrainian and Russian Translations.
• Denisov , Mohammed_Nasserr , Haidora ,Titan493ASST , Connectus , al95ireyiz for testing the contest.

We're looking forward for your participation !

Congratulations to Winners ! :

1. Timosh

2. balakrishnan

3. Kerw1l

4. nyavim

5. NPsolved.cpp

6. YaLong

Editorials

Problem A

Problem B

Problem C

Problem D

Problem E

Hello Codeforces !

I'm glad to invite you to the Sixth Eolymp Blitz Round #6 on 16th November, at 10:00 UTC , a regular programming contest for beginners!

This is rated competition for members with rating $$$\le \color{red}{\bf{1750}}$$$.

Format and Difficulty

The competition is meant help you get started with competitive programming and improve your problem solving skills. You will be given 1.5 hours to solve 5 problems of easy difficulty.

The scoring for each task being block-based, meaning points are awarded for each block of tests separately, and only if the solution passes all tests in the block. If there is a tie between two participants, the one whose last productive submission (i.e., a submission that added at least one point) was made earlier will be ranked higher in the leaderboard.

Prizes

The top-10 participants (with rating $$$\le \color{red}{\bf{1750}}$$$) of the competition will receive 200 Eolymp Mints.

10 random participants among Top-100 (with rating $$$\le \color{red}{\bf{1750}}$$$) who scored at least $$$51$$$ points will receive 100 Eolymp Mints each.

Call for Tasks

We are looking for problem setters to help us prepare for the upcoming rounds. Learn more about how to submit problem.

Credits

• MathModel for coordinating the round.
• MathModel and Davy_D._Kaosar for authoring problems.
• Sergey Kolodyazhnyy for creating Eolymp 😎.
• Denisov for Ukrainian and Russian Translations.
• Denisov , kimononawa , turneja ,al95ireyiz , Titan493ASST for testing the contest.

We're looking forward for your participation !

Editorials

Problem A

Problem B

Problem C

Problem D

Problem E

Hello Codeforces!

I'm excited to invite you to Weekend Practice round #13 , taking place on 9th November, at 14:00 UTC. This is a rated contest at Eolymp.

Format and Difficulty

Same as in previous rounds, the competition is primarily aimed at improving practical skills. There will be $$$2$$$ hours for $$$5$$$ tasks of varying difficulty, the easiest of which can even be solved by beginners.

The scoring for each task being block-based (meaning points are awarded for each block of tests separately, and only if the solution passes all tests in the block). If there is a tie between two participants, the one whose last productive submission (i.e., a submission that added at least one point) was made earlier will be ranked higher in the leaderboard.

The statements will be available in the following languages: English, Ukrainian, Azerbaijani, Russian.

One of the problems will be interactive so please make sure to be familiar with them.

Registration

You can join the competition on the competition page.

Prizes

The top-10 participants of the competition, as well as 10 random participants from those who rank from 11th to 100th place, will receive prizes in the form of t-shirts. Please, note, that we have changed how prizes are awarded,

Visit Frequently Asked Questions section to learn more.

Credits

• MathModel For Coordinating The Round 😎.
• De3b0o for authoring problems 🔥 .
• Sergey Kolodyazhnyy for creating Eolymp 😎.
• Denisov for Ukrainian and Russian Translations.
• Denisov , kimononawa , JuicyGrape , edogawa_something , Pa_sha , Haidora , 0pt1mus23 for testing the contest.

Scoring

Congratulations to Winners $$$!$$$ :

1. physics0523

2. liympanda

3. wery0

4. pcheloveks

5. hieptk

Congratulations to First Solvers $$$!$$$ :

A : hieptk

B : physics0523

C : physics0523

D : liympanda

E : NA

Editorial

Problem A

Problem B

Problem C

Problem D

Problem E

Hello Codeforces !

I'm glad to invite you to the Fifth Eolymp Blitz Round #5 on 2nd November, at 10:00 UTC , a regular programming contest for beginners!

This is rated competition for members with rating $$$\le \color{red}{\bf{1750}}$$$.

Format and Difficulty

The competition is meant help you get started with competitive programming and improve your problem solving skills. You will be given 1.5 hours to solve 5 problems of easy difficulty.

The scoring for each task being block-based, meaning points are awarded for each block of tests separately, and only if the solution passes all tests in the block. If there is a tie between two participants, the one whose last productive submission (i.e., a submission that added at least one point) was made earlier will be ranked higher in the leaderboard.

Prizes

The top-10 participants (with rating $$$\le \color{red}{\bf{1750}}$$$) of the competition will receive 200 Eolymp Mints.

10 random participants among Top-100 (with rating $$$\le \color{red}{\bf{1750}}$$$) who scored at least $$$51$$$ points will receive 100 Eolymp Mints each.

Call for Tasks

We are looking for problem setters to help us prepare for the upcoming rounds. Learn more about how to submit problem.

Credits

• MathModel for coordinating the round.
• MathModel and Davy_D._Kaosar for authoring problems.
• Sergey Kolodyazhnyy for creating Eolymp 😎.
• Denisov for Ukrainian and Russian Translations.
• Denisov , kimononawa , turneja , Too_Weak_To_Anything , JuicyGrape , al95ireyiz for testing the contest.

We're looking forward for your participation !

Editorials

Problem A

Problem B

Problem C

Problem D

Problem E

First Solvers

A: detective...dots

B : kx04

C : hieptk

D: Mendeke

E : Tomas Rimkus

Will be announced shortly after removing cheaters.

Thank you for participating !

Special Thanks to hxu10 for giving me the chance to write the editorial and for maomao90 for enhancing the editorial !.

Editorial of Problems E and F are written by hxu10, and the rest are written by me. I hope they're insightful and concise, please let me hear your opinion about it or any feedback in general 💙.

2156A - Pizza Time

from math import *

def solve():
    n=int(input())
    print((n-1)//2)

for _ in range(int(input())):
    solve()

from math import *

def solve():
    n=int(input())
    a,b,c=n//3,n//3,n//3+(n%3)
    ans=0
    while(n>2):
        ans+=n//3
        n=n//3+(n%3)
    print(ans)

for _ in range(int(input())):
    solve()

2156B - Strange Machine

def solve():
    n,q=map(int,input().split())
    s=input().strip()
    a=list(map(int,input().split()))
    A,B=s.count('A'),s.count('B')
    for i in range(q):
        if(B==0):
            print(a[i])
        else:
            ans=0
            while(a[i]):
                for j in s:
                    if(a[i]==0):break
                    ans+=1
                    if(j=='A'):a[i]-=1
                    else: a[i]//=2
            print(ans)

for _ in range(int(input())):
    solve()

def solve():
    n,q=map(int,input().split())
    s=input()
    a=list(map(int,input().split()))
    A=s.count('A')
    B=s.count('B')
    last=s[0]
    seq=[] 
    cur=1
    for i in range(1,n):
        if(s[i]==last): cur+=1
        else:
            seq.append([last,cur])
            cur=1
            last=s[i]
    if(cur!=0): seq.append([last,cur])
    if(B==0):
        for i in a: print(i)
    else:
        for i in range(q):
            ans=0
            while(a[i]>0):
                for j in seq:
                    if(a[i]==0): break
                    if(j[0]=='A'):
                        mn=min(j[1],a[i])
                        ans+=mn
                        a[i]-=mn
                    else:
                        if a[i]==0: break
                        x=a[i]
                        p=0
                        while(x):
                            x//=2
                            p+=1
                        mn=min(p,j[1])
                        ans+=mn
                        a[i]//=(2**mn)
            print(ans)

for _ in range(int(input())):
    solve()

2156C - Maximum GCD on Whiteboard

#include <bits/stdc++.h>
using namespace std;
#define int long long

void solve(){
  int n,k;cin>>n>>k;
  vector<int>a(n),mp(n+1),p(n+1);
  for(auto &i:a){
     cin>>i;
     mp[i]++;
  }
  for(int i=1;i<=n;i++){
      p[i]=p[i-1]+mp[i];
  }
  int ans=1;
  for(int g=1;g<=n;g++){
    int t=min(n,4*g-1);
    int good=n-p[t];
    if(g<=n)good+=mp[g];
    if(2*g<=n)good+=mp[2*g];
    if(3*g<=n)good+=mp[3*g];
    if(good>=n-k)ans=g;
  }
  cout<<ans<<"\n";
}

signed main(){
  ios::sync_with_stdio(0);
  cin.tie(0);
  int t;cin>>t;
  while(t--)solve();
}

2156D - Find the Last Number

def query(index,num):
    print("?",index,num)
    return int(input())

def main():
    n = int(input())
    rest = set()
    likely = set()
    for i in range(1,n):
        rest.add(i)
    for i in range(1,n+1):
        likely.add(i)
    D = len(bin(n)[2:])
    ans = 0
    for d in range(D):
        index_0 = set()
        index_1 = set() 
        likely_0 = set()
        likely_1 = set()
        for index in rest:
            res = query(index, 1<<d)   
            if res == 0:
                index_0.add(index)
            else:
                index_1.add(index)  
        zeros = 0
        ones = 0  
        for num in likely:
            if num & (1<<d):
                ones += 1
                likely_1.add(num)
            else:
                zeros += 1
                likely_0.add(num)
        if zeros == len(index_0):
            ans += 1 << d
            rest = index_1
            likely = likely_1
        elif ones == len(index_1):
            rest = index_0
            likely = likely_0
        else:
            print("Error")
            return 
    print("!",ans)

T = int(input())
t = 1
while t <= T:
    main()
    t += 1

2156E - Best Time to Buy and Sell Stock

def main():
    n = int(input())
    arr = list(map(int,input().split()))

    # calculate the number of j for each i that satisfy arr[max(i,j)] - arr[min(i,j)] >= target
    def measurecount(arr,target):
        m = len(arr)
        count = [0]*m
        minimum = []
        for i in range(m):
            for j in range(len(minimum)):
                if minimum[j] + target <= arr[i]:
                    count[i] += 1
            minimum.append(arr[i])
            minimum.sort()
            if len(minimum) > 3:
                minimum.pop()
        maximum = []
        for i in range(m-1,-1,-1):
            for j in range(len(maximum)):
                if maximum[j] - target >= arr[i]:
                    count[i] += 1
            maximum.append(arr[i])
            maximum.sort(reverse=True)
            if len(maximum) > 3:
                maximum.pop()
        return count

    # binary search to judge if we can find such pair
    def judge(target):
        count = measurecount(arr,target)
        if max(count) <= 1:
            return False
        pick = []
        if max(count) > 2:
            for i in range(n):
                if count[i] > 2:
                    pick = [i]
                    break
        else:
            for i in range(n):
                if count[i] != 2: 
                    continue 
                for j in range(n):
                    if j==i: 
                        pick.append(j)
                    elif j < i and arr[j] + target <= arr[i]: 
                        pick.append(j)
                    elif j > i and arr[i] + target <= arr[j]:
                        pick.append(j)
                break

        for p in pick:
            count2 = measurecount(arr[:p]+arr[p+1:], target)
            if max(count2) <= 1:
                return False
        return True       

    front = -10**9 - 10
    rear = 10**9 + 10
    while front < rear:
        mid = front + (rear-front)//2
        res = judge(mid)
        if res:
            front = mid + 1
        else:
            rear = mid 
    ans = front - 1
    print(ans)
                       
T = int(input())
t = 1
while t <= T:
    main()
    t += 1
    

#include "bits/stdc++.h"
using namespace std;
 
const int MAXN = 200005;
const int INF = 1000000005;
 
inline int fdiv(int num, int denom) {
  return num / denom - ((num ^ denom) < 0 && num % denom);
}
inline int cdiv(int num, int denom) { return fdiv(num + denom - 1, denom); }
 
int t;
int n;
int a[MAXN];
 
vector<int> adj[MAXN];
void add_edge(int u, int v) {
  adj[u].push_back(v);
  adj[v].push_back(u);
}
bool check(int x) {
  for (int i = 1; i <= n; i++) {
    adj[i].clear();
  }
  set<pair<int, int>> st;
  for (int i = 1; i <= n; i++) {
    int cnt = 0;
    for (auto [prv, prv_id] : st) {
      if (a[i] - prv >= x) {
        add_edge(prv_id, i);
      }
    }
    st.insert({a[i], i});
    if ((int) st.size() > 3) {
        st.erase(prev(st.end()));
    }
  }
 
  int bad_cnt = 0;
  for (int i = 1; i <= n; i++) {
    if ((int)adj[i].size() >= 2) {
      bad_cnt++;
    }
  }
  for (int i = 1; i <= n; i++) {
    int delta = (int)adj[i].size() >= 2;
    for (int v : adj[i]) {
      if (adj[v].size() == 2) {
        delta++;
      }
    }
    if (delta == bad_cnt) {
      return false;
    }
  }
  return true;
}
 
int main() {
  cin >> t;
  while (t--) {
    cin >> n;
    for (int i = 1; i <= n; i++) {
      cin >> a[i];
    }
    int lo = -INF, hi = INF;
    while (lo < hi) {
      int mid = cdiv(lo + hi, 2);
      if (check(mid)) {
        lo = mid;
      } else {
        hi = mid - 1;
      }
    }
    cout << lo << '\n';
  }
  return 0;
}

2156F1 - Strange Operation (Easy Version)

def main():
    n = int(input())
    p = list(map(int,input().split()))
    for i in range(n):
        p[i] -= 1
    seq = []
    indexes = [i for i in range(n)]
    def update(indexes):
        count = 0
        for i in range(n):
            if indexes[i] < 0:  continue
            indexes[i] = count
            count += 1
    curr = 1
    ans = [-1]*n
    for i in range(n):
        if ans[i] > 0:  
            continue
        if indexes[p[i]] % 2 == 0:
            ans[i] = curr
            curr += 1
            indexes[p[i]] = -1
            update(indexes)
            continue 
        prefix = p[i]
        pick = -1
        for j in range(i+1,n):
            if ans[j] > 0:
                continue 
            if p[j] > prefix or indexes[p[j]] % 2 > 0:
                prefix = min(prefix,p[j])
                continue
            pick = j 
            break
        ans[j] = curr 
        curr += 1
        ans[i] = curr
        curr += 1
        indexes[p[j]] = -1
        indexes[p[i]] = -1
        update(indexes)
    print(*ans)      
T = int(input())
for _ in range(T):
    main() 

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <tuple>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <functional>
#include <cassert>
#include <immintrin.h>

using namespace std;

#define int long long

int p[100005];
int pos[100005];

signed main()
{
#if _LOCAL_
    freopen("case.txt", "r", stdin);
#endif

    int t;
    cin >> t;

    while(t--) {
        int n;
        cin >> n;
        for(int i = 0; i < n; ++i) {
            cin >> p[i];
        }
        for(int i = 0; i < n; ++i) {
            pos[p[i]] = i;
        }
        for(int cnt = 1; cnt <= n; ++cnt) {
            int cur = n;
            for(int i = cnt, mn = n; i <= n; ++i) {
                if(pos[i] < mn) {
                    mn = pos[i];
                    if((i & 1) == (cnt & 1)) {
                        cur = pos[i];
                    }
                }
            }
            int val = p[cur];
            p[cur] = cnt;
            for(int i = cnt; i < val; ++i) {
                p[pos[i]]++;
            }
            for(int i = val; i > cnt; --i) {
                pos[i] = pos[i-1];
            }
            pos[cnt] = cur;
        }
        for(int i = 0; i < n; ++i) {
            cout << p[i] << ' ';
        }
        cout << endl;
    }

    return 0;
}

for _ in range(int(input())):
    n=int(input())
    p=list(map(int,input().split()))
    pos=[0]*n
    for i in range(n):
        pos[p[i]-1]=i
    ch=1
    while ch:
        ch=0
        for m in range(n-2):
            a,b,c=pos[m],pos[m+1],pos[m+2]
            if(c<min(a,b)):
                i=c
                if(a<b):
                    j,k=a,b
                    p[i],p[j],p[k]=m+1,m+2,m+3
                    pos[m],pos[m+1],pos[m+2]=i,j,k
                else:
                    j,k=b,a
                    p[i],p[j],p[k]=m+1,m+3,m+2
                    pos[m],pos[m+2],pos[m+1]=i,j,k
                ch=1
    print(*p)

2156F2 - Strange Operation (Hard Version)

inf = 10**9

class fenwick(object):
    def __init__(self, n):
        self.n = n
        self.cul = [0]*n
        self.maxd = len(bin(n))-3
    def update(self,index,diff):
        i = index
        while i<self.n:
            self.cul[i] += diff
            i += (i+1)&(-i-1)
    def getaccu(self,index):
        output = 0
        i = index
        while i>=0:
            output += self.cul[i]
            i -= (i+1)&(-i-1)
        return output

class segment_tree(object):
    def merge(self,num,accu):
        return min(accu,num)
    def __init__(self,n,initial):
        self.n = n
        self.inf = inf
        self.arr = [self.inf]*(2*n)
        for i in range(2*n-1,0,-1):
            if i>=n:  self.arr[i] = initial[i-n]
            else:     self.arr[i] = self.merge(self.arr[2*i],self.arr[2*i+1])

    def update(self,index,target):
        index += self.n
        self.arr[index] = target
        while index > 0:
            if index & 1:
                nexttarget = self.merge( self.arr[index], self.arr[index-1])
            else:
                nexttarget = self.merge( self.arr[index], self.arr[index+1])
            self.arr[index>>1] = nexttarget
            index = index >> 1

    def addnum(self,index,diff):
        self.update(index, self.arr[index+self.n] + diff)

    def query(self,left,right):
        i,j = self.n+left,  self.n+right+1
        output = self.inf  # initial output should be changed if you want to change the merge function
        while i<j:
            if i&1:
                output = self.merge(self.arr[i],output)
                i += 1
            if j&1:
                j -= 1
                output = self.merge(self.arr[j],output)
            i = i >> 1
            j = j >> 1
        return output

def main(t):
    n = int(input())
    p = list(map(int,input().split()))
    location = [0]*n
    for i in range(n):
        p[i] -= 1
        location[p[i]] = i 
    seg = segment_tree(n, location)
    fen = fenwick(n)
    for i in range(n):
        fen.update(i,1)
    ans = [-1]*n
    curr = 1
    for i in range(n):
        if ans[i] >= 0:  
            continue 
        index = fen.getaccu(p[i]) - 1
        if index % 2 == 0:
            fen.update(p[i],-1)
            seg.update(p[i],inf)
            ans[i] = curr 
            curr += 1
            continue
        j = i 
        while True:
            j = seg.query(0,p[j]-1) 
            nextindex = fen.getaccu(p[j]) - 1
            if nextindex % 2 > 0:
                continue 
            break
        ans[j] = curr 
        ans[i] = curr + 1
        curr += 2
        seg.update(p[i],inf)
        seg.update(p[j],inf)
        fen.update(p[i],-1)
        fen.update(p[j],-1)
    print(*ans)

T = int(input())
for t in range(T):
    main(t)