def getUnallottedUsers(bids, totalShares):
    sorted_bids = sorted(bids, key=lambda x: (-x[2], x[3]))
    
    allocated_shares = {}
    unallotted_users = set()
    remaining_shares = totalShares
    
    for user_id, shares, price, timestamp in sorted_bids:
        if remaining_shares == 0:
            unallotted_users.add(user_id)
            continue
        
        allocated = min(shares, remaining_shares)
        allocated_shares[user_id] = allocated_shares.get(user_id, 0) + allocated
        remaining_shares -= allocated
        
        if allocated_shares[user_id] < shares:
            unallotted_users.add(user_id)
    
    fully_unallotted = [user_id for user_id, shares in allocated_shares.items() if shares == 0]
    fully_unallotted.extend([bid[0] for bid in bids if bid[0] not in allocated_shares])
    
    return sorted(set(fully_unallotted))

Bny ✅

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

const int MOD = 1e9 + 7;

bool canAchieve(vector<int>& A, vector<int>& B, vector<int>& C, int mid, long long& cost) {
    int N = A.size();
    long long curCost = 0;
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
    vector<int> curA = A;

    for (int i = 0; i < N; ++i) {
        if (curA[i] > mid) {
            pq.push({C[i], i});
        }
    }

    for (int i = 0; i < N; ++i) {
        while (curA[i] < mid) {
            if (pq.empty()) return false;
            auto [costIdx, idx] = pq.top(); pq.pop();
            if (curA[idx] <= mid || curA[idx] <= B[idx]) continue;

            int move = min(mid - curA[i], curA[idx] - max(B[idx], mid));
            curA[i] += move;
            curA[idx] -= move;
            curCost = (curCost + 1LL * move * costIdx) % MOD;

            if (curA[idx] > mid) {
                pq.push({C[idx], idx});
            }
        }
    }
    cost = curCost;
    return true;
}

