Clever Code

Hello everyone! Just a update of Previous blog
If you’ve been using Clever Code, first of all — Thank you! You already know how helpful it is for analyzing and comparing Codeforces problem-solving history. But today, I’m thrilled to share some exciting news and a major update with you.

Recently, I logged into my Vercel dashboard just out of curiosity, expecting maybe one or two users here and there. But what I saw completely surprised me — Clever Code had over 2000 edge requests in the last 30 days, coming from multiple countries!

I genuinely didn't expect this kind of reach — it started as a personal tool, and now it's being used globally. So I thought: " If people are actually using and benefiting from this, I should definitely take it to the next level." And that’s exactly what I did.

What’s New?

1. Smart Recommendations

Now get problem suggestions tailored specifically to your skill level and areas of interest:

• Personalized Difficulty Range: By default, problems are recommended in the range of your rating ± 200, making sure they are neither too easy nor too hard.
• Weak Tag Filtering: Want to improve your weak areas? We've got you covered. The tool automatically detects tags where your performance is low or attempts are few, and recommends problems specifically from those tags so you can improve where it matters most.
• Clickable Tag Filters: All tags in the recommendations are now clickable. You can instantly filter problems based on your preferred topic like dp, graphs, binary search, etc.
• Unsolved Focus: The recommendations exclude problems you've already solved, helping you find fresh challenges every time.

2. Topic Mastery Graph

A complete visual of your strengths and weaknesses:

• Bar charts and graphs showing the number of problems solved by tag.
  
• Understand your strongest and weakest topics at a glance.
  
• Great for tracking long-term growth and planning targeted practice.
  

3. Codeforces Year Wrapped

Your personal CP journey, summarized beautifully:

• Total problems solved this year.
  
• Most active tags and top 5 highest-rated solved problem.
  
• A fun and shareable way to reflect on your progress!
  

Why Should You Care?

• Practice Smarter – Focus on your weak areas and get curated suggestions
• Track and Grow – Stay consistent and intentional with your improvement
• Motivate Yourself – Visualize progress and set new personal goals

I genuinely appreciate the love this little side project has received. If Clever Code is helping you in any way, feel free to drop feedback or share it with others.

Website link

Thank you again — and as always,
Happy Coding!
—Rishu Raj

Clever Code

Hello everyone!!

In the competitive programming world, one of the most effective ways to improve is by learning from others who have tackled similar challenges. Have you ever wondered how someone else, perhaps a mentor or a peer, has approached problems in a specific tag on Codeforces? To make this process easier and more insightful, I’ve developed a tool that allows you to compare your practice with that of others.

What Does This Tool Do?

This tool on my website lets you gain insights into how others have practiced by filtering problems they've solved by specific tags.

Here’s how it works:

• Enter a Codeforces ID: Start by entering the Codeforces handle of the user whose practice history you want to explore. This could be anyone—from a senior programmer to a peer whose problem-solving skills you admire.
• Filter by Tag: After entering the ID, you can filter the solved problems by specific tags. This lets you see all the problems that the user has solved within a particular tag, giving you a clear view of their practice focus.
• Compare with Your Practice: The best part? You can compare their solved problems with your own. The tool shows you how many and which of their solved problems you’ve already completed. This comparison helps you identify gaps in your practice and discover new problems to tackle that align with your learning goals.

Why Is This Useful?

• Strategic Learning: Focus on tags where you want to improve by seeing what problems others have solved in those areas.
• Broaden Your Practice: Discover new problems to solve that you might have overlooked, but that others in your network have already tackled.
• Benchmark Your Progress: Compare your problem-solving journey with others to see how your skills stack up and where you can continue to grow.

One more request

This is the base version of my project. I have more ideas that I’m working on to further improve it. If you find this project innovative, you’re welcome to contribute with your ideas as well.
Just fork our project on GitHub, implement your idea, and submit a pull request. We’ll be happy to consider your contributions.
Project link — Clever-code
Github — Link1 Link2

I’d love to hear your feedback on how this tool is helping you in your competitive programming journey.
Happy coding!
Thanking you.

