1. What exactly is the problem

During rounds, a specific pattern has appeared: a participant gets ready-made code from an LLM and simply submits it, almost without understanding it. This is not always caught by plagiarism: a person can rename variables, swap some parts of the code.

2. The idea

Xeppelin — an open-source tool, originally made for ICPC, which:

• is launched locally before the contest
• logs file changes in the working directory
• stores a development timeline (when and how the code changed)
• does not record the screen, keyboard, network, or tabs
• after the contest builds a visualization of activity

This is not my tool, but you can find it here

3. What exactly is proposed for Codeforces (implementation, not an idea)

The proposal is to use Xeppelin as an external source of behavioral data, without interfering with CF infrastructure. Workflow:

1. The participant launches Xeppelin before the round

2. Solves problems as usual (locally, in an IDE)

3. After the round Xeppelin produces:

• a file changes log
• an activity timeline

This log can be automatically linked with CF submissions (by contestId + handle)

CF at the same time:

• does not change the submission process
• does not receive data in real time
• does not require anything complex and global except installing 1 piece of software and linking it with codeforces.

4. What data is obtained

From Xeppelin, clear and simple metrics are available:

• number of file changes before AC
• sizes of individual changes
• active work time vs idle time
• whether the code was written gradually or “in one chunk”
• whether the same pattern repeats across multiple problems

These are process metadata, not screen content and not user input.

5. Why this works well specifically against cheaters:

A typical pattern of copying or cheating with an LLM-solution:

• long idle period
• one large file update
• almost no edits
• immediate AC

This pattern:

• rarely occurs for people who actually write code
• is clearly visible exactly in the file timeline
• is hard to fake without actually rewriting the solution

6. How this can be used in practice (without bans)

Xeppelin is not proof, but a signal. Realistic use cases:

• additional input for post-contest analysis
• a basis for provisional rating in clearly anomalous cases
• a tool for moderators/authors, not automatic punishment

7. Why this is safe for CF

• no proctoring
• no interference with submissions
• no mandatory installations
• no real-time load

Xeppelin works completely outside, CF receives data after the contest or only upon request.

8. Limitation and compromise solution

Limitation

An obvious downside of this approach is that it is impossible and unnecessary to cover 100% of participants. Some people will not be able or willing to use an external logger (devices, installation policy, personal reasons).

Trying to make such software mandatory for all rated rounds is indeed too strict and may harm Codeforces accessibility.

Compromise solution (without changing the core CF system)

Instead, the following option is proposed:

• The rating remains the same as now
• Each result gets a status:

• Verified — if the participant attached an activity log (Xeppelin)

• Unverified — normal participation, without logs

• This is not a separate rating and not a “second league”

• This is an additional layer of trust, similar in spirit to unofficial standings or verified badges

In practice, this gives:

• the ability to filter the leaderboard by Verified
• priority of trust for verified results
• fewer provisional checks for verified participants

At the same time:

• nobody loses access to rating
• the contest format does not break
• honest participants get a clear incentive to confirm the process

9. TL;DR

There is already an existing tool (Xeppelin) that logs the development process without surveillance. It can be directly linked to CF rounds and used as an additional signal against LLM-solution copy-paste — without bans and without breaking the platform.

2126A - Only One Digit

Idea: soullless

#include <bits/stdc++.h>
using namespace std;
int main() {
  int t;
  cin >> t;
  while(t--) {
    int x;
    cin >> x;
    int mn = 9;
    while(x > 0) {
      mn = min(mn, x % 10);
      x/=10;
    }
    cout << mn << endl;
  }
}

2126B - No Casino in the Mountains

Idea: soullless

#include <bits/stdc++.h>
using namespace std;
int main() {
  int t;
  cin >> t;
  while(t--) {
    int n,k;
    cin >> n >> k;
    int a[n + 1];
    for(int i = 1;i <= n;i++) cin >> a[i];
    int ans = 0;
    int cnt = 0;
    for(int i = 1;i <= n;i++) {
      if(a[i] == 1) {
        ans+=(cnt + 1)/(k + 1);
        cnt = 0;
        continue;
      }
      else {
        cnt++;
      }
    }
    ans+=(cnt + 1)/(k + 1);
    cout << ans << endl;
  }
}

2126C - I Will Definitely Make It

Idea: soullless