pair<int, long long> findMaxMin(vector<int>& A, vector<int>& B, vector<int>& C) {
    int left = *min_element(B.begin(), B.end());
    int right = *max_element(A.begin(), A.end());
    int ans = left;
    long long minCost = LLONG_MAX;

    while (left <= right) {
        int mid = left + (right - left) / 2;
        long long cost = 0;

        if (canAchieve(A, B, C, mid, cost)) {
            ans = mid;
            minCost = cost;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }

    return {ans, minCost};
}

int main() {
    int T;
    cin >> T;

    while (T--) {
        int N;
        cin >> N;

        vector<int> A(N), B(N), C(N);
        for (int i = 0; i < N; ++i) {
            cin >> A[i];
        }

        for (int i = 0; i < N; ++i) {
            cin >> B[i];
        }

        for (int i = 0; i < N; ++i) {
            cin >> C[i];
        }

        pair<int, long long> result = findMaxMin(A, B, C);
        cout << "[" << result.first << ", " << result.second << "]" << endl;
    }

    return 0;
}


//queries and array ✅
Source : Hola

#include <iostream>
#include <vector>
#include <climits>
using namespace std;
const int MOD = 1e9 + 7;
class SegmentTree {
    vector<int> tree;
    vector<int> arr;
    int size;

    void build(int node, int start, int end) {
        if (start == end) {
            tree[node] = arr[start];
        } else {
            int mid = (start + end) / 2;
            build(2 * node, start, mid);
            build(2 * node + 1, mid + 1, end);
            tree[node] = min(tree[2 * node], tree[2 * node + 1]);
        }
    }

    int query(int node, int start, int end, int l, int r) {
        if (r < start || l > end) return INT_MAX;
        if (l <= start && end <= r) return tree[node];
        int mid = (start + end) / 2;
        return min(query(2 * node, start, mid, l, r), query(2 * node + 1, mid + 1, end, l, r));
    }

public:
    SegmentTree(const vector<int>& input) : arr(input), size(input.size()) {
        tree.resize(4 * size);
        build(1, 0, size - 1);
    }

    int query(int l, int r) {
        return query(1, 0, size - 1, l, r);
    }
};
long long maxProfitSubstring(const string& str, const vector<int>& values) {
    int n = str.size();
    vector<int> prefixSum(n + 1, 0);
    for (int i = 0; i < n; ++i) {
        prefixSum[i + 1] = prefixSum[i] + values[str[i] - 'a'];
    }
    vector<int> indexArray(n);
    for (int i = 0; i < n; ++i) {
        indexArray[i] = str[i] - 'a' + 1; 
    }
    SegmentTree segTree(indexArray);
    long long maxProfit = 0;
    for (int start = 0; start < n; ++start) {
        for (int end = start; end < n; ++end) {
            int minIndex = segTree.query(start, end);
            long long sum = prefixSum[end + 1] - prefixSum[start];
            long long profit = sum * minIndex;
            maxProfit = max(maxProfit, profit);
        }
    }

    return maxProfit % MOD;
}

Google
Maxium gain substring ✅

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

vector<int> tree;

void update(int start, int end, int parent, long long index){
   if (start > end) {
       return;
   }
   if (start == end) {
       tree[parent]++;
       return;
   }
   int mid = (start + end) / 2;
   if (index > mid) {
       update(mid + 1, end, 2 * parent + 2, index);
   }
   else {
       update(start, mid, 2 * parent + 1, index);
   }
   tree[parent] = tree[2 * parent + 1] + tree[2 * parent + 2];
}

int query(int start, int end, int parent, int qstart, int qend){
   if (qstart > end || qend < start) {
       return 0;
   }
   if (qstart <= start && qend >= end) {
       return tree[parent];
   }
   int mid = (start + end) / 2;
   int L = query(start, mid, 2 * parent + 1, qstart, qend);
   int R = query(mid + 1, end, 2 * parent + 2, qstart, qend);
   return L + R;
}

int solve(string &S){
   int n = S.size();
   tree.resize(4 * 2 * n + 1, 0);

   int shift = n;
   long long currSum = 0;
   long long cnt = 0;

   update(0, 2 * n, 0, 0 + shift);
  
   for (int i = 0; i < n; i++) {
       currSum += (S[i] == '1' ? 1 : -1);
     
       int lessThan = (currSum + shift) - 1;
       cnt += query(0, 2 * n, 0, 0, lessThan);

       update(0, 2 * n, 0, currSum + shift);
   }
   return cnt;
}

More Ones ✅

int t;
cin >> t;
while(t--){
  int n;
  const int mod = 1e9 + 7;
  cin >> n;
  string s;
  cin >> s;
  int dp[n+2];
  int last1 = -1 , last0 = -1;
  memset(dp,0,sizeof dp);
  dp[0] = 1;
  for(int i = 1;i<=n;i++){
  int x = (s[i-1] - '0');
  dp[i] = (dp[i-1] * 2)%mod;
  if(x){
  if(last1 != -1)
  dp[i] -= dp[last1 - 1];
  dp[i] = (dp[i] + mod)%mod;
  last1 = i;
  } else {
  if(last0 != -1){
  dp[i] -= dp[last0 - 1];
  dp[i] = (dp[i] + mod)%mod;
  } else {
  dp[i] -= 1;
  dp[i] = (dp[i] + mod)%mod;
  }
  last0 = i;
  }
  }
  if(last0==-1)
  {
   dp[n] -= 1;
   dp[n] += mod;
   dp[n] %= mod;
  }
  cout << dp[n]<<endl;
 
}

Distinct subsequence ✅

from itertools import product
from collections import defaultdict

def minimize_difference(N, A, K, operand):
   
    possible_values = []
    for a in A:
        values = set()
        for mask in range(1 << K):
            new_value = a
            for i in range(K):
                if mask & (1 << i):
                    new_value ^= operand[i]
            values.add(new_value)
        possible_values.append(sorted(values))

   
    all_values = []
    for i, values in enumerate(possible_values):
        for value in values:
            all_values.append((value, i))
    all_values.sort()

   
    count = defaultdict(int)
    left = 0
    min_range = float('inf')
    distinct_count = 0

    for right, (value, i) in enumerate(all_values):
        if count[i] == 0:
            distinct_count += 1
        count[i] += 1

        while distinct_count == N:
            min_range = min(min_range, all_values[right][0] - all_values[left][0])
            left_value, left_index = all_values[left]
            count[left_index] -= 1
            if count[left_index] == 0:
                distinct_count -= 1
            left += 1

    return min_range

Xor on Array ✅

MIN COST

GOOGLE ✅

Vahan hiring for below roles :

SDE Intern : 2025/2024 batches
SDE l : 2024/2023/2022 batches
SDE ll : 2022/2021 and before batches

Referral Form :
https://forms.gle/n8z8owcZZgHddoMt8

Codefeast is hiring for above roles :

2027 , 2026 , 2025 passout  batches eligible

Available for 6 months remote full time intern

Apply Form : https://docs.google.com/forms/d/e/1FAIpQLSfCEQRLNw1fxO2L1HyzT38R34Wk2rjkqL0FO7RZG88WC6QrFg/viewform

CBTS hiring for Associate Software Engineer

2024/2023/2022 passouts

Chennai / Bangalore / Gurgaon

https://recruiting.adp.com/srccar/public/RTI.home?c=2190231&d=altafiberJobs&rb=INDEED&r=5001058832806#/

embedUR systems : Fresher Drive B.E / B.Tech 2024 Batch

Salary Remuneration:
Offered CTC: Up to 8 Lakhs

Apply Form : http://forms.office.com/r/2BB7XFaqFj

int main() {
    int n, m;
    cin >> n >> m;
    vector<int> ratings(n);
    for (int i = 0; i < n; ++i) {
        cin >> ratings[i];
    }

    sort(ratings.begin(), ratings.end());

    vector<int> dp(n + 1, 0);
    int maxPlayers = 0;
    vector<vector<int>> dp2(m + 1, vector<int>(n + 1, 0));

    for (int i = 1; i <= m; ++i) {
        int left = 0;
        for (int right = 1; right <= n; ++right) {
            while (ratings[right - 1] - ratings[left] > 5) {
                ++left;
            }
            dp2[i][right] = max(dp2[i][right - 1], dp2[i - 1][left] + (right - left));
            maxPlayers = max(maxPlayers, dp2[i][right]);
        }
    }

    cout << maxPlayers << endl;

    return 0;
}

Uber ✅