Introduction

Over the past 16.5 years, Codeforces has changed in many ways. On a positive note, Codeforces has become a platform with its own growing community of great people. It has also given its users (including me) some great memories; it could be a massive rating jump, or small observations or edge cases that prevent you from getting AC on a problem causing you to lose rating. Almost all of us have experienced this.

Having a growing community also has its own problems. One major problem occurring very commonly today is cheating. Don't lie to yourself, sometimes in life, you have taken a shortcut (that you know is completely illegal and immoral) out of desperation. Even I have done it twice (I've gotten 2 skipped contests btw). People have been thinking of a way to stop this phenomenon completely for many years now, but we have to face the truth: There is no way to completely erase cheaters from Codeforces. There are flaws with every method to stop cheating:

• IP ban: Impractical when the cheater uses a public network or a VPN

• Other methods: Can simply be bypassed by creating a new account

But have you ever thought of ignoring the cheaters and just consider Codeforces a platform just for practice? In my opinion, cheaters are a part of the platform, and they contribute to the community in some way, maybe you just overlooked them.

My opinion about cheaters

First of all, I like them because they give you a bigger sense of achievement when you achieve a high ranking. Gamers know that it always feels great when you beat someone using some kind of hack client, either X-raying or aim assist in FPS games. The same thing applies to Codeforces, when you beat a cheater, it gives you a bigger sense of happiness. When Codeforces didn't have this many cheaters (just a few years back), you can beat someone consistently and it will feel quite boring. But now, it actually feels satisfying because sometimes AI can beat you and sometimes you can beat AI.

Secondly, people tend to misunderstand things when it comes to cheating. When people hear the word "cheater" on Codeforces, many people think of a person with no knowledge about programming pasting a problem statement into LLMs such as ChatGPT or Gemini, then submitting it into Codeforces. This is only true for a part of the cheaters on Codeforces. The others (including me) are people who actually have some programming skills but get stuck on a problem and ask third-party sources for help. I personally know other people (on Codeforces and in person) who actually do this.

Cheater-exposing blogs

Cheater-exposing blogs can be seen everywhere on Codeforces. It can come in any time (after a contest, on a random day, etc.). These blogs "expose" people who they suspect of cheating during a past contest. Apparently, they have become more popular recently. In my opinion, these "cheater-exposing blogs" are completely unnecessary and it is a waste of time reading and creating these blogs.

Firstly, the anti-cheating system in Codeforces is already quite good enough to eliminate most cheaters. A cheater's contest can be skipped if only one submission is suspected of cheating (due to similar logic or code). After every Codeforces contest, a MOSS (Measure of Software Similarity) analysis is carried out to eliminate similar codes. Then, the contest admins will manually skip submissions if they suspect that the user is using AI or copying other's submissions. Sometimes, they might miss a few users, but there is no need to spend 30 minutes writing a whole blog giving evidence about a cheater. They will be caught eventually.

Secondly, as a person who usually goes on Codeforces to read blogs, the amount of "cheater-exposing and shitposting" blogs has become so large that it is hard to find an actually fun thing to look at. I'd really appreciate the blog if it was one of greateric's blogs that include interesting stuff or some behind-the-scenes drama such as this blog or this blog. But I don't like it if the blogs are just "Cheater in Codeforces Round xxxx" or "My first contest".

Conclusion and Additional notes

In conclusion, I think people should just stop exposing cheaters in general. It is a complete waste of time (I know that many people hate cheating, but there is no need to snitch someone out). People who do this might just be scared that they will be replaced by AI in the future.

In the blog, I did say that I'd like to have some cheaters in a contest, but I only like it to a certain extent. If there were only 2-3% of cheaters in the standings, I might be quite satisfied. But in the current era, around 10-15% of people in contests are cheaters, and they often achieve high ranks (There has been contests where the top 10-20 are mostly cheaters and this is actually traumatizing to people who are actually competing for rating).

If you have any opinions, feel free to share them in the comments section!!

I think August 2026 will be a special month because there will be contests on the 6th and 7th (and cuz I like 67). As far as I know, this is the first month to have 2 contests like so. If I am wrong, please do tell me a month in the comments

2241A - Divide and Conquer

Let $$${z_1, z_2, z_3, ..., z_k}$$$ be the values of $$$z$$$ in the operations to transform $$$x$$$ into $$$y$$$. $$$\newline$$$ The resulting x after the operations is: $$$\dfrac{x}{\displaystyle\prod^{k}_{i=1} z_i}$$$

In other words, we have $$$y = \dfrac{x}{\displaystyle\prod^{k}_{i=1} z_i}$$$