#include <bits/stdc++.h>
using namespace std;
int main() {
  int t;
  cin >> t;
  while(t--) {
    int n,p;
    cin >> n >> p;
    int a[n + 1];
    for(int i = 1;i <= n;i++) cin >> a[i];
    int cur = a[p];
    int dist = a[p];
    sort(a + 1,a + n + 1);
    bool ans = true;
    for(int i = 1;i <= n;i++) {
      if(a[i] < cur) continue;
      if(a[i] &mdash; cur > dist) {
        ans = false;
      }
      cur = a[i];
    }
    if(ans) cout << "YES" << endl;
    else cout << "NO" << endl;
  }
}

2126D - This Is the Last Time

Idea: soullless

#include <bits/stdc++.h>
using namespace std;
int main() {
  int t;
  cin >> t;
  while(t--) {
    int n,k;
    cin >> n >> k;
    pair <int,pair <int,int> > p[n + 1];
    for(int i = 1;i <= n;i++) cin >> p[i].first >> p[ыi].second.first >> p[i].second.second;
    sort(p + 1,p + n + 1);
    int cur = k;
    for(int i = 1;i <= n;i++) {
      if(p[i].first > cur) break;
      cur = max(cur,p[i].second.second);
    }
    cout << cur << endl;
  }
}

2126E - G-C-D, Unlucky!

Idea: Away_in_the_heavens

#include <bits/stdc++.h>
using namespace std;
main() {
    int t;
    cin >> t;
    while (t--) {
        int n;
        cin >> n;
        long long a[n + 1];
        for (int i = 1; i <= n; i++) {
            cin >> a[i];
        }
        long long b[n + 1];
        for (int i = 1; i <= n; i++) {
            cin >> b[i];
        }
        long long ans[n + 1];
        for (int i = n; i >= 1; i--) {
            ans[i] = lcm(a[i], b[i]);
        }
        bool ch = 1;
        if(ans[1] != a[1]) ch = 0;
        if(ans[n] != b[n]) ch = 0;
        for (int i = 2; i <= n; i++) {
            if (__gcd(a[i &mdash; 1], ans[i]) != a[i]) {
                ch = 0;
            }
        }
        for (int i = n &mdash; 1; i >= 1; i--) {
            if (__gcd(b[i + 1], ans[i]) != b[i]) {
                ch = 0;
            }
        }
        if (ch) {
            cout << "YES" << "\n";
        } else {
            cout << "NO" << "\n";
        }
    }
}

2126F - 1-1-1, Free Tree!

Idea: soullless

#include <bits/stdc++.h>
using namespace std;
const int B = 2e5 + 100;
int n;
int col[B];
long long costt = 0;
vector <pair <int,int> > reb[B];
bool was[B];
map <int,long long> cnt[B];
int pred[B];
long long zn[B];
void dfs(int v) {
  was[v] = true;
  for(auto u:reb[v]) {
    if(was[u.first]) {
      pred[v] = u.first;
      continue;
    }
    if(col[v] != col[u.first]) costt+=u.second;
    dfs(u.first);
    zn[u.first] = u.second;
    cnt[v][col[u.first]]+=zn[u.first];
  }
}
void update(int v,int x) {
  if(v != 1) {
    cnt[pred[v]][col[v]]-=zn[v];
    if(col[pred[v]] == col[v]) costt+=zn[v];
    cnt[pred[v]][x]+=zn[v];
    if(col[pred[v]] == x) costt-=zn[v];
  }
  else {
      
  }
  costt+=cnt[v][col[v]];
  costt-=cnt[v][x];
  col[v] = x;
}
void clr() {
  for(int i = 1;i <= n;i++) {
    reb[i].clear();
    was[i] = false;
    cnt[i].clear();
    zn[i] = 0;
  }
  costt = 0;
}
int main() {
  int t;
  cin >> t;
  while(t--) {
    int q;
    cin >> n >> q;
    for(int i = 1; i <= n; i++) cin >> col[i];
    for(int i = 1; i < n; i++) {
      int u, v, c;
      cin >> u >> v >> c;
      reb[v].push_back({u,c});
      reb[u].push_back({v,c});
    }
    dfs(1);
    while(q--) {
      int pos,x;
      cin >> pos >> x;
      update(pos,x);
      cout << costt << "\n";
    }
    clr();
  }
}

2126G1 - Big Wins! (easy version)

Idea: soullless

#include <bits/stdc++.h>
using namespace std;
const int B = 2e5 + 100;

