Swiggy is hiring for Associate Software Engineer.

If interested, fill the form: https://docs.google.com/forms/d/e/1FAIpQLSfz_6J2t7ES3KjCMex-_0_c12K74_ggpjGttFeuD8J5oZ80TA/viewform

from collections import Counter
def solve(n, s, k):
    freq = Counter(s)
    distinct_count = len(freq)
    if k > n:
        return -1
    if k == distinct_count:
        return 0
    operations = 0
    if k > distinct_count:
        operations = k - distinct_count
    else:
        extra = distinct_count - k
        freq_values = sorted(freq.values())
        operations = sum(freq_values[:extra])
    return operations

Distinct Character transformation ✅

import math
def solve(l, r):
    count = 0
    for x in range(l, r + 1):
        sqrt_floor = math.isqrt(x)
        if x % sqrt_floor == 0:
            count += 1
    return count

Lucky number ✅

Shellovation hiring Mobile / App Development Intern

2026/2027 batch passouts
38 k per month stipend

Apply Here : https://unstop.com/internships/mobile-app-developer-shellovation-private-limited-1270510?lb=riTZ96J&utm_medium=Share&utm_source=shortUrl

Marsh McLennan is hiring (only with referral)

Take referral on LinkedIn and apply!!

Company : Uber
Program: Uber She++ and UberSTAR Internship
Eligibility : 2027

Apply: https://flows.beamery.com/uber/apac-uber-she---2025-s_29svpsn

Complete details about eligibility

📌PayU is hiring!
Data Engineering Intern

Location: Mumbai, Bengaluru, Gurgaon
Qualification:
- A degree in Engineering, Statistics, Computer Science, Mathematics or other similar quantitative field from a premier institute
- Students in the 2nd / 3rd semester & final year of their Graduation/Post Graduation can apply for an internship

💻Apply Link: https://jobs.eu.lever.co/payu/ee2691f3-64c7-4251-9284-e91aa40b2932/