Or $$$\displaystyle\prod^{k}_{i=1} z_i = \dfrac{x}{y}$$$.

Since $$$\displaystyle\prod^{k}_{i=1} z_i$$$ is an integer, $$$\dfrac{x}{y}$$$ must also be an integer, so the answer is YES if $$$x$$$ is divisible by $$$y$$$ and NO otherwise

Time complexity: $$$O(1)$$$ per testcase

#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
using ll = long long;

int t;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cin >> t;
    while(t--) {
    	int a, b;
    	cin >> a >> b;
    	cout << (a % b == 0 ? "YES" : "NO") << endl;
    }
}

2241B - Good times Good times

Before we find the answer, express $$$concat(n, n)$$$ (where concat(x, y) means concatenating $$$x$$$ and $$$y$$$ together) in terms of $$$n$$$

We know that $$$10^{d(n)} + 1$$$ is a good number since it only contains 0 and 1, and $$$concat(n, n)$$$ is a good number since n is a good number, so we need to output $$$10^{d(n)} + 1$$$. We do not need to worry about the bounds since $$$d(n) \le 8$$$

Time complexity: $$$O(d(n))$$$ per testcase

#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
using ll = long long;

int t;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cin >> t;
    while(t--) {
    	int x;
    	cin >> x;
    	string s = to_string(x);
    	cout << '1';
    	for(int i = 0; i < s.size() - 1; i++) cout << '0';
    	cout << '1' << endl;
    }
}

2241C - RemovevomeR

First, let's prove that the answer does not exceed 2

Consider a binary string $$$s$$$ of length $$$n \ge 3$$$.

• If there are 2 consecutive equal characters, they form a palindrome

• Otherwise, $$$s$$$ must be of the form $$$01010101...$$$ or $$$10101010...$$$. Then $$$010$$$ and $$$101$$$ form palindromes.

So we can always decrease the size of a binary string with length at least 3

Now let's see in which cases is the answer equal to 2. $$$\newline$$$ In fact, the answer is equal to 2 when there exists exactly 1 index $$$i$$$ such that $$$1 \le i \le n - 1$$$ and $$$s_i \ne s_{i + 1}$$$

This can be proven by combining consecutive equal characters into blocks.

• If there are exactly 2 blocks, they cannot be combined together, thus resulting in a final length of 2.

• Otherwise, operations can be performed to turn a block into a single character with the corresponding value. The leftover string will have alternating 1s and 0s, so we can keep removing characters until there is only 1 character left.

Time complexity: $$$O(n)$$$ per testcase

#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
using ll = long long;

int t;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cin >> t;
    while(t--) {
    	int n;
    	string s;
    	cin >> n >> s;
    	int cnt = 0;
    	for(int i = 0; i < n - 1; i++) {
    		if(s[i] != s[i + 1]) cnt++;
    	}
    	if(cnt == 1) cout << 2 << endl;
    	else cout << 1 << endl;
    }
}

2241D - An Alternative Way

There are 2 observations we need to make in this problem:

1. We do not need to care cases where $$$a_i \le b_i$$$ since we can perform an operation where $$$l = r = i$$$ a total of $$$b_i - a_i$$$ times

2. When we want to decrease $$$a_i$$$, we have to increase $$$a_{i - 1}$$$. This leads to the fact that we cannot decrease the first element

From these 2 observations, we can form a strategy as follows:

Traverse the array backwards and for each $$$i$$$ such that $$$2 \le i \le n$$$ and $$$a_i \gt b_i$$$, we decrease $$$a_i$$$ by $$$a_i - b_i$$$ and increase $$$a_{i - 1}$$$ by $$$a_i - b_i$$$ $$$\newline$$$ Finally, if $$$a_1 \le b_1$$$ output YES, otherwise output NO

Time complexity: $$$O(n)$$$ per testcase

Note: For the sake of simplicity, the decrease of $$$a_i$$$ has been omitted in the following implementation

#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
using ll = long long;

int t;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cin >> t;
    while(t--) {
    	int n;
    	cin >> n;
    	vector<ll> a(n), b(n);
    	for(int i = 0; i < n; i++) cin >> a[i];
    	for(int i = 0; i < n; i++) cin >> b[i];
    	for(int i = n - 1; i > 0; i--) {
    		if(a[i] > b[i]) {
    			a[i - 1] += (a[i] - b[i]);
    		}
    	}
    	if(a[0] > b[0]) cout << "NO" << endl;
    	else cout << "YES" << endl;
    }
}

Before you click that upvote button, hear me out. My contribution is positive and I want it to be negative, so just please do me a favor and click that downvote button.