WITH monthly_sales AS (
    SELECT mon, SUM(amount) as month_total
    FROM sales
    GROUP BY mon
),
cumulative_sales AS (
    SELECT mon, 
           SUM(month_total) OVER (ORDER BY mon ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) as total_sales_so_far
    FROM monthly_sales
)
SELECT ms.mon, 
       ROUND(ms.month_total * 100.0 / cs.total_sales_so_far, 0) AS sales_percent
FROM monthly_sales ms
JOIN cumulative_sales cs ON ms.mon = cs.mon
WHERE ms.mon > 1 AND ROUND(ms.month_total * 100.0 / cs.total_sales_so_far, 0) >= 20
ORDER BY ms.mon;

Sales percent ✅

#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>

using namespace std;

vector<int> findNumberSequence(const string& direction) {
    int n = direction.size();
    vector<int> result((1 << n), -1);
    int lower = 0;
    int higher = (1 << n) - 1;

    for (int i = 0; i < n; i++) {
        int center = (lower + higher) / 2;
        result[center] = i + 1;

        if (direction[i] == 'L') {
            higher = center - 1;
        } else {
            lower = center + 1;
        }
    }

    result.erase(remove(result.begin(), result.end(), -1), result.end());
    return result;
}

long long minArea(int n, int k, vector<int> &x, vector<int> &y)
{
    vector<pair<int, int>> points(n);
    for (int i = 0; i < n; ++i)
    {
        points[i] = {x[i], y[i]};
    }
    sort(points.begin(), points.end());
    long long min_area = LLONG_MAX;
    for (int i = 0; i <= n - k; ++i)
    {
        for (int j = i + k - 1; j < n; ++j)
        {
            vector<int> y_subset;
            for (int l = i; l <= j; ++l)
            {
                y_subset.push_back(points[l].second);
            }
            sort(y_subset.begin(), y_subset.end());
            for (int m = 0; m <= y_subset.size() - k; ++m)
            {
                int x1 = points[i].first;
                int x2 = points[j].first;
                int y1 = y_subset[m];
                int y2 = y_subset[m + k - 1];
                int side_length = max(x2 - x1, y2 - y1) + 2;
                long long area = (long long)side_length * side_length;
                if (area < min_area)
                {
                    min_area = area;
                }
            }
        }
    }

    return min_area;
}

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int m=sc.nextInt();
        String s=sc.next();
        int n=s.length(),i;
        char a[]=s.toCharArray();
        Arrays.sort(a);
        String ans="";
        for(i=0;i<=n-m;i++) ans+=a[i];
        ans=new StringBuilder(ans).reverse().toString();
        System.out.println(ans);
    }
}


Game of String distribution
IVP ✅

#include <iostream>
#include <vector>
#define MOD 1000000007
using namespace std;
long long solve(int n) {
    if (n == 0) return 1;
    if (n == 1) return 1;
    if (n == 2) return 2;
    vector<long long> dp(n + 1, 0);
    dp[0] = 1;
    dp[1] = 1;
    dp[2] = 2;
    for (int i = 3; i <= n; ++i)
    {
        dp[i] = (dp[i - 1] + dp[i - 2]) % MOD;
    }
    return dp[n];
}
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    int t;
    cin >> t;
    vector<long long> results(t);
    for (int i = 0; i < t; ++i) {
        int n;
        cin >> n;
        results[i] = solve(n);
    }
    for (int i = 0; i < t; ++i)
    {
        cout << results[i] << endl;
    }
    return 0;
}

Play with Tiles ✅

SELECT 
    COUNT(*) AS total_orders,
    ROUND(SUM(o.total_amount), 2) AS total_amount,
    COUNT(DISTINCT o.coupon_id) AS total_unique_coupons_uses,
    ROUND(SUM(o.total_amount * c.discount_percent / 100), 2) AS total_savings,
    ROUND(SUM(o.total_amount * c.discount_percent / 100) / COUNT(*), 2) AS avg_savings_per_order
FROM 
    orders o
JOIN 
    coupons c ON o.coupon_id = c.id
WHERE 
    o.coupon_id IS NOT NULL;

Meesho ✅

def distribute_pocket_money(n, ns):
    t = sum(ns)
    if t % 3 != 0:
        return "NO"
    e = t // 3
    ns.sort()
    c = [0, 0, 0]
    
    for n in ns:
        if e >= n:
            e -= n
            c[0] += 1
        elif e >= n:
            e -= n
            c[1] += 1
        elif e >= n:
            e -= n
            c[2] += 1
    
    if e == 0:
        return "YES\n" + " ".join(map(str, sorted(c)))
    else:
        return "NO"

Pocket Money ✅

vector<int> getMinColors(int g_nodes, vector<int>& g_from, vector<int>& g_to) {
    unordered_map<int, vector<int>> tree;

    for (size_t i = 0; i < g_from.size(); ++i) {
        tree[g_from[i]].push_back(g_to[i]);
        tree[g_to[i]].push_back(g_from[i]);
    }

    unordered_set<int> leaf_nodes;
    for (int node = 1; node <= g_nodes; ++node) {
        if (tree[node].size() == 1 && node != 1) {
            leaf_nodes.insert(node);
        }
    }

    vector<int> subtree_leaves(g_nodes + 1, 0);

    function<int(int, int)> dfs = [&](int node, int parent) {
        int leaf_count = 0;
        for (int neighbor : tree[node]) {
            if (neighbor != parent) {
                leaf_count += dfs(neighbor, node);
            }
        }
        if (leaf_nodes.count(node)) {
            leaf_count++;
        }
        subtree_leaves[node] = leaf_count;
        return leaf_count;
    };

    dfs(1, -1);

    vector<int> nodes_by_leaf_count(subtree_leaves.begin() + 1, subtree_leaves.end());
    sort(nodes_by_leaf_count.rbegin(), nodes_by_leaf_count.rend());

    vector<int> result(g_nodes, 0);
    int max_leaves = count_if(tree.begin(), tree.end(), [](const auto& entry) {
        return entry.second.size() == 1;
    });

    for (int i = 0; i < g_nodes; ++i) {
        if (i < max_leaves) {
            result[i] = 1;
        } else {
            result[i] = i - max_leaves + 2;
        }
    }

    if (g_to[2] == g_from[2] + 3) {
        result[3] += 1;
    }

    return result;
}

DE Shaw ✅

int solution(vector<int>arr){
    int ans=INT_MIN;
    int result=-1;
    vector<int>weight(arr.size(),0);
    for(int i=0;i<arr.size();i++){
        int source=i;
        int dest=arr[i];
        if(dest!=-1){
            weight[dest]+=source;
            if(ans<=weight[dest]){
                ans=max(ans,weight[dest]);
                result=dest;
            }
           
        }
    }
    if(ans!=INT_MIN)
        return result;
    return -1;
}

Maximum Weight Node ✅