Knapsack is a standard problem of dp (Dynamic programming) in which you need to pack a set of items, with given values and sizes (such as weights or volumes), into a container with a maximum capacity.

Identification

You have a container with a maximum capacity given. and given two arrays one array contains value and other containing weight/limits respectively. You have to find optimal value you can obtain within the bag's size limit. and we have a choice along arrays.

Knapsack can be divided into three sub problem.

1. Fractional Knapsack :- Easily solved using Greedy. In this problem you have given all thing that kanpsack have but you can use value in fraction means if you have given a weight $$$4kg$$$ with value of $$$10$$$ then we can use $$$1kg$$$ with a weight of $$$2.5$$$.

2. 0-1 Knapsack :- In this we can use one weight only one time also we can't break into pices. we have to use dp to find solution of this type of problem as we have a choice among array that we can choose it or not, so there must be overlapping subproblem so we have to store value that we had have already obtained.

3. Unbounded Knapsack:- In this type of problem we have no restriction on number of time a element, that means we can use a element any number of times to obtain it. But we can't break a piece into smaller pieces like in fractional knapsack. int this problem we have choice that we can choose a weight or not so this is also solved using DP.

0-1 Knapsack

Problem statment.

Given N items where each item has some weight and profit associated with it and also given a bag with capacity W,The task is to put the items into the bag such that the sum of profits associated with them is the maximum possible.

profit_array[]={1, 4, 2, 3, 5}, Weight_array[]={1, 8 , 5, 7, 9}, W(maximum capacity of bag)= 5.

Thinking process;

we can surely look that we have many choice in which we can get $$$5$$$ as weight like weight = $$$3+2$$$ in which we can get overall profit of $$$7+5$$$, if we choose $$$4+1$$$ we can get a value of $$$8+1$$$, like that.

we have to make choice on every element that we can choose it/pick it or not, here come the recursion in the figure in which we can write a code for a case then it will solve automatic.

we have two choice on every element that we can choose it or not.

Dry Run

lets describe base case and some restricted area

1. We are starting from $$$n-1$$$ index then if reach at $$$0th$$$ index then we have to return it

2. In every case when we are going to choose an index then we have to check that the index we hve choosen its weight is less than or equal to weight avaliable in bag.

Code With recursion

int rec(vector<int> &Weight, vector<int> &value, int i, int w)
{
    if (i == 0)
    {
        if (Weight[0] <= w)
            return value[0];
        return 0;
    }
    int pick = INT_MIN;
    if (Weight[i] <= w) pick = value[i] + rec(Weight, value, i - 1, w - Weight[i], dp);
    int not_pick = rec(Weight_arr, value, i - 1, w, dp);
    return max(pick, not_pick);
}
int knapsack0_1 (vector<int> weight, vector<int> value, int n, int maxWeight)
{
    return fn(weight, value, n - 1, maxWeight);
}

Time Complexity: O(2N)

Here come the Dp in figure in which we solve overlapping problem only one time and store it in a matrix.

For this we have to make a matrix of which store value at parameter which is changing like in this problem changing parameter is $$$index$$$ and $$$maxWeight$$$ so we have to make 2-D vector of size [index+1][maxWeight+1] and give a value that will never come in figure and we can easily identify it that this index id solved or not, let initilize with $$$-1$$$,

And in code we have to solve when dp[index][maxWeight]==-1 otherwise we can return dp[index][maxWeight] because in recursion if we reach at a place then it dosen't matter that from where we come.

Code with DP (Memoization Approach)

int fn(vector<int> &Weight, vector<int> &value, int i, int w, vector<vector<int>> &dp)
{
    if (i == 0)
    {
        if (Weight[0] <= w)
            return val[0];
        return 0;
    }
    if (dp[i][w] != -1)return dp[i][w];
    int pick = INT_MIN;
    if (Weight[i] <= w)
        pick = value[i] + fn(Weight, value, i - 1, w - Weight[i], dp);
    int notpick = fn(Weight, value, i - 1, w, dp);
    return dp[i][w] = max(pick, notpick);
}
int knapsack0_1 (vector<int> weight, vector<int> value, int n, int maxWeight)
{
    vector<vector<int>> dp(n + 1, vector<int>(maxWeight + 1, -1));
    return fn(weight, value, n - 1, maxWeight, dp);
}

