Lately, I’ve noticed I get stuck on problems that don’t follow any standard approach. The kind where you can’t rely on a known DS or algorithm and just have to figure something out on your own.

Most of these fall under constructive algorithms, math, or what people usually call ad hoc (even though CF doesn’t have that tag).

I’ve been trying to find a collection of such problems in the 2000–2400 range, ones that are based on creative construction, math reasoning, or just clever ideas that don’t come usually from standard known approaches.

You can drop your favorite problems or the challenging ones in the rating range and I would love to try. Some problems that i found challenging and liked:

2034E - Permutations Harmony

2162G - Beautiful Tree

1392E - Omkar and Duck

If you know a good resource for this, or have solved problems that fit this category, please share them in the comments. It’ll help me and others who are trying to get better at this type of problem.

Thanks.

Whenever I take part in a contest, I try not to check the common or friend standings until I’m done with the first 2–3 easier problems. It helps me stay focused and avoid panic. Usually, when I finish those problems, I feel good about my performance. No wrong submissions, solved them faster than before, and it feels like I’ve clearly improved compared to my past attempts.

But then I check the standings, and reality hits. I’m often sitting around rank 1500–2000, which feels very average. It makes me wonder, where are all these people coming from?

The funny part is with the friend standings. That feature is supposed to help, right? It shows you how people around your level are doing. For me, it usually just shows jiangly or some Candidate Master already solving the tough problem. But when I look at the global dashboard, I see 1500 or 2000 solves on that same problem. So on one side, most of my skilled friends are struggling with it, yet the problem has thousands of submissions already. The picture feels inconsistent, and honestly it’s a bit frustrating.

So now I’m left confused. Am I actually improving, but just too slowly compared to the rest of Codeforces? Or has the overall level of participants suddenly gone way up? Or is it simply the effect of LLM-based cheating making the solved counts look inflated?

That’s what’s been bothering me a lot lately. I just wanted to rant and also see if others feel the same.

Pardon for the weird title.

This blog is just meant to start a discussion and question the idea of adding problems like 2132D - From 1 to Infinity into contests.

Before stating my point: This blog is not meant to target or attack any problem setter. I'm just sharing my thoughts and confusion, hoping to start a healthy discussion.

In this problem, there are basically two parts to the solution:

1) Find the last number N whose digits all belong to the first K digits and then add the first remaining digits of N + 1. (This part is relatively easier and smaller.)

2) Find the sum of the sum of digits for all numbers from 1 to N.

Now, this second task is something you can literally find on Google with one quick search. Here’s one such source:

Sum of digits from 1 to N (GFG)

And that’s where my confusion starts. What’s the point of adding such tasks to a contest when the main part of the solution is already out there and participants are allowed to use it?

Does being good at CP also mean being good at Googling standard implementations and plugging them in? I get it when it’s about common stuff like finding cycles or diameter in a tree because those are well-known techniques. But here, when the “main juice” of the problem is easily available online, isn’t it kind of unfair to people who spend time implementing it themselves compared to those who just grab it from the internet? Of course, it’s not the fault of those who use code from the internet since it’s allowed during the contest, but it still feels a bit off from a fairness perspective.

And if the real goal of the problem was just to check if you can find N, then why not directly ask for N instead of also requiring the sum of the first K digits?

I’m just genuinely confused and raising a point here. Would love to hear what others especially setters think about including such problems in contests.

As an addicted contest participant, I would like to have more contest in a week , from 5th may to Today there has been only two contests, is there any reason for it?

It's a really unfair and sad gesture by Igor_Parfenov, author of latest Div2_992 round, Problem C was exact copy of problem : https://mirror.codeforces.com/contest/513/problem/B2

This is extremely unfair to the people who tried this problem for the first time. This also explains why so many people were able to do this problem despite it being good enough, that most of the experts in my friend-list couldn't do it.

My submission for contest problem 992C : 295640125

Exact same code submission for older version 592B2 : 295644907

Edit: I don't want to put allegations on the author of the contest, as it could be a highly improbable coincidence that he thought the exact some problem. This blog is just to highlight the fact that fairness of the contest was compromised.

people downvoting this blog cuz they got a good rank and now want the contest to not be unrated i can understand that some of you might have actually solved the problem during the contest. I am not fighting for the contest to be unrated, the sole purpose of this blog is to make sure such things do not happen again.

by downvoting this blog you do the work of suppressing the issue and if you do so how do you differentiate yourself from the people who try to compromise the fairness of the contest by any possible means.

Problem Link : 1995C - Squaring

I have tried to implement the float method from the editorial.

Editorial solution