int main() {
  int t;
  cin >> t;
  while(t--) {
    int n;
    cin >> n;
    int a[n + 1];
    for(int i = 1;i <= n;i++) cin >> a[i];
    int ans = 0;
    for(int i = 1;i <= 100;i++) {
      int b[n + 1] = {};
      for(int j = 1;j <= n;j++) {
        if(a[j] >= i) b[j] = 1;
        else b[j] = -1;
      }
      int pref[n + 1] = {};
      for(int j = 1; j <= n; j++) {
        pref[j] = pref[j - 1] + b[j]; 
      }
      int prefmn[n + 2] = {},suffmx[n + 1] = {};
      prefmn[0] = 0,suffmx[n] = pref[n];
      for(int j = 1; j <= n; j++) {
        prefmn[j] = min(prefmn[j - 1],pref[j]);
      }
      for(int j = n - 1; j >= 1; j--) {
        suffmx[j] = max(suffmx[j + 1],pref[j]);
      }
      for(int j = 1; j <= n; j++) {
        if(prefmn[j - 1] <= pref[j] || pref[j - 1] <= suffmx[j]) {
          ans = max(ans,i - a[j]);
        }
      }
    } 
    cout << ans << endl;
  }
}

2126G2 - Big Wins! (hard version)

Idea: soullless

#include<bits/stdc++.h>
using namespace std;
int n;
int a[200005 + 2];
array<int, 4> t[800005];
array<int, 4> merge(array<int, 4>a, array<int, 4>b) {
    int ans = max(a[0], b[0]);
    int mxpref = max(a[1], a[3] + b[1]);
    int mxsuff = max(b[2], a[2] + b[3]);
    ans = max({ans, mxpref, mxsuff});
    int sum = a[3] + b[3];
    return {ans, mxpref, mxsuff, sum};
}
void update(int v, int tl, int tr, int pos, int val) {
    if (tl == tr) {
        t[v] = {max(val, 0), max(val, 0), max(val, 0), val};
    } else {
        int tm = (tl + tr) >> 1;
        if (pos <= tm) {
            update(v * 2, tl, tm, pos, val);
        } else {
            update(v * 2 + 1, tm + 1, tr, pos, val);
        }
        t[v] = merge(t[v * 2], t[v * 2 + 1]);
    }
}
array<int, 4> get(int v, int tl, int tr, int l, int r) {
    if (tl == l && tr == r) {
        return t[v];
    } else if (l > r) {
        return {0, 0, 0, 0};
    } else {
        int tm = (tl + tr) >> 1;
        return merge(get(v * 2, tl, tm, l, min(r, tm)), get(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r));
    }
}
int solve(int n, vector<int>A) {
    int m = 0;
    for (int i = 1; i <= n; i++) {
        a[i] = A[i &mdash; 1];
        m = max(m, a[i]);
    }
    vector<int>ind[m + 1];
    for (int i = 1; i <= n; i++) {
        ind[a[i]].push_back(i);
    }
    stack<int>s;
    s.push(0);
    a[0] = -INT_MAX;
    int l[n + 1];
    for (int i = 1; i <= n; i++) {
        while (a[s.top()] >= a[i]) {
            s.pop();
        }
        l[i] = s.top() + 1;
        s.push(i);
    }
    a[n + 1] = -INT_MAX;
    s.push(n + 1);
    int r[n + 1];
    for (int i = n; i >= 1; i--) {
        while (a[s.top()] >= a[i]) {
            s.pop();
        }
        r[i] = s.top() &mdash; 1;
        s.push(i);
    }
    int med = 1;
    for (int i = 1; i <= n; i++) {
        update(1, 1, n, i, 1);
    }
    for (auto u : ind[1]) {
        update(1, 1, n, u, -1);
    }
    int ans = 0;
    for (int mn = 1; mn <= m; mn++) {
        for (auto u : ind[mn]) {
            int lg = l[u], rg = r[u];
            while (med < m && get(1, 1, n, lg, u &mdash; 1)[2] + get(1, 1, n, u + 1, rg)[1] + (a[u] < (med) ? -1 : 1) >= 0) {
                med++;
                for (auto u : ind[med]) {
                    update(1, 1, n, u, -1);
                }
            }
        }
        // cout << med << ' ' << mn << endl;
        ans = max(ans, med &mdash; mn);
    }
    return ans;
}
int solveslow(int n, vector<int>A) {
    for (int i = 1; i <= n; i++) {
        a[i] = A[i &mdash; 1];
    }
    int mx = 0;
    for (int i = 1; i <= n; i++) {
        vector<int>v;
        for (int j = i; j <= n; j++) {
            v.push_back(a[j]);
            sort(v.begin(), v.end());
            mx = max(mx, v[v.size() / 2] &mdash; v[0]);
        }
    }
    return mx;
}
int rnd() {
    return (rand() + rand() * RAND_MAX);
}
main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    int tt;
    cin >> tt;
    while(tt--) {
        int n;
        cin >> n;
        vector<int>v;
        for (int i = 1; i <= n; i++) {
            int x;
            cin >> x;
            v.push_back(x);
        }
        cout << solve(n, v) << endl;
        // cout << solveslow(n, v) << endl;
        for(int i = 0;i <= n*4;i++) {
            t[i][0] = 0;
            t[i][1] = 0;
            t[i][2] = 0;
            t[i][3] = 0;
        }
    }
}

