is $1900 - 2399$ - $3$ — If your rating is $2400+$ If you are a beginner then
just learn

# | User | Rating |
---|---|---|

1 | tourist | 3869 |

2 | Benq | 3618 |

3 | Miracle03 | 3452 |

4 | peehs_moorhsum | 3429 |

5 | Radewoosh | 3417 |

6 | Petr | 3408 |

7 | maroonrk | 3386 |

8 | ko_osaga | 3339 |

9 | sunset | 3338 |

10 | jiangly | 3333 |

# | User | Contrib. |
---|---|---|

1 | YouKn0wWho | 214 |

2 | 1-gon | 204 |

3 | Um_nik | 195 |

4 | Errichto | 182 |

5 | awoo | 180 |

6 | sus | 176 |

6 | tourist | 176 |

8 | antontrygubO_o | 172 |

9 | -is-this-fft- | 169 |

10 | maroonrk | 168 |

You can use several words in query to find by all of them at the same time. In addition, if you are lucky search understands word forms and some synonyms. It supports search by title and author. Examples:

`305`

— search for 305, most probably it will find blogs about the Round 305`andrew stankevich contests`

— search for words "andrew", "stankevich" and "contests" at the same time`user:mikemirzayanov title:testlib`

— search containing "testlib" in title by MikeMirzayanov`"vk cup"`

— use quotes to find phrase as is`title:educational`

— search in title

1.

The Ultimate Topic List (with Resources, Problems and Templates) This post took $4$ years to make. And this is the most significant thing that I have ever shared in my whole life.
#### Story
Hi, I have been doing CP for like $4$ years and from the very beginning what I have been feeling is a need for a comprehensive topic list that will contain all sorts of topics from easy to advanced with corresponding tutorials, problem lists and templates so that I wouldn't have to look at different sites, from here to there. So what do you do when you think something is missing from the world? Yeah, you create that thing! So here I am, sharing the ultimate topic list that you will need in CP.
When I say that it took me $4$ years to make it, I genuinely mean it. I have been collecting them from the inception of my CP journey and yesterday I thought that it got its almost complete shape. You may not imagine the sheer excitement hidden under each of the characters of this post.
#### Payment
You can pay me just by upvoting this blog and by being a bet...

is $1900 - 2399$ - $3$ — If your rating is $2400+$ If you are a beginner then
just learn

2.

