#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 ✅

public int minChargingSpeed(int[] evBatteries, int totalHours) {
        int left = 1;
        int right = getMax(evBatteries);
        while (left < right) {
            int mid = left + (right - left) / 2;
            if (canChargeAll(evBatteries, mid, totalHours)) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        return left;
    }

    private int getMax(int[] evBatteries) {
        int max = 0;
        for (int battery : evBatteries) {
            max = Math.max(max, battery);
        }
        return max;
    }

    private boolean canChargeAll(int[] evBatteries, int speed, int totalHours) {
        int hoursNeeded = 0;
        for (int battery : evBatteries) {
            hoursNeeded += (battery + speed - 1) / speed;
        }
        return hoursNeeded <= totalHours;
    }

Uber ✅

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

vector<vector<int> > SolveTower (int N, vector<int> a) {
   // Write your code here
   vector<vector<int> > ans;
   int done = N;
   priority_queue<int> pq;
   for(auto x: a){
      pq.push(x);
      vector<int> aux;
      while(!pq.empty() && pq.top() == done){
         aux.push_back(done);
         pq.pop();
         done--;
      }
      ans.push_back(aux);
   }
   sort(a.begin(), a.end());
   a.resize(unique(a.begin(), a.end()) - a.begin());
   assert(a.size() == N);
   return ans;
}

int main() {

    ios::sync_with_stdio(0);
    cin.tie(0);
    int N;
    cin >> N;
    assert(1 <= N && N <= 1e6);
    vector<int> a(N);
    for(int i_a = 0; i_a < N; i_a++)
    {
     cin >> a[i_a];
    }

    vector<vector<int> > out_;
    out_ = SolveTower(N, a);
    for(int i = 0; i < out_.size(); i++){
       for(int j = 0; j < out_[i].size(); j++){
          cout << out_[i][j] << " ";
       }
       cout << "\n";
    }
}

Uber ✅

public static String maskSensitiveInfo(String data) {
        if (isEmail(data)) {
            return maskEmail(data);
        } else if (isPhoneNumber(data)) {
            return maskPhoneNumber(data);
        }
        return data;
    }

    private static boolean isEmail(String data) {
        return data.matches("^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}$");
    }

    private static boolean isPhoneNumber(String data) {
        return data.matches("^[0-9().\\-+ ]{10,20}$");
    }

    private static String maskEmail(String email) {
        email = email.toLowerCase();
        String[] parts = email.split("@");
        String local = parts[0];
        String domain = parts[1];

        if (local.length() > 2) {
            local = local.charAt(0) + "*" + local.charAt(local.length() - 1);
        } else {
            local = local.charAt(0) + "*";
        }
        return local + "@" + domain;
    }

    private static String maskPhoneNumber(String phone) {
        phone = phone.replaceAll("[^0-9]", "");
        int len = phone.length();
        String maskedPhone = "";

        if (len == 10) {
            maskedPhone = "###-###-" + phone.substring(6);
        } else if (len == 11) {
            maskedPhone = "+#-###-###-" + phone.substring(7);
        } else if (len == 12) {
            maskedPhone = "+##-###-###-" + phone.substring(8);
        } else if (len == 13) {
            maskedPhone = "+###-###-###-" + phone.substring(9);
        }

        return maskedPhone;
    }

Protecting Personal Information ✅

int solve(int n)
{
    int ans = 0;
    for (int i = 1; i <= n; i *= 10)
    {
        int divider = i * 10;
        ans += (n / divider) * i +
               min(max(n % divider - i + 1, 0LL), i);
    }
    return ans;
}

int solve(vector<int> pass,int limit){
    sort(pass.begin(),pass.end());
   
    int ini=0;
    int fin=pass.size()-1;
    int count=0;
    while(ini<=fin){
        if(pass[ini]+pass[fin]<=limit){
            count++;
            ini++;
            fin--;
        }
        else{
            count++;
            fin--;
        }
    }
    return count;
}