Time Complexity: O(N * W).

Auxiliary Space: O(N),Stack space required for recursion

Auxiliary Space: O(N * W) + O(N). The use of a 2D array data structure for storing intermediate states and O(N) auxiliary stack space(ASS) has been used for recursion stack

we have many similar problem related to 0-1_knapsack like

1. Subset sum Problem (problem)

2. Partition Equal Subset Sum (Problem)

3. Target sum (Problem)

4. Partition array into two arrays to minimize sum difference (Problem)

5. Count subset sum (Problem)

You can solve many problem D and E on (Atcode DP sheet)

1446A - Рюкзак

Thanks.

GCD

• Gcd of two natural number $$$a$$$ and $$$b$$$ is defined as the largest number which is a divisor of both $$$a$$$ and $$$b$$$.

• Mathematically it is defined as: GCD(a, b)= max{k>0: (k/a) and (k/b)}.(Here $$$k$$$/$$$a$$$ means $$$k$$$ divides  $$$a$$$).

  Ways to find GCD

  Brute Force

• We can find gcd of two number by checking for all integer less than both number.

• We never use this approach to find gcd because this run in O(n) time complexity.

  Euclidean algorithm

• The Euclidean algorithm was formulated as follows: subtract the smaller number from the larger one until one of the numbers is zero. Indeed, if   $$$g$$$ divides   $$$a$$$ and   $$$b$$$, it also divides   $$$a-b$$$. On the other hand, if   $$$g$$$ divides   $$$a-b$$$ and   $$$b$$$, then it also divides   $$$a = b + (a-b)$$$, which means that the sets of the common divisors of   $$${a, b}$$$ and   $$${b,a-b}$$$ coincide.

• $$$a$$$ remains the larger number until   $$$b$$$ is subtracted from it at least   $$$\left\lfloor\frac{a}{b}\right\rfloor$$$ times. Therefore, to speed things up,   $$$a-b$$$ is substituted with $$$a-\left\lfloor\frac{a}{b}\right\rfloor b = a \bmod b$$$.

Implementation Using Code

1. Recursive Code

    int gcd (int a, int b) {
       if (b == 0)
        return a;
       else
     return gcd (b, a % b);
     }

This code run in O(log min(a, b)) Time complexity and in Recursive Stack space complexity.

2. Iterative Solution

    int gcd (int a, int b) {
      while (b) {
        a %= b;
        swap(a, b);
      }
      return a;
    }

This code run in O(log min(a, b)) Time complexity and But it take a constant space complexity as we have only define two variable only. This solution is is more faster than recursive one because of recursive call take more time than normal iteration.

Binary GCD

Above method works in time complexity of O(log n).we can more optimize this as we all know that The slow part of the normal algorithm are the modulo operations. Modulo operations, although we see them as   $$$O(1)$$$, are a lot slower than simpler operations like addition, subtraction or bitwise operations.. Here comes the Binary GCD in role.

This uses three very popular properties of GCD

• If both numbers are even, then we can factor out a two of both and compute the GCD of the remaining numbers:   $$$\gcd(2a, 2b) = 2 \gcd(a, b)$$$.
• If one of the numbers is even and the other one is odd, then we can remove the factor 2 from the even one:   $$$\gcd(2a, b) = \gcd(a, b)$$$ if   $$$b$$$ is odd.
• If both numbers are odd, then subtracting one number of the other one will not change the GCD:   $$$\gcd(a, b) = \gcd(b, a-b)$$$

Implementation Using Code

    int gcd(int a, int b) {
      if (!a || !b)
        return a | b;
      unsigned shift = __builtin_ctz(a | b);
      a >>= __builtin_ctz(a);
      do {
        b >>= __builtin_ctz(b);
        if (a > b)
            swap(a, b);
        b -= a;
      } while (b);
     return a << shift;
    }

Thanks.