Almaty Code Cup x Qazaq Programming Contest — one of the prestigious ICPC-style programming competition for students in grades 7–11(12). Created by former and current members of the Qazaq national informatics team, ACC x QPC is back again in 2025! This is our third edition — and now on an international scale!

Prizes & Awards:

Take part and compete for:

• Cash prizes — total prize pool starting from 3000+ USD;

• Tuition grants and discounts at top technical universities;

• A chance to stand out and take a step toward a successful future!

How will ACC x QPC 2025 run?

• Qualifier: online with proctoring, hosted on codeforces.com (details coming soon);

• Final round: top 32 teams advance to the on-site round in Almaty. Accommodation and meals will be fully provided by the organizers.

Registration is now open!

• Form: https://forms.gle/d7Gyg3FLuksaJKTS7

• Deadline: 4 august (inclusive)

• Before each stage, you’ll receive your login, password, and access link.

• To stay updated, make sure you’re subscribed to our Telegram-channel

Hi cheaters and people!

Hello, Codeforces!

I am very excited to invite you to our contest Codeforces Round 1037 (Div. 3), which starts on Jul/17/2025 17:35 (Moscow time). You will be given 7 problems and 2 hours and 15 minutes to solve them.

The problems were authored by me, __rose, Pishka12, Chalishkan and I_HATE_MD_DM to solve and alter them.

The round will be hosted by the rules of educational rounds (extended ICPC). Thus, all solutions will be judged on preliminary tests during the round, and after the round, there will be a 12-hour phase of open hacks. After the open hack phase, all accepted solutions will be rejudged on successful hacks. Also, note that there is no score distribution — rank will be determined by number of problems solved, followed by penalty; wrong submissions will incur the usual penalty of 10 minutes, following the rules of educational rounds.

Remember that only the trusted participants of the third division will be included in the official standings table. As it is written by link, this is a compulsory measure for combating unsporting behavior. To qualify as a trusted participant of the third division, you must:

• take part in at least five rated rounds (and solve at least one problem in each of them)
• do not have a point of 1900 or higher in the rating.

Regardless of whether you are a trusted participant of the third division or not, if your rating is less than 1600, then the round will be rated for you.

We would like to thank:

• Vladosiya for wonderful coordination.
• Away_in_the_heavens for help with problems.
• sstrong, Wansur for red testing.
• N29, dsolunov, daukah, parkky and ImDMka for orange testing.
• newhandIe, accord, Duukh and QazLon for purple tesing.
• itz_pabloo, APMAH, Dif1rent, MaGnsi0 thespace, I_LOVE_vinnipuh01 and Makha for blue testing.
• IceHydra, 1BR444H1M, Yozhik, NexTopper and VOP-Ansish for cyan testing.
• uropeltidae, KOI and D_D for green testing.
• abylaj-shymer-2026 for gray testing.
• MikeMirzayanov and KAN for the great platforms.
• Vinton Cerf, and Robert Kahn for inventing the internet.
• You for participating!

GL HF!

Editoral is out!:

Also I would like to show you the beauty of our country's nature with the stunning backdrop of tourist Peak (3965m)!

Hey everyone! Today, after another one of my runs, I started wondering: how do workouts before contests actually affect your thinking?

When you hit the gym, go for a run, or play football — you're burning glycogen. That’s a form of stored energy your body makes from carbs. It’s stored in your muscles and liver.

Muscle glycogen is used for movement.

Liver glycogen keeps your blood sugar stable and literally feeds your brain.

During physical activity, you burn both. Your muscles use their own fuel, and your liver starts dumping sugar into your blood to keep your brain from shutting down. So yeah — doing a CF round two hours after playing football is a terrible idea.

If you burned all your glycogen yesterday, didn’t eat well, and didn’t sleep enough — your brain the next day runs on fumes. You’ll feel it hard if you played football right before the round: you sit down to code, and your head’s just fog. Easy problems feel heavy, and on the hard ones you’re just staring like it’s your first time seeing a for loop.

Here are the simple rules I stick to:

1. No heavy physical activity the day before Forget the “let’s go kick a ball real quick.” You’ll just sit there in the contest with fish eyes, chasing bugs in your own code. Your body needs time to recover that energy.
2. Eat real food (not tea and cookies) Your body needs carbs — pasta, rice, potatoes, oatmeal. Don’t chug soda and snack on candy like it’s fuel. Slow carbs = stable energy through the whole contest.

