Update 1.0 : The app is now live here.

Hello Codeforces,

So, I got some requests to predict the future ratings from my fellow coders and I simply didn't ignore it. I have worked a way through which a user can get their future ratings predicted by a piece of code. It was inspired by stefdasca's blog but since I am a bit weak in geometry and graphs so I decided to write a code for it (ignoring the fact that I am weak in coding too).

I have tested it rigourously for like 2-3 times and it did work as the results were satisfactory.

For Eg: The case of 1-gon's profile:

How to get your future ratings:

/*

You need your max_rating, current_rating and last 3 rounds rating changes. 

Enter the numbers in this order:

max_rating
current_rating 
ratings_change1 
ratings_change2 
ratings_change3 
lucky_number 


Sit back and get your rating prediction for as long as you are not satisfied with it.

*/


#include<bits/stdc++.h>
using namespace std;
// #pragma GCC optimize "trapv"


const int SEED_ACCEPTANCE_LT = 10;
const int MULT_ACCEPTANCE_LT = 301;
const int COUNT_PREV_CONTEST_DELTA = 3;
const int MULTIPLIER = 10;
const int UPP_LIM_FOR_MUL = 1000;
const int MAX_RATING_SO_FAR = 3797;
const int MY_FAV_REDUCING_AGENT = -3;

// 12
string title_on_rating[] = { 
    "Undated",
    "Noobie", 
    "Puppy-lil", "Spicy-list", "Eggs-puff",
    "Candyman-Disaster", "Maatsaab", "Entertainment-Mstrbator", 
    "Grandma's Sister", "Indigenous Gangbastad", "Legendary Grandma",
    "Insanity"
};

int ratings_list [] = {
    1, 
    1200, 1400, 1600, 
    1900, 2100, 2300, 
    2400, 2600, 3000, MAX_RATING_SO_FAR+1, 
    10000
};

class Rating {
public:
    int maxRating = 0, currRating = 0;
    int predictedRating = 0;
    int testCases = 1;
    int curr_rank = 0;

    vector<int> prev_rating_deltas;

    Rating (int r1, int r2) {
        maxRating = r1, currRating = r2;
        predictedRating = r2;
        curr_rank = (int)(upper_bound(ratings_list, ratings_list+12, currRating) - ratings_list);
    }

    void Get_PastRatings() {
        prev_rating_deltas.resize(COUNT_PREV_CONTEST_DELTA);
        cout << "Enter the ratings delta of past " << COUNT_PREV_CONTEST_DELTA << " contests:\n";
        bool rainboy_flag = false;
        for (int i = 0; i < COUNT_PREV_CONTEST_DELTA; i++) {
            cin >> prev_rating_deltas[i];
            rainboy_flag |= (abs(prev_rating_deltas[i]) >= 111);
        }
        if (rainboy_flag) cout << "\"rainboy delta is detected\"\n";
        sort(prev_rating_deltas.begin(), prev_rating_deltas.end());
        if (prev_rating_deltas[0] > 0) {
            prev_rating_deltas[0] = - prev_rating_deltas[0];
        }
        if (prev_rating_deltas[COUNT_PREV_CONTEST_DELTA-1] < 0) {
            prev_rating_deltas[COUNT_PREV_CONTEST_DELTA-1] = - prev_rating_deltas[COUNT_PREV_CONTEST_DELTA-1];
        }

    }

    void Set_TestCases() {
        cout << "Enter your lucky number duh\n";
        cin >> testCases;
        testCases = (testCases % 9) + 1;
        testCases *= MULTIPLIER;
    }