def ok(mid, N, M):
    count = 0
    for i in range(1, N + 1):
        count += min(M, mid // i)
    return count
def solve(N, M, K):
    low, high = 1, N * M
    while low < high:
        mid = (low + high) // 2
        if ok(mid, N, M) < K:
            low = mid + 1
        else:
            high = mid
    return low
N, M, K = map(int, input().split())
print(solve(N, M, K))

A lot to merge ✅
Media. Net

#include <iostream>
#include <vector>
using namespace std;
const int MOD = 1000000007;

struct node {
    int val;
    int lazy;
    node *left;
    node *right;

    node() {
        left = nullptr;
        right = nullptr;
        lazy = 0;
        val = 0;
    }
};

void build(node *&root, int s, int e) {
    root = new node();
    if (s == e) {
        root->val = 0;
    } else {
        int mid = (s + e) / 2;
        build(root->left, s, mid);
        build(root->right, mid + 1, e);
        root->val = root->left->val + root->right->val;
    }
}

void applyLazy(node* root, int s, int e) {
    if (root->lazy) {
        root->val = (e - s + 1) - root->val;
        if (s != e) {
            if (!root->left) root->left = new node();
            if (!root->right) root->right = new node();
            root->left->lazy ^= 1;
            root->right->lazy ^= 1;
        }
        root->lazy = 0;
    }
}

void update_range(node *root, int s, int e, int l, int r) {
    applyLazy(root, s, e);
    if (s > r || e < l) return;
    if (s >= l && e <= r) {
        root->lazy ^= 1;
        applyLazy(root, s, e);
        return;
    }
    int mid = (s + e) / 2;
    update_range(root->left, s, mid, l, r);
    update_range(root->right, mid + 1, e, l, r);
    root->val = root->left->val + root->right->val;
}

int query(node *root, int s, int e, int l, int r) {
    applyLazy(root, s, e);
    if (s > r || e < l) return 0;
    if (s >= l && e <= r) {
        return root->val;
    }
    int mid = (s + e) / 2;
    int leftQuery = query(root->left, s, mid, l, r);
    int rightQuery = query(root->right, mid + 1, e, l, r);
    return leftQuery + rightQuery;
}

int solve(int N, vector<vector<int>>& B) {
    node* root = nullptr;
    build(root, 0, N - 1);
    
    int sumQueries = 0;
    for (const auto& op : B) {
        int type = op[0];
        int l = op[1] - 1;
        int r = op[2] - 1;

        if (type == 0) {
            update_range(root, 0, N - 1, l, r);
        } else {
            sumQueries += query(root, 0, N - 1, l, r);
            sumQueries %= MOD;
        }
    }
    return sumQueries;
}

int main() {
    int N, Q;
    cin >> N >> Q;
    vector<vector<int>> B(Q, vector<int>(3));
    
    for (int i = 0; i < Q; ++i) {
        cin >> B[i][0] >> B[i][1] >> B[i][2];
    }

    int result = solve(N, B);
    cout << result << endl;

    return 0;
}

Mask updates
Media. Net✅

#include <bits/stdc++.h>
using namespace std;
void solve() {
    int T;
    cin >> T;
    while (T--) {
        int n, x;
        cin >> n >> x;
        vector<int> a(n);
        for (int i = 0; i < n; i++) {
            cin >> a[i];
        }
        vector<int> remainderCount(x, 0);
        for (int i = 0; i < n; i++) {
            remainderCount[a[i] % x]++;
        }
        int pairs = 0;
        pairs += remainderCount[0] / 2;
        for (int r = 1; r <= x / 2; r++) {
            if (r == x - r) { 
                pairs += remainderCount[r] / 2;
            } else {
                int minCount = min(remainderCount[r], remainderCount[x - r]);
                pairs += minCount;
                remainderCount[r] -= minCount;
                remainderCount[x - r] -= minCount;
            }
        }
        cout << pairs * 2 << endl;
    }
}

int main() {
    solve();
    return 0;
}

christmas celebration ✅

class Shop:
    def __init__(self):
        self.items = {}
    def create(self, X, Y):
        if X in self.items and self.items[X] > 0:
            return False
        else:
            self.items[X] = Y
            return True
    def place_order(self, X, Y, Z):
        if Y not in self.items or self.items[Y] < Z:
            return False
        else:
            self.items[Y] -= Z
            return True
    
    def balance(self):
        return sum(self.items.values())
def process_queries(queries):
    shop = Shop()
    result = []
    for query in queries:
        parts = query.split()
        command = parts[0]
        if command == "Create":
            X = int(parts[1])
            Y = int(parts[2])
            if shop.create(X, Y):
                result.append("Item Created successfully!")
            else:
                result.append("Couldn't create item!")
        elif command == "PlaceOrder":
            X = int(parts[1])
            Y = int(parts[2])
            Z = int(parts[3])
            if shop.place_order(X, Y, Z):
                result.append("Order placed successfully!")
            else:
                result.append("Couldn't place order!")
        elif command == "Balance":
            result.append(f"Total no of items in the shop is {shop.balance()}")
    return result

Shop inventory ✅

#include <bits/stdc++.h>
using namespace std;
#define ll long long
ll solve(ll n, ll m, vector<vector<string>>& c) {
    vector<vector<ll>> g1(n), g2(n);
    vector<ll> d1(n, 0), d2(n, 0);
    for (const auto& t : c) {
    if (t[0] == "x") {
    ll a = stoll(t[1]) - 1;
    ll b = stoll(t[2]) - 1;
    g1[a].push_back(b);
    d1[b]++;
    } else if (t[0] == "y") {
    ll a = stoll(t[1]) - 1;
    ll b = stoll(t[2]) - 1;
    g2[a].push_back(b);
    d2[b]++;
        }
    }

    auto ts = [&](vector<vector<ll>>& g, vector<ll>& d) -> vector<ll> {
    queue<ll> q;
    for (ll i = 0; i < n; i++) {
    if (d[i] == 0) q.push(i);
    }
    vector<ll> o;
    while (!q.empty()) {
    ll u = q.front();
    q.pop();
    o.push_back(u);
    for (ll v : g[u]) {
    d[v]--;
    if (d[v] == 0) q.push(v);
        }
        }
    return o.size() == n ? o : vector<ll>();
    };

    vector<ll> o1 = ts(g1, d1);
    vector<ll> o2 = ts(g2, d2);
    if (o1.empty() || o2.empty()) return -1;
    vector<ll> r(n, 0), cols(n, 0);
    for (ll i = 0; i < n; i++) {
    for (ll v : g1[o1[i]]) {
    r[v] = max(r[v], r[o1[i]] + 1);
    }
    }
    for (ll i = 0; i < n; i++) {
    for (ll v : g2[o2[i]]) {
    cols[v] = max(cols[v], cols[o2[i]] + 1);
        }
    }
    ll max_r = *max_element(r.begin(), r.end()) + 1;
    ll max_cols = *max_element(cols.begin(), cols.end()) + 1;
    return max_r + max_cols;
}
int main() {
    ll n, m;
    cin >> n >> m;
    vector<vector<string>> c(m, vector<string>(3));
    for (ll i = 0; i < m; i++) {
        cin >> c[i][0] >> c[i][1] >> c[i][2];
    }
    cout << solve(n, m, c) << endl;
    return 0;
}

Stay inside Circle ✅

📌Aminurmus Technology is hiring

Multiple Roles:
- SDE ( Intern/Fulltime)
- Reactjs Developer ( Intern/Fulltime)
- Dot net Developer (Intern/ Fulltime)
- Mern Stack Developer (Intern/Fulltime)
- Figma Developer Intern
- Fullstack Developer (Intern/Fulltime)
- Data Analysis
- Android Developer

Remote Opportunity

Batch: First year to Final Year

💻Apply: https://aminurmus.com/career

Use Referral Mail Id:
rupam.bernwal@aminurmus.com