Algorithms Thread 8: Tree Basics (+ Gym Contest) Algorithms Thread Episode 8: Tree Basics
==================
Episode 8 of Algorithms Thread [comes out in <90 minutes!](https://youtu.be/MOy4UDjN8DM) This one is a bit more beginner-friendly and covers the following ideas:
- Graph/Tree Diameters
- Binary Lifting
- Tree Flattening with Euler tours
Also, to make sure you have actually learned that stuff, I made a [custom Gym set on CodeForces](https://codeforces.com/gym/102694) that will last two weeks that hopefully is really good practice for making sure you have learned this stuff. Here is a link to the gym set; it will be available 45 minutes after the video comes out so that people have time to watch the video before starting the set, if they are interested in penalty points. All of the problems in the gym are original to this set (in their flavortext at least, some are simple enough that I'm sure they have appeared in other contests before).
The new gym integration was heavily inspired by [user:Errichto,2020-08-16]'s ...

Algorithms Thread 8: Tree Basics (+ Gym Contest), [comes out in <90 minutes!](https://youtu.be/MOy4UDjN8DM) This one is a bit
morebeginner-friendly, is a bit more beginner-friendly and covers the following ideas:

Announcement of AlgorithmsThread Tree Basics Contest

3.

Codeforces: Updates in rating and rounds <img src="/predownloaded/21/a3/21a33b497ee8a34a678befc3f79745eb69a9cf07.png" style="float:right; margin: 0 1em 1em 1em;"/>
Hello, Codeforces!
It's time for news. I hope you will enjoy!
* We reduce the rating bound for the orange color. Thus, now the orange rating (and the _Master_ title) will start from 2100 rating units.
* The lower bound of the rating for _legendary grandmasters_ is increased to 3000 rating units. Thus, right now in the community, 14 participants meet this requirement. Real legends!
* For rounds like "Div. 2 Only" the upper bound of the rating for official participation is increased. Now everyone whose rating is less than 2100 (i.e., before _masters_) will be able to register for such rounds to participate officially, their rating will be updated based on the results of the round. We do not plan to increase the complexity of Div. 2 rounds. Practice shows that the problems of such rounds are interesting and useful for participants "below the orange".
...

in these rounds simple training problems that will help beginner participants
to gain skills and to get new

4.

Codeforces New Feature: Rewrite Statements in Mashups Hello Codeforces!
There is something new for you. It seems that now it will be easier to reuse problems from the archive for educational and other purposes.
As you know, problems from past Codeforces rounds can be added to <a href="https://codeforces.com/blog/entry/10099">mashups</a> simply by their codes of the form like <code>1234D</code> (contest ID + problem letter). I myself regularly used this when I taught at Saratov University — it was very convenient to prepare trainings: problems have expected complexity and topics, there are Russian and English statements, you can see the analysis and many solutions. Because of hacks and uphacks, problems in the archive usually have strong tests. Almost all of them are well-prepared. In addition, with the help of <a href="https://codeforces.com/blog/entry/21912">user lists</a>, you can easily pick up problems for a group of students that they did not solve.
<img src="/predownloaded/2f/ec/2fecbf1f7e7a8f8655f0f74576fd1f6dbbc2307...

by their codes of the form like 1234D (contest ID + problem letter). I myself
regularly

5.

A Beginners Tutorial on How to Write an Engaging CF Blog Lets say that you wanted to write a tutorial about Li Chao Segment tree or how [user:Elegia,2021-09-05]'s mind works but you dont know how to write it or where to even begin. Don't worry because this blog will help you start off and get 4k upvotes(note: specified number of upvotes will only come if you write about Elegia's mind).
The first thing people see about your blog is the title. Unless it is in top(in that case you probably already know how to write a good blog), then people will be clicking on it from Recent Actions. If the blog is a contest announcement, a tutorial, or a blog asking for help on a problem, then keeping the title short and concise will help. A certain level of formality should be held when writing the title because it encases everything that you are writing about. You should, however, include description in your title. Simply saying "I have a question" or something similar to that isn't helpful to anyone.
A good title:
<a href="https://imgbb.com/"><i...

reader attention. Most of the contest announcements and even tutorials have
images to some extent, will be clicking on it from Recent Actions. If the blog is a contest
announcement, a tutorial, or a blog, . If the blog is a contest announcement, a tutorial, or a blog asking for help
on a problem

6.

I compiled a list of almost all useful blogs ever published on Codeforces [update: till 09.06.2021] <h3 style="color:red">If there are any blogs that I have missed, please tell in the comment section. Thank you.</h3>
# Mathematics Stuff
- [Number Theory in Competitive Programming [Tutorial]](https://codeforces.com/blog/entry/46620)
- [Number of points on Convex hull with lattice points](https://codeforces.com/blog/entry/62183)
- [FFT, big modulos, precision errors.](https://codeforces.com/blog/entry/48465)
- [Number of ways between two vertices](https://codeforces.com/blog/entry/19078)
- [Mathematics For Competitive Programming](https://codeforces.com/blog/entry/76938)
- [FFT and NTT](https://codeforces.com/blog/entry/19862)
- [Burnside Lemma](https://codeforces.com/blog/entry/51272)
- [Number of positive integral solutions of equation 1/x+1/y=1/n!](https://codeforces.com/blog/entry/76836)
- [On burnside (again)](https://codeforces.com/blog/entry/64860)
- [Simple but often unknown theorems/lemmas/formula? Do you know?](https://codeforces.com/blog/entry/55912)
- [Probabili...

1000 to 2400+](https://codeforces.com/blog/entry/66909) - [Algorithms Thread
9: Treaps (+ GymContest, : Tree Basics (+ Gym Contest)](https://codeforces.com/blog/entry/81527) -
[Treaps reinvented?](https, contest: Geometry Special 2018](https://codeforces.com/blog/entry/59252) -
[O(n) algorithm for finding

7.

About Division 4 Rounds Hello Codeforces!
Initially, here was an announcement of the first round for the fourth division. But currently, in comments there is the huge discussion of division 4 rounds in general. Honestly, I read all (almost all) comments.
I decided to replace the text of this post to match the comments better. Also, I'll write one more post separately to discuss problems. And this post will be about division 4 rounds in general.
About Div4 rounds:
* I'm not afraid of a queue or servers overload: it is technical challenges and my task is to resolve them. The previous biggest rounds were not overshadowed by technical problems and judging delays, they went well. I see no reasons why something should work much worse in the rounds for Div. 4 (and if it does, then this should be fixed).
* I don't think that Div. 3 rounds are too dificult. Actually, they are quite good for beginners. They are noticeably easier than Div. 2. Almost every round trusted participants solve all problems, ma...

8.

Atcoder Beginner Contest 171 — Unofficial English Editorial Hi all, [Atcoder Beginner Contest 171](https://atcoder.jp/contests/abc171) was today. I wrote an unofficial English editorial. Hope it helps!
### [A: αlphabet](https://atcoder.jp/contests/abc171/tasks/abc171_a)
We simply write an if statement.
Runtime: $\mathcal{O}(1)$.
<spoiler summary="Sample code">
~~~~~
char x = in.next().charAt(0);
if (x >= 'A' && x <= 'Z')
out.println("A");
else
out.println("a");
~~~~~
</spoiler>
### [B: Mix Juice](https://atcoder.jp/contests/abc171/tasks/abc171_b)
We want to buy the cheapest fruits, so we can sort the array and then pick the first $K$ fruits.
Runtime: $\mathcal{O}(N \log N)$.
<spoiler summary="Sample code">
~~~~~
int n = in.nextInt(), k = in.nextInt();
int[] p = in.readIntArray(n);
Util.safeSort(p); // this shuffles and sorts to avoid hacks
long answer = 0;
for (int i = 0; i < k; i++) {
answer += p[i];
}
out.println(answer);
~~~~~
</spoiler>
### [C: One Quadrillion and One Dalmatia...

Atcoder Beginner Contest 171 — Unofficial English Editorial, Hi all, [Atcoder Beginner Contest 171](https://atcoder.jp/contests/abc171) was
today. I wrote

9.

AtCoder Beginner Contest 169 Unofficial Editorial I just did my first ABC in a while, so I decided to write up and share my solutions below. Feel free to leave questions in the comments!
There were several questions this round that had the potential to create precision issues; however, the solutions below give approaches that sidestep those errors altogether. Sadly, I think compiling and testing my A prevented me from winning the round :(
#A — Multiplication 1
Just multiply the numbers and print them out. It's not that hard.
Time Complexity: $O(1)$. [Click here for my submission.](https://atcoder.jp/contests/abc169/submissions/13800320)
---
#B — Multiplication 2
This turns out not to be quite as easy as the last problem. Multiplying numbers this large is actually a challenge in C++ because the result is likely to be greater than $2^{63}$, and thus will cause long long overflow. Thus, in C++, we can't just multiply the numbers and check if the result is greater than $10^{18}$.
One possible appr...

AtCoder Beginner Contest 169 Unofficial Editorial

10.

Atcoder Beginner Contest 132 — Unofficial English Editorial Hi all, [Atcoder Beginner Contest 132](https://atcoder.jp/contests/abc132) was today. Atcoder only publishes Japanese editorials for beginner contests, so I wrote an unofficial English editorial. Hope it helps!
### [A: Fifty-Fifty](https://atcoder.jp/contests/abc132/tasks/abc132_a)
After sorting the input, a "good" string will look like "AABB". Therefore, we simply sort and check for this format.
<spoiler summary="Sample code">
~~~~~
char[] s = in.next().toCharArray();
Arrays.sort(s);
out.println(s[0] == s[1] && s[2] == s[3] && s[1] != s[2] ? "Yes" : "No");
~~~~~
</spoiler>
### [B: Ordinary Number](https://atcoder.jp/contests/abc132/tasks/abc132_b)
It suffices to simply check every range of 3 and see if its middle element should be counted. A simple way is to sort each range of 3 and check that the middle element remains in the middle.
Runtime: $\mathcal{O}(n)$.
<spoiler summary="Sample code">
~~~~~
int n = in.nextInt();
int[] p = new int[n];
for (int i =...

Atcoder Beginner Contest 132 — Unofficial English Editorial, Hi all, [Atcoder Beginner Contest 132](https://atcoder.jp/contests/abc132) was
today. Atcoder only

11.

Atcoder Beginner Contest 174 — Unofficial English Editorial Hi all, [Atcoder Beginner Contest 174](https://atcoder.jp/contests/abc174) was today. I wrote an unofficial English editorial. Hope it helps!
### [A: Air Conditioner](https://atcoder.jp/contests/abc174/tasks/abc174_a)
We simply write an if statement.
Runtime: $\mathcal{O}(1)$.
<spoiler summary="Sample code">
~~~~~
int x = in.nextInt();
out.println(x >= 30 ? "Yes" : "No");
~~~~~
</spoiler>
### [B: Distance](https://atcoder.jp/contests/abc174/tasks/abc174_b)
We can loop through all the points, and test each one. To avoid potential rounding errors, it's simplest to check $x^2 + y^2 \le D^2$, so we can keep everything in integers.
Runtime: $\mathcal{O}(N)$.
<spoiler summary="Sample code">
~~~~~
int n = in.nextInt();
long d = in.nextInt();
d = d * d;
Point[] points = Point.readPoints(in, n);
int answer = 0;
for (Point p : points) {
if (p.x * p.x + p.y * p.y <= d)
answer++;
}
out.println(answer);
~~~~~
</spoiler>
### [C: Repsept](h...

Atcoder Beginner Contest 174 — Unofficial English Editorial, Hi all, [Atcoder Beginner Contest 174](https://atcoder.jp/contests/abc174) was
today. I wrote

12.

Unofficial ACL Beginner Contest Editorial ### [A – Repeat ACL](https://atcoder.jp/contests/abl/tasks/abl_a)
<spoiler>
Easy programming-language-knowledge check typical of the first task of AtCoder beginner contests. The following is a passing Kotlin submission:
```
fun main() {
val k = readLine()!!.toInt()
val ans = "ACL".repeat(k)
println(ans)
}
```
</spoiler>
### [B – Integer Preference](https://atcoder.jp/contests/abl/tasks/abl_b)
<spoiler>
Assume there is an integer in both ranges and call it $x$. Note that both $x \ge \max(A, C)$ and $x \le \min(B, D)$ must therefore be true.
Thus $x$ exists if and only if $\max(A, C) \le \min(B, D)$ is true. This is the standard formula for finding the overlap of two ranges.
</spoiler>
### [C – Connect Cities](https://atcoder.jp/contests/abl/tasks/abl_c)
<spoiler>
Note that the initial network of cities can be divided into one or more *components*, where any city of a component can reach any other city in that component follow...

Unofficial ACL Beginner Contest Editorial, Easy programming-language-knowledge check typical of the first task of AtCoder
beginner, programming-language-knowledge check typical of the first task of AtCoder
beginner contests. The following

13.

AtCoder Beginner Contest 135 English Solutions #A — Harmony
Without loss of generality, let $A < B$. Then, we have three cases:
- $K$ is less than $A$. This gives $A - K = B - K$, which gives $A = B$, which is false.
- $K$ is greater than $B$. This gives $K - A = K - B$, which is also false.
- $K$ is between $A$ and $B$. This gives $K - A = B - K$, which gives $2K = A+B$.
Thus, we must have $2K=A+B$. If $A+B$ is odd, there is thus no solution. If $A+B$ is even, our answer is $\frac{A+B}{2}$. It is easy to verify that this number is indeed between $A$ and $B$.
Runtime: $O(1)$. [Click here for my submission.](https://atcoder.jp/contests/abc135/submissions/6560205)
---
#B — 0 or 1 Swap
Let $K$ be the number of positions $i$ at which $p_i \neq i$ (using 1-indexing). If $K = 0$, the answer is yes, as we can simply leave the permutation as is. If $K = 2$, the answer is also yes: swap the two misplaced elements. (Notice that we can never have $K = 1$, as if any element is put in the wrong posi...

AtCoder Beginner Contest 135 English Solutions

14.

AtCoder Beginner Contest 133 English Solutions Since AtCoder often doesn't release English editorials to their beginner contests, I thought I'd write up my solutions. Feel free to add a comment if anything was unclear!
A — T or T
------------------
Our alternatives here are sending all $N$ people on the train, for a total of $N \cdot A$ yen, or using the taxi, for a total of $B$ yen. We should thus print the minimum of these two values.
Code: https://atcoder.jp/contests/abc133/submissions/6265526
B — Good Distance
------------------
We reword the problem slightly: for how many points $y$ and $z$ is $\sum_{k=1}^D (y_i-z_i)^2$ a perfect square?
Given the small input constraints, we know that this sum is going to be at most $10 \cdot (20-20)^2 = 16000$. Hence, we can simply compute a list of all perfect squares less than $16000$ and iterate over all $\dbinom{N}{2}$ pairs of points. For each pair of points, we compute the summation and check if it is equal to any of our squares. If so, we increment th...

AtCoder Beginner Contest 133 English Solutions, Since AtCoder often doesn't release English editorials to their beginner
contests, I thought I'd

15.

AtCoder Beginner Contest 128 — Unofficial English Editorial Hello Codeforces! Did you enjoy the [AtCoder Beginner Contest 128](https://atcoder.jp/contests/abc128)? A Japanese editorial is [already out](https://img.atcoder.jp/abc128/editorial.pdf), but unfortunately there is no English editorial, so I translated it into English experimentally. Note that this is an unofficial one; AtCoder has no responsibility for this editorial. Also, I didn't do proofreading at all, so it might contain many typos. Moreover, this is the first experience I write such kind of editorial, so the English may not be clear, may be confusing, or even contain mistakes. Any minor corrections (including grammatical one) or improvement suggestions are welcome. Please do not hesitate posting a comment about it.
## A: Apple Pie
For simplicity, you can cut all the apples into pieces in advance. As a result, you will have $3A+P$ pieces of apple. By using all these pieces as much as you can make apple pie, you will get maximum number of apple pies. The maximum ...

AtCoder Beginner Contest 128 — Unofficial English Editorial, Hello Codeforces! Did you enjoy the [AtCoder Beginner Contest
128](https://atcoder.jp/contests

16.

Atcoder Beginner Contest 143 — Unofficial English Editorial Hi all, [Atcoder Beginner Contest 143](https://atcoder.jp/contests/abc143) was today. I wrote an unofficial English editorial. Hope it helps!
### [A: Curtain](https://atcoder.jp/contests/abc143/tasks/abc143_a)
The curtains can cover a maximum of $2B$. So either they don't cover the whole window and the remainder is $A-2B$, or they do and the remainder is $0$. So the answer is $\max(0, A-2B)$.
Runtime: $\mathcal{O}(1)$.
<spoiler summary="Sample code">
~~~~~
int a = in.nextInt(), b = in.nextInt();
out.println(Math.max(0, a - 2 * b));
~~~~~
</spoiler>
### [B: TAKOYAKI FESTIVAL 2019](https://atcoder.jp/contests/abc143/tasks/abc143_b)
We can simply loop through every pair (taking care not to double count) and add the health points restored.
Runtime: $\mathcal{O}(N^2)$.
<spoiler summary="Sample code">
~~~~~
int n = in.nextInt();
int[] d = in.readIntArray(n);
long answer = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
answ...

Atcoder Beginner Contest 143 — Unofficial English Editorial, Hi all, [Atcoder Beginner Contest 143](https://atcoder.jp/contests/abc143) was
today. I wrote

17.

Unofficial Editorial for AtCoder Beginner Contest #190 [A — Very Very Primitive Game](https://atcoder.jp/contests/abc190/tasks/abc190_a)
---------------------------------------------------------------------------------------
<spoiler summary="Solution">
Simply simulate the game and print out the winner.
Time complexity: $O(A+B)$ [My solution](https://atcoder.jp/contests/abc190/submissions/19821916)
</spoiler>
[B — Magic 3](https://atcoder.jp/contests/abc190/tasks/abc190_b)
---------------------------------------------------------------------------------------
<spoiler summary="Solution">
For each spell $i$, check if $X_i < S$ and $Y_i > D$. If such spell $i$ is found, the answer is `"Yes"`, otherwise, if after all spells have been processed and no such spell has been found, the answer is `"No"`.
Time complexity: $O(N)$ [My solution](https://atcoder.jp/contests/abc190/submissions/19822194)
</spoiler>
[C — Bowls and Dishes](https://atcoder.jp/contests/abc190/tasks/abc190_c)
---------------------...

Unofficial Editorial for AtCoder Beginner Contest #190

18.

Atcoder Beginner Contest 146 -- Unofficial English Editorial Hi all, [Atcoder Beginner Contest 146](https://atcoder.jp/contests/abc146) was today. I wrote an unofficial English editorial. Hope it helps!
### [A: Can't Wait for Holiday](https://atcoder.jp/contests/abc146/tasks/abc146_a)
We simply find the index in the week, and print $7-i$ (taking care to order the days correctly so Sunday gives us $7$ as the output).
Runtime: $\mathcal{O}(1)$.
<spoiler summary="Sample code">
~~~~~
String w = "SUNMONTUEWEDTHUFRISAT"; // this is sort of a bad way to do this
String s = in.next();
int i = w.indexOf(s) / 3;
out.println(7 - i);
~~~~~
</spoiler>
### [B: ROT N](https://atcoder.jp/contests/abc146/tasks/abc146_b)
We can simply loop through the string and increment each character by $N$, taking care to subtract $26$ if we go past the end of the alphabet.
Runtime: $\mathcal{O}(|S|)$.
<spoiler summary="Sample code">
~~~~~
int n = in.nextInt();
char[] s = in.next().toCharArray();
for (int i = 0; i < s.length; i++) {
s[i]...

Atcoder Beginner Contest 146 -- Unofficial English Editorial, Hi all, [Atcoder Beginner Contest 146](https://atcoder.jp/contests/abc146) was
today. I wrote

19.

Unofficial Editorial for AtCoder Beginner Contest #187 [A — Large Digits](https://atcoder.jp/contests/abc187/tasks/abc187_a)
==============================================================
<spoiler summary="Solution">
Calculate the sum of the digits of both integers, and print out the maximum.
Time complexity: $O(1)$ [My solution](https://atcoder.jp/contests/abc187/submissions/19162245)
</spoiler>
[B — Gentle Pairs](https://atcoder.jp/contests/abc187/tasks/abc187_b)
==============================================================
<spoiler summary="Solution">
As the slope $m$ of a line between two points $(x_1,y_1)$ and $(x_2,y_2)$ can be found by the equation $m = \frac{y_2-y_1}{x_2-x_1}$, we simply need to compute the value of $m$ for each pair $(i,j)$, while adding $1$ to our count every time $-1 \le m \le 1$.
Time complexity: $O(N^2)$ [My solution](https://atcoder.jp/contests/abc187/submissions/19162514)
</spoiler>
[C — 1-SAT](https://atcoder.jp/contests/abc187/tasks/abc187_c)
================...

Unofficial Editorial for AtCoder Beginner Contest #187

20.

AtCoder Beginner Contest 144 English Solutions #A — 9x9
We can simply directly implement the procedure given in the problem. Print $AB$ if $A$ and $B$ are less than $10$ and $-1$ otherwise. One particularly fast way to do this is to use the ternary operator, which takes a boolean expression and two values as inputs and returns the first value if the expression is true and the second value otherwise. In C++, this looks like
$\texttt{A < 10 && B < 10 ? A*B : -1}$.
Runtime: $O(1)$. [Click here for my submission.](https://atcoder.jp/contests/abc144/submissions/8146605)
---
#B — 81
Since we're only considering pairs of numbers from one through nine, we can simply iterate over every pair of numbers from one to nine and check if each pair multiplies to $N$. As soon as we find such a pair, we output Yes and exit the program. If we reach the end of the loop, we can then print No, since we've checked every possible pair and found that none of them work.
Notice that we could also iterate over all number...

AtCoder Beginner Contest 144 English Solutions

21.

Mashup contests for beginners (1500, 1600, 1600, 1700) Hey everyone,
I hope you are doing good. I was thinking of starting a mashup contest series in which I will be creating a mashup contest every day at some time (which we all can choose) and that contest will have 4 questions (1 div2B (1500), 2 div2C's (1600) and 1 div2D(1700)) and 2 hours to attempt those. Right after the contest we can discuss the solutions and do that every single day (except when an official contest is there).
I feel that this way we can get more practise and having a group who want to practise similar things will keep us motivated.
Let me know what do you guys think about this.
PS: This is targeted for beginners (cyans who wanna be blue). Everyone is welcome for this tho.
Based on the response I will start creating contests from today onwards.
Thanks
UPD:
So looks like **I am not allowed to create a mashup contest**. I was able to create a mashup right before this announcement. Can someone tell me why this is happening? Hoping _they_ dont take m...

22.

AtCoder Beginner Contest 129 — Unofficial English Editorial Hello Codeforces! Did you enjoy the [AtCoder Beginner Contest 129](https://atcoder.jp/contests/abc129)? As usual, there was only [Japanese editorial](https://img.atcoder.jp/abc129/editorial.pdf) published, so I translated it into English again.
**Disclaimer.** Note that this is an unofficial editorial and AtCoder has no responsibility for this. Also, I didn't do proofreading at all, so it might contain many typos. Moreover, this is the second experience I write such kind of editorial, so the English may not be clear, may be confusing, or even contain mistakes. Any minor corrections (including grammatical one) or improvement suggestions are welcome. Please do not hesitate posting a comment about it.
## A: Airplane
There are 6 orders to visit the airports, so you can try all of them and look for the minimum value. However, if you realized that each cost of a route is equal to the sum of two integers out of the given three, you could also obtain an answer by subtracting ...

AtCoder Beginner Contest 129 — Unofficial English Editorial, Hello Codeforces! Did you enjoy the [AtCoder Beginner Contest
129](https://atcoder.jp/contests

23.

AtCoder Beginner Contest 130 — Unofficial English Editorial Hello Codeforces! Did you enjoy the [AtCoder Beginner Contest 130](https://atcoder.jp/contests/abc130)? As usual, there was only [Japanese editorial](https://img.atcoder.jp/abc130/editorial.pdf) published, so I translated it into English. Um, actually it's already three days after the contest, it might be a bit late, but well, whatever?
**Disclaimer.** Note that this is an unofficial editorial and AtCoder has no responsibility for this. Also, I didn't do proofreading at all, so it might contain many typos. Moreover, this is the third experience I write such kind of editorial, so the English may not be clear, may be confusing, or even contain mistakes. Any minor corrections (including grammatical one) or improvement suggestions are welcome. Please do not hesitate posting a comment about it.
## A: Rounding
You can implement it straightforward: print $0$ if $X < A$, and print $10$ if $x >= A$.
An example code is shown in List 1:
Listing 1. Example Code of Rounding...

AtCoder Beginner Contest 130 — Unofficial English Editorial, Hello Codeforces! Did you enjoy the [AtCoder Beginner Contest
130](https://atcoder.jp/contests

24.

[Gym] Invitation to Dagitab 2021 Mirror — Beginner-Friendly Long Contest Happy New Year to the Codeforces community!
I would like to invite you all to join the mirror of the Ateneo Senior High School Programming Varsity's mid-year contest, Dagitab 2021. You will be given a little under 10 days to solve 13 problems. The problems will be available starting 9:00 am on Jan 2 (UTC+8), and the contest officially runs until 11:59 pm on Jan 11 (again, UTC+8).
**EDIT:** The problems are now available. Good luck!
The contest link is here: https://codeforces.com/contests/102911 *Edited this to be the correct link
Most of the problems in the contest are standard, since it is targeted at beginners, so as long-format, I think this contest would be educational for people up to Cyan level. More experienced contestants could even treat these 13 problems as an easy ICPC set, and a team of three Purples could possibly finish the entire set within the 5-hour period (I think).
I also guaranteed that all these problems are comfortably solvable using Python (th...

[Gym] Invitation to Dagitab 2021 Mirror — Beginner-Friendly Long Contest, Most of the problems in the contest are standard, since it is targeted at
beginners, so as long

Codeforces (c) Copyright 2010-2021 Mike Mirzayanov

The only programming contests Web 2.0 platform

Server time: Dec/02/2021 04:59:51 (k2).

Desktop version, switch to mobile version.

Supported by

User lists

Name |
---|