    void Prediction_Process() {
        vector<int> predicted_n_ratings(testCases);
        vector<long long> seeds(2);
        for (long long &seed: seeds) {
            seed = rand() % SEED_ACCEPTANCE_LT + 1;
        }
        while (seeds[0] == seeds[1]) {
            seeds[0] = rand() % SEED_ACCEPTANCE_LT + 1;
        }
        for (int tc = 0; tc < testCases; tc++) {

            int thisRating = 
            (int)(
                (seeds[0] * currRating + seeds[1] * maxRating) 
                    / 
                (seeds[0] + seeds[1])
            );

            vector<long long> multipliers_for_prev_rounds(COUNT_PREV_CONTEST_DELTA);
            for (long long &mult: multipliers_for_prev_rounds) {
                mult = rand() % UPP_LIM_FOR_MUL + 1;
            }

            sort(multipliers_for_prev_rounds.begin(), multipliers_for_prev_rounds.end());
            int medianPos = COUNT_PREV_CONTEST_DELTA / 2;
            for (int cc = 0; cc < COUNT_PREV_CONTEST_DELTA; cc++) {
                while (llabs(multipliers_for_prev_rounds[cc] - multipliers_for_prev_rounds[medianPos]) > MULT_ACCEPTANCE_LT) {
                    multipliers_for_prev_rounds[cc] = rand() % UPP_LIM_FOR_MUL + 1;
                }
                sort(multipliers_for_prev_rounds.begin(), multipliers_for_prev_rounds.end());
            }

            long long resultantRatingDelta = 0ll, multSum = 0ll;
            for (int position = 0; position < COUNT_PREV_CONTEST_DELTA; position++) {
                resultantRatingDelta += (multipliers_for_prev_rounds[position] * (long long) prev_rating_deltas[position]);
                multSum += multipliers_for_prev_rounds[position];
            }
            resultantRatingDelta /= multSum;
            predicted_n_ratings[tc] = thisRating + (int)resultantRatingDelta;
        }

        // nearest neighbour like
        sort(predicted_n_ratings.begin(), predicted_n_ratings.end());
        int median1 = testCases/2, median2 = testCases/2+1;
        int group1_mean = predicted_n_ratings[median1], group2_mean = predicted_n_ratings[median2];
        int group1_nos = 1, group2_nos = 1;
        long long sophisticated_sum1 = 0ll, sophisticated_sum2 = 0ll;

        for (int i = 0; i < testCases; i++) {
            if (abs(group1_mean - predicted_n_ratings[i]) < abs(group2_mean - predicted_n_ratings[i])) {
                if (abs(group1_mean - predicted_n_ratings[i]) < MULT_ACCEPTANCE_LT) {
                    group1_mean = (int)((long long)group1_mean + predicted_n_ratings[i]) / 2;
                    sophisticated_sum1 += predicted_n_ratings[i];
                    group1_nos++;
                }
            } else {
                if (abs(group2_mean - predicted_n_ratings[i]) < MULT_ACCEPTANCE_LT) {
                    group2_mean = (int)((long long)group2_mean + predicted_n_ratings[i]) / 2;
                    sophisticated_sum2 += predicted_n_ratings[i];
                    group2_nos++;
                }
            }
        }
        int KNN_like_mean = 
        (int) (
            ((long long)(group1_mean) * group1_nos + (long long) (group2_mean) * group2_nos) 
                    /
             (long long)(group2_nos + group1_nos)
        );
        int sophisticated_like_mean = 
        (int) (((sophisticated_sum1 / group1_nos + sophisticated_sum2 / group2_nos)) / 2
        );

        // cout << ".\n[KNN_like_mean: " << KNN_like_mean << "] & [sophisticated_like_mean: " << sophisticated_like_mean << "]\n";
        if (sophisticated_like_mean > KNN_like_mean) {
            swap(sophisticated_like_mean, KNN_like_mean);
        }
        sort(seeds.begin(), seeds.end());
        int KEN_MULTIPLIER = (rand() % MULT_ACCEPTANCE_LT) + MULTIPLIER;
        int XEN_MULTIPLIER = (rand() % KEN_MULTIPLIER) / 2 + 1;

        predictedRating = 
        (int)(
            ((XEN_MULTIPLIER * seeds[0] * sophisticated_like_mean) + (KEN_MULTIPLIER * seeds[1] * KNN_like_mean))
                /
            (((XEN_MULTIPLIER * seeds[0])) + (KEN_MULTIPLIER * seeds[1]))
        );
    }

    void Analysis() {
        cout 
        << "Your are currently " 
        << title_on_rating[curr_rank] 
        << ".\nA little bit of push and you're gonna make it to next level.\n" 
        << title_on_rating[curr_rank+1]
        << " is not too far from you. WH!GL!\n";
        // cout << curr_rank << ratings_list[curr_rank] << "\n";
    }

    void Challenge() {
        const int maxContestSoFar = 1539;
        string url_to_problem = "https://codeforces.com/problemset/problem/";
        cout << "\nA random challenge for you is to solve the following problem\n";
        cout << url_to_problem << rand() % maxContestSoFar + 1 << "/" << char('A' + (curr_rank + 1) / 2) << "\n";
        cout << "(If this link is invalid, the number you entered was not lucky...)\n";

    }
};

