Online competitions are dead.

It was fun while it lasted. Some of us were lucky enough to witness the golden age of competitive programming. But AI changed it.

Your online results are meaningless. Your online rating is pointless. Not because you cheat, but because others do — and you cannot know how much of the scoreboard you can trust.

There is no stopping it. We keep chasing obvious cases, but cheating will become less and less obvious over time.

“But people could cheat before. They could share ideas or code.”

Yes. But that kind of cheating required at least two people willing to cooperate. Now it takes only one.

“What about screen recordings?”

A recording of your screen cannot show what you are doing on your phone. You do not even need to copy an entire solution.

I do not see a reliable way to restore trust in unsupervised online competition.

Of course, in-person contests are a different story. IOI and ICPC circuits are fine. Training from home is still useful, and solving problems is still fun. But competing from home and expecting the results to be a trustworthy measure of individual ability? Not anymore.

“Isn’t competitive programming too big to die? Aren’t too many people involved?”

There is a way forward: more in-person competitions.

Organize contests at your school or university. Build local communities. Find people you can compete with in the same room.

Compete against each other, no online cheaters.

Hi CodeForces,

As you might know AtCoder Would Tour 2026 Finals are happening in a week and OpenAI bot is participating in both Algorithm and Heuristic tracks. What are your predictions? Will AI beat all humans this time?

Please vote for the options below:

Will AI win the Algorithm finals? Finalist Lineup

• Yes
• No

Will AI win the Heuristic finals? Finalist Lineup

• Yes
• No

Thank you for participating!

Suppose the input for a problem is positive integer N and answer happens to be 1/N. Here is what happens for different constraints on N. You decide which version is the hardest.

1.

N <= 10^9

Everyone does math and all solutions look like

cout << 1.0 / N

2.

N <= 10^6

You see solutions from above but some contestants decide to use iterative approach, something like

double ans = 1.0;
for (int i = 2; i <= N; i++) ans = ans * (i - 1) / i;

3.

N <= 10^5

Mostly solutions from above, but some contestants use recursion (maybe with memoization)

double f(int N) {
   if (N == 1) return 1.0;
   return f(N - 1) * (N - 1) / N;
}

4.

N <= 500

Solutions from above, but some contestants go with O(N^3) dynamic programming instead

5.

N <= 109

Contestants think there is a typo and go with first solution

6.

N <= 100

Some contestants realize that you can precompute all answers

const double ans[100]={1.0, 0.5, 0.333333333, ... }

7.

N <= 47

Intended solution from Ukrainian author has O(N^4) complexity

8.

N <= 36

You see lot of solutions with meet-in-the middle approach

9.

N <= 20

You start to see a lot of bitwise operations in codes that can mean dynamic programming on subsets

10.

N <= 10

Some C++ codes use next_permutation(), Java coders having harder time