I am using base 2 for log here. In the first code, I am calculating the difference of b[i-1] and b[i], tmp is the number of times log(2)=1 has to be added into b[i]. If b[i-1]-b[i]>0, We are adding it's ceil value to the total operations ( ops ) and also to b[i] itself.

However this solution gives wrong answer on test-case 2, my guess is my outputs are bigger than answer expected.

Note: I have removed input templates from codes to make them short, rest is intact. You can also refer to the submission links.

Code with wrong answer

#include "bits/stdc++.h"
using namespace std;

// ================================== Macros ======================================================
#define int long long int
#define double long double
#define uint unsigned long long
#define vi vector<int>
#define vb vector<bool>
#define vs vector<string>
#define vvi vector<vector<int>>
#define vvb vector<vector<bool>
#define vp vector<pair<int,int>>
#define pb push_back
#define el(a,v) for(auto& a : v)
#define fr(i,n) for(int i=0;i<n;i++)
#define rf(i,n) for(int i = (n)-1;i>=0;i++)
#define rep(i,a,n) for(int i=0;i<=(a);i++)
#define sz(v) = (int) v.size()
#define mxe(v) *max_element(v.begin(),v.end())
#define mne(v) *min_element(v.begin(),v.end())
#define srt(v) sort(v.begin(),v.end())
#define rev(v) sort(v.rbegin(),v.rend())
#define dbg(var) cout<<#var<<" = "<<var<<nl;
#define unq(v)  v.resize(distance(v.begin(), unique(v.begin(), v.end())))
#define nl "\n"
#define ws " "


const int  MOD=1e9+7; 
const int INF = INT64_MAX-4;
void solve() {
    int n;cin>>n;
    vector<int> v(n);
    int ops = 0;
    cin>>v;

    reverse(v.begin(),v.end());
    while(v.back()==1)v.pop_back();
    el(a,v){
        if(a==1){
            cout<<-1<<nl;
            return;
        }
    }
    reverse(v.begin(),v.end());
    // dbg(v);
    n=v.size();
    vector<double> b(n);

    fr(i,n){
        b[i] =log2(log2(v[i]));
    }

    // dbg(b);

    for(int i =1;i<n;i++){
        int tmp = max((double)0.0,ceil(b[i-1]-b[i]));
        b[i]+=tmp*log2(2);
        ops+=tmp;
    }
    cout<<ops<<nl;
}


int32_t main()
{
 
 ios_base::sync_with_stdio(false);
 cin.tie(NULL);

    int T = 1;
    cin >> T;
    while (T--)
    {
        solve();
    }
    return 0;
}

submission : 272991530

While this code works

#include "bits/stdc++.h"
using namespace std;

// ================================== Macros ======================================================
#define int long long int
#define double long double
#define uint unsigned long long
#define vi vector<int>
#define vb vector<bool>
#define vs vector<string>
#define vvi vector<vector<int>>
#define vvb vector<vector<bool>
#define vp vector<pair<int,int>>
#define pb push_back
#define el(a,v) for(auto& a : v)
#define fr(i,n) for(int i=0;i<n;i++)
#define rf(i,n) for(int i = (n)-1;i>=0;i++)
#define rep(i,a,n) for(int i=0;i<=(a);i++)
#define sz(v) = (int) v.size()
#define mxe(v) *max_element(v.begin(),v.end())
#define mne(v) *min_element(v.begin(),v.end())
#define srt(v) sort(v.begin(),v.end())
#define rev(v) sort(v.rbegin(),v.rend())
#define dbg(var) cout<<#var<<" = "<<var<<nl;
#define unq(v)  v.resize(distance(v.begin(), unique(v.begin(), v.end())))
#define nl "\n"
#define ws " "


const int  MOD=1e9+7; 
const int INF = INT64_MAX-4;
const double eps = 0.000000001;


void solve() {
    int n;cin>>n;
    vector<int> v(n);
    int ops = 0;
    cin>>v;

    reverse(v.begin(),v.end());
    while(v.back()==1)v.pop_back();
    el(a,v){
        if(a==1){
            cout<<-1<<nl;
            return;
        }
    }
    reverse(v.begin(),v.end());
    // dbg(v);
    n=v.size();
    vector<double> b(n);

    fr(i,n){
        b[i] =log2(log2(v[i]));
    }

    // dbg(b);

    for(int i =1;i<n;i++){
        double need = b[i-1]-b[i];
        if(need>eps){
            int tmp = 1 + (need-eps);
            b[i]+=tmp*log2(2);
            ops+=tmp;
        }
    }
    cout<<ops<<nl;
}


int32_t main()
{
 
 ios_base::sync_with_stdio(false);
 cin.tie(NULL);

    int T = 1;
    cin >> T;
    while (T--)
    {
        solve();
    }
    return 0;
}

submission : 272991530