signed main() {
    // random random everywhere.
    srand(unsigned(time(0)));

    #ifdef LUCTIVUD
      // const auto start_time = std::chrono::high_resolution_clock::now();
      freopen("/home/luctivud/CPPractice/Zinput.txt", "r", stdin);
      freopen("/home/luctivud/CPPractice/Zoutput.txt", "w", stdout);
    #endif

    // enter currRating and maxRating
    int maxR, currR;
    cout << "Enter your *max rating* and *current rating* respectively\n";
    cin >> maxR >> currR;

    // validation of Rating
    if (maxR < currR) {
        cout << "Your max rating is less than your current rating.. What have you done, dumbass??\n";
        return 0;
    } else if (maxR > MAX_RATING_SO_FAR) {
        cout << "Unfortunately, No one is interested in your insane shit. :P\n";
    }

    // create rating object
    Rating userRating(maxR, currR);

    // get past ratings
    userRating.Get_PastRatings();

    // predict Ratings:
    userRating.Set_TestCases();
    userRating.Prediction_Process();

    // output ratings;
    cout << "\n.\n..\n...\n";
    cout << "Your *predicted rating* after next few rounds is: " << userRating.predictedRating;// << "\n";
    cout << "\n...\n..\n.\n";

    userRating.Analysis();
    userRating.Challenge();

    return 0;
}

I would encourage some participation from you guys and post in the comments what results you get. Also, if you want me to do a prediction myself I will try my best to be as random as I can.

If the code challenges you to solve a problem don't just run away. Happy coding.

P.S. This work is just for fun so don't ask me any proof for it. You can just trust the ratings as it is just a work of statistics and random function with a little bit of K-Means algorithm.

[Some self promotion: Follow me on github and star this repo if you find it helpful and all of the code related to this blog is in this separate repository.]

So, we are currently in a very problematic situation and everyone is in an argument with one another on what they should really call their existence.. Should it be a question or a problem? Well someone settled it off with a "bugaboo" thing and it's really apt because most of the time I'm really bugabooing my existence or thinking about different ways how I could cause bugaboos to others.

Next up, I got so obsessed with the progenitor of THE best blog that I searched for 0.0019 sec on google and found some of the old pics of my favourite LGM that I wanna share without his consent. Of course, my fav LGM had selfies with many of the celebtities by I disregarded them all and picked up the ones that existed for real.

Uh! If you still didn't guess who my fav LGM is, then he's on a TOUR to the top of Mariana Trench. Here's his cf profile, link in description:

Now I shall share the pics with the context.

When someone says, “I have a problem, What is your name?”.

When someone wanted a QnA session with him.

Watching the movie “problem mark” with boyfriend.

That one narcissist moment.

Someone introduces “bugaboo” and everyone is crazy about it.

Now, I would like to thank the person who supplied me with the courage to post this. He’s a man with Zero Haters and a huge lover of Um_ortized algorithms :

On a serious note: If “Question” and “Problem” with an external help of “Task” gave birth to “Bugaboo”, then “Solution” and “Answer” together will produce what? Time to tag Ari for the answer solution

This post is meant for humour, if someone got offended by some kind I take the full responsibility.

And for the ones who are gonna complain about wasted time, you should have not checked it, but check this out.

#RedditWoosh #I_like_problems #MoreOffense

Hello there, coders! I hope everyone is doing good.

When I started reading blogs and articles about different tips, tricks and issues faced by other coders on various sites I found some of the posts really informative and I collected them at a place by saving their links.

Only Yesterday my friend suggested me to make those links public as he found them useful too. The thing is that many a times we find some useful post and instead of saving it for future, we move on to the next one.

I have curated all of the posts which I found useful in the past few months and now I have made a GitHub repository in markdown containing them and I will maintain it and add new posts as I find.

This repo is basically a guide for beginners and intermediate level competitive programmers containing links on data structures and algorithms as well as different maths and ad-hoc problems.

You can find it here and star it or watch to get notified for future changes.

Overview of my repository:

• It contains the suggestions on time management and techniques one should adapt while starting cp.

• Along with it there are various tools which are quite useful in competitive programming.

• Various blogs and video tutorials which I found useful in understanding a concept.

