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

int sum(int s, int e, vector<int>& v){
    unordered_map<int, int> prev;
    int res = 0, curr = 0;
    for (int i = s; i < e; i++) {
        curr += v[i];
        if (curr == 0)
            res++;

        if (prev.find(curr) != prev.end())
            res += (prev[curr]);
        prev[curr]++;
    }

    return res;
}

long getMedianSubarrays(vector<int>& s, int k){
    int n = s.size();
    vector<int> small(n, 0), gre(n, 0);
    for (int i = 0; i < n; i++) {
        small[i] = s[i] < s[k - 1];

        gre[i] = s[i] > s[k - 1];
    }
    vector<int> diff(n, 0);
    for (int i = 0; i < n; i++)
        diff[i] = small[i] - gre[i];
    long v1 = sum(0, n, diff);
    long v2 = sum(0, k - 1, diff);
    long v3 = sum(k, n, diff);
    return v1 - v2 - v3;
}

int main(){
    vector<int> arr={5, 3, 1, 4, 7, 7};
    int K = 4;
    cout << getMedianSubarrays(arr, K);
}

Sport week in Hackerland ✅

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

string findTheString(vector<vector<int>>& lcp) {
    int n = lcp.size();
    string s(n, 'a');
    set<char> used;
    
    auto validate = [&](int i, int j) {
        return lcp[i][j] == (int)min(s.length(), s.length());
    };
    
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (!validate(i, j)) return "Impossible";
            if (lcp[i][j] > 0) {
                s[j] = s[i];
                used.insert(s[j]);
            }
        }
    }
    
    if (used.size() > 26) return "Impossible";
    
    char next_char = 'a';
    for (char c : used) {
        if (next_char > 'z') return "Impossible";
        replace(s.begin(), s.end(), c, next_char);
        next_char++;
    }
    
    return s;
}

Tekion ✅

def photoAlbum(index_count, index, identity_count, identity):
    output = [0] * index_count
    for i in range(index_count):
        output[i] = identity[index[i]]
    return output

Schrodinger ✅

set<ll> primes(ll n)
{
    map<ll,ll>mp;
    set<ll>st;
    while (n % 2 == 0)
    {
        mp[2]++;
        n = n/2;
    }
    for (int i = 3; i <= sqrt(n); i = i + 2)
    {
        while (n % i == 0)
        {
            mp[i]++;
            n = n/i;
        }
    }
    if (n > 2)
        mp[n]++;
    for(auto it:mp){
        if(it.ss%2==1){
            st.insert(it.ff);
        }
    }
    return st;
}
ll getNonPerfectPairs(ll n, vl arr,ll k){
    map<set<ll>,ll>mp;
    ll cnt=0;
    for(int i=0;i<n;i++){
        set<ll>temp=primes(arr[i]);
        mp[temp]++;
    }
    vl ans;
    for(auto it:mp){
        ans.pb(it.ss);
    }
    sort(all(ans));
    priority_queue<ll>pq;
    for(int i=0;i<ans.size();i++){
        pq.push({ans[i]});
    }
    debug(ans);
    while(pq.size()>1){
        ll x=pq.top();
        pq.pop();
        ll y=pq.top();
        pq.pop();
        cnt++;
        if(x-1>0){
            pq.push(x-1);
        }
        if(y-1>0){
            pq.push(y-1);
        }
    }  
    ll temp=0;
    if(pq.size()>0){
        temp=pq.top();
    }
    debug(temp);
    ll mini=min(k,temp/2);
    cnt+=mini;
    cout<<cnt<<endl;
}

Schrodinger ✅

def updatePrefixSum(prefixSum, x1, y1, x2, y2, h):
    prefixSum[y1][x1] += h
    if x2 + 1 < len(prefixSum[0]):
        prefixSum[y1][x2 + 1] -= h
    if y2 + 1 < len(prefixSum):
        prefixSum[y2 + 1][x1] -= h
    if x2 + 1 < len(prefixSum[0]) and y2 + 1 < len(prefixSum):
        prefixSum[y2 + 1][x2 + 1] += h