That’s it. Sleep well, eat well, don’t fry your body the day before — and go solve at full power.

Good luck in your contests and olympiads! :)

P.S. I recently wrote a motivational/educational book where I shared my experience and dropped a bunch of practical advice — both for improvement and for getting real results.

You can find the book h-e-e-e-e-e-e-e-e-re

Hey everyone! This year, IOI 2025 will take place in Bolivia — super exciting! Who will be representing your country at this legendary competition?

Here's our team (Kazakhstan):

— Wansur (second time at IOI) (1 attempt left)

— ahyeon (second time at IOI) (0 attempt left)

— Away_in_the_heavens (first time at IOI) (2 attempts left)

— WansurMyKing667 (first time at IOI) (1 attempt left)

What about your team? Share it in the comments — would be really cool to see who’s going and maybe even spot some familiar names!

My friend Away_in_the_heavens sent me a screenshot that left me completely shocked.

I have never seen anything like this on the platform before:

The image shows the standings of today’s round.

For comparison, here's what standings typically looked like across 100 previous contests:

Of course, incidents of unfair play have happened before. However, judging by today’s round, the number of cheaters has increased tenfold, if not a hundredfold. And the reason is clear — the appearance of tools like ChatGPT o1 or ChatGPT mini-high-3, which are apparently capable of solving problems up to ~3000 rating in just a few minutes.

As a result, the round turns into a minigame for cheaters: who can type faster or debug ChatGPT's solution more efficiently.

In my opinion, the current state of affairs calls for action. Perhaps it's time to reconsider the rating system or implement new mechanisms to address such violations.

I’d love to hear the thoughts of both the Codeforces team and veteran users who have been on the platform for many years.

Hey everyone! I’m excited to share something important with you.

Over the past two years, I’ve walked a long road in competitive programming — through thousands of problems, hundreds of contests, ups and downs, burnout, and bouncing back. And now, I’ve written a book that captures all of that experience.

But this isn’t just a guide. It’s a motivational and educational book — for high school students, university students, and anyone who wants to grow stronger in olympiad programming. Inside, you’ll find:

the raw truth about burnout and how to deal with it,

real strategies for consistent growth,

a personal story — from the very first steps to winning gold,

and most importantly, ideas that will help you reach the top — and stay there.

This book is for everyone: beginners and advanced alike.

Download the PDF: https://drive.google.com/drive/folders/1NJ5Qx5ci7GrQeMKZhDakVHqaqg1CdNEg

I’ll be truly grateful if you read it and share your thoughts. This isn’t a textbook — it’s a conversation. From one olympiad programmer — to everyone walking the same path.

See you at the top of the rankings.

Where is the April fool contest? The contest was held every year until 2024, will it be this year?

Does anyone know why nor has deleted all his blogs? A lot of math blogs were deleted, we have lost a lot of tricks.

Good Day Codeforces!

Me, Wansur and Chalishkan are happy to invite you to take part in Codeforces Round 973 (Div. 2), which starts on Sep/20/2024 17:35 (Moscow time). You will be given 6 problems and 2 hours to solve them. One problem is divided into two subtasks.

The round will be rated for all participants with a rating lower than 2100.

The problems were authored by me, Wansur and Chalishkan to solve and alter them.

We would like to thank:

• FairyWinx for wonderful coordination.
• triple__a, sevlll777, bashkort, sstrong for red testing.
• Tima, dope, hopele555, Aldk, NaughtyMorzh, Issa, ahyeon, Nuris, Gamicrab for orange testing.
• NewLul, vsinitsynav, for purple tesing.
• xikvwl, Teeleu, Away_in_the_heavens, Quinx, Tangirkul, sabyr for blue testing.
• selenite, Shadibay for green testing.
• MikeMirzayanov and KAN for the great platforms.
• Vinton Cerf, and Robert Kahn for inventing the internet.
• You for participating!

Score Distribution: 500 — 750 — 1250 — 2000 — 2500 — (2000 + 2000)

Good luck!

UPD1: Congrats to the winners!

div. 2:

1. EmmaXII

2. hxano

3. Muelsyse_sep006

4. Hexagons

5. Trumling_hasnotime

div. 1 + div. 2:

1. maspy

2. arvindf232

3. Brovko

4. aryanc403

5. E869120

UPD2: The Editorial is out!

It is our team on EJOI 2024 4-th from left is me, 5-th from left is Wansur

We are also very glad that ICPC 2024 will be in Astana, and we wish all participants a good tour!