• There are ladders and topic-wise curated problems for beginners and intermediate level programmers.
  
  

Check out my repo.

However, there are a lot of problems and blogs still to be added in there, so I would ask your suggestions in what to add and if you feel like you have a link which should be added in there for benefit of all, please add it in comment.

Thanks, happy coding !

Hello Codeforces community,

In this post I want to address the two major problems that I see with cf and provide a solution to them to my level of knowledge.

Cheating and Numerous Valueless posts and users floating on cf.

The first is related to cheating. Initially I believed that cheating can not be done in short contests but after being an active user for more than 4 months on codeforces & other sites, I've now understood that I was wrong. Cheating can happen in any contest be it Codechef-XYZ or Google-XYZ or CF-XYZ, but it for sure doesn't go unnoticed. A section of other users notices the cheating and if no strict action is taken on it, then majority of the same section gets encouraged to do the same and they make pairs or divide the tasks for the future contests. Hence, the fact that no action was taken on the offense acts as a propagator for others to do the same.

Solution :

< copy-pasted-from-my-comment >

I think I have an idea how these cheating activities can be reduced. Codeforces should have a feature to report plag in which we can link the profiles of all the users who are allegedly cheating in the previous contests.

A bot could then match the recent contests' solutions of all those users and if a similarity above a certain percentage is found, then the case should be forwarded to a moderator who can penalize them as per the rules.

Also anyone can also link the similar solutions like above in the feature to make things easier. This can be helpful during the hacking phase as it will then be permanently displayed in rankings of the contest too.

I believe users from the same institutes read solutions of their colleagues and friends after the contest and are more likely to detect plag, but then they make another fake profile and flood the posts which is quite annoying for someone who doesn’t care about all these.

I don’t know if cf has this thing but if it doesn’t, then the idea should be forwarded to Mike sir asap.

Coming to the second problem:

The useless posts and fake accounts. I was curious to find out how easier it could be to make an account on codeforces if I already have one and if I don't want to use my real email. Turns out it is pretty easy, anyone can do it in a matter of seconds — or even make a bot to do so.. I won't disclose how, because I don't want to promote it in any way, but it is a problem as it is. ((I along with many other users was using Amino App in the same way but last year Amino saw it as a problem and banished all the fake accounts before announcing their Amino+ version.))

After the fake account is created the user solves a recent question, and then posts their sh*t which is perfectly annoying for me.

Solution :

An email validator should be added to check if the emails are authentic, or less likely cf should validate the user by taking some sort of identity (just adding it but I don't suggest as it will be harder to maintain). Also cf can increase the count of problems a user needs to solve before posting to 10, maybe, or 15. For making a comment 1 is okay~

I understand that having more satisfied users is best for cf and the community but compromising the quality of Codeforces with it is just unbearable for me. I prefer not giving codechef long for the sole reason that mass cheating happens there and evryone asks for solution (so irritating) and stay away from codechef discuss at the time of long contest. Due to which I'm somewhat losing my interest in cc problems and contests. (By satisfied I meant that the users who solve the problem after cheating also feel satisfied and if they are caught and penalized they won't and maybe leave the platform. But believe me, they won't.)

I'm taking the case of India, because majority of users happen to be from India, myself included. It is not that only Indian cheats, but a proportion in every country's population have the same mindset and since the population of Indians on cf is also huge so they always end up being a target.

Also, I believe(pmw) that someone who loves something or is passionate about it won't cheat with their hobby. And I don't know the case about other countries but in mine, cp is not seen as a hobby by a majority but as a chance to get popular in their surrounding or to get a job pfft. So they do whatever they could to gain it. For them I would say — take cp as an opportunity and not as a chance (PM me and I would elaborate). And also they won't leave the community if penalized because of the same reason(chance).

Rest I hav no problems with cf or any other users. This was just my thought on it, and I myself didn't like the idea of making a post on it but in the end I did.

P.s. I don't want anyone to heavily criticize a country and its people based on the small proportion in it which is moron or whatever u wnt to call it. We are not taught to cheat in our schools. Cheating is simply a seed that grows like a weed(unnoticed) and turns into a poisonous plant and it can happen with anyone, anywhere. Instead we are taught to be maryada-purushottam like Shree Ram. So I req everyone to develop a pious character like Shree Ram and discourage what's wrong. Jai Shree Ram.

Happy Coding!