def calculateTotalWater(prefixSum, x1, y1, x2, y2):
    total = 0
    for i in range(y1, y2 + 1):
        for j in range(x1, x2 + 1):
            if i > 0:
                prefixSum[i][j] += prefixSum[i - 1][j]
            if j > 0:
                prefixSum[i][j] += prefixSum[i][j - 1]
            if i > 0 and j > 0:
                prefixSum[i][j] -= prefixSum[i - 1][j - 1]
            total += prefixSum[i][j]
    return total

def rainInRectangle():
    n, m, k, q = map(int, input().split())
    prefixSum = [[0] * (n + 1) for _ in range(m + 1)]

    for _ in range(k):
        x1, y1, x2, y2, h = map(int, input().split())
        updatePrefixSum(prefixSum, x1 - 1, y1 - 1, x2 - 1, y2 - 1, h)

    results = []
    for _ in range(q):
        x1, y1, x2, y2 = map(int, input().split())
        result = calculateTotalWater(prefixSum, x1 - 1, y1 - 1, x2 - 1, y2 - 1)
        results.append(result)

    return results

Phonepe ✅

#include <iostream>
#include <string>
#include <algorithm>
#include <vector>

using namespace std;
bool cmp(const string& s, const string& t) {
    if (s.size() == t.size()) {
        return s < t;
    }
    return s.size() < t.size();
}
void SolvePuzzle(int n, vector<string>& str) {
    vector<string> ans;
    for (int i = 0; i < n; i++) {
        string s = str[i];
        int j = 0;
        while (j < s.size()) {
            string temp;
            while (j < s.size() && s[j] >= '0' && s[j] <= '9') {
                temp += s[j];
                j++;
            }
            if (!temp.empty()) {
                string frzi = "";
                string rest = "0";
                bool xx = false;
                for (int k = 0; k < temp.size(); k++) {
                    if (temp[k] == '0' && !xx) {
                        continue;
                    } else {
                        frzi += temp[k];
                        xx = true;
                    }
                }
                if (!xx) {
                    ans.push_back(rest);
                } else {
                    ans.push_back(frzi);
                }
            }
            j++;
        }
    }
    sort(ans.begin(), ans.end(), cmp);
    for (const auto& str : ans) {
        cout << str << endl;
    }
}

int main() {
    int n;
    cin >> n;
    vector<string> str(n);
    for (int i = 0; i < n; ++i) {
        cin >> str[i];
    }
    SolvePuzzle(n, str);
   
    return 0;
}

Amelia ✅
Tesco

def solution(laps):
    drivers = {}
    eliminated = []

    for lap in laps:
        slowest = float('-inf')
        toRemove = []

        for info in lap:
            name, time = info.split()
            time = int(time)
            
            drivers[name] = min(drivers.get(name, time), time)
            
            if drivers[name] > slowest:
                slowest = drivers[name]
                toRemove = [name]
            elif drivers[name] == slowest:
                toRemove.append(name)
        
        eliminated.extend(sorted(toRemove))
        for name in toRemove:
            del drivers[name]

    return eliminated

Databrick ✅

Batch : 2022/2023

https://forms.office.com/Pages/ResponsePage.aspx?id=x_VEPW5yzUWybD5Yzd6jdtDxHUngfbFJkaznH3TwOwpURUpZU1dIVlZGMFI1WktUQlFGV0Q4NFAxQi4u

Bank of America is hiring Software Engineer

For 2023, 2024 grads
Location: Mumbai

https://careers.bankofamerica.com/en-us/job-detail/24035851/software-engineer-i-b-gbs-ind-multiple-locations

Innovaccer is hiring SDET

For 2021, 2022, 2023 grads

Location: Noida

https://job-boards.greenhouse.io/innovaccer/jobs/7625511002

https://forms.office.com/Pages/ResponsePage.aspx?id=yXdC9f7aqkSFpHPVx8UkUE0Lt1Npr9tIvphtYFKvAWVUNjZPWkdLRDZBQUUwUE5TOU84WDBHUDdESS4u

Hitachi Systems India Pvt Ltd Hiring Database Administrator- Trainee

Face to Face Drive- Saturday, 21st Sept- Hitachi Systems India-Mumbai

Company Name: Mastercard
Role: Data Scientist Intern
Batch eligible: 2026 grads

Apply: https://mastercard.wd1.myworkdayjobs.com/en-US/Campus/job/Gurgaon-India/Data-Scientist-Intern--Summer-2025---India_R-228651