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;
}

We are inviting applications at GENPACT for the role of Management Trainee.

Skill Set : Record to Report, RTR, R2R.

• Location : Hyderabad
• Shifts : US
• Eligibility Criteria :
• CA (2024 batch) Freshers.
• Notice period : IMMEDIATE JOINERS, 30 Days.

Interested candidates can share their updated CV to me at diksha.prakash@genpact.com

• Full name :
• Current Profile :
• Current Company :
• Current designation :
• Current CTC :
• Expected CTC :
• Current location :
• Notice period :

#include <bits/stdc++.h>
using namespace std;
using namespace std;
int maxCoins( vector<int> a, vector<int> b)

{
    int N = a.size(), M = b.size();
    vector<int> flag(2, 0);
    int i = 0, j = 0;
    while (i < N && j < M)
    {
        if (a[i] < b[j])
            flag[0] += a[i++];
        else if (a[i] > b[j])
            flag[1] += b[j++];
        else
        {
            int v = a[i], count_a = 0, count_b = 0;
            while (i < N && a[i] == v)
                count_a++, i++;
            while (j < M && b[j] == v)
                count_b++, j++;
            int r0 = max(flag[0] + count_a * v, flag[1] + (count_a + count_b - 1) * v);
            int r1 = max(flag[1] + count_b * v, flag[0] + (count_a + count_b - 1) * v);
            if (count_a > 1 && count_b > 1)
            {
                r0 = max(r0, flag[0] + (count_a + count_b - 2) * v);
                r1 = max(r1, flag[1] + (count_a + count_b - 2) * v);
            }
            flag[0] = r0;
            flag[1] = r1;
        }
    }
    while (i < N)
        flag[0] += a[i++];
    while (j < M)
        flag[1] += b[j++];
    return max(flag[0], flag[1]);
}

int solve(vector<int> &A, vector<int> &B)
{
    int n = A.size();
    int m = B.size();
    int ans = 0;
    int i = 0, j = 0;
    bool flag = false;
    if (is_sorted(A.begin(), A.end()) && is_sorted(B.begin(), B.end()))
    {
        flag = true;
    }
    else
    {
        reverse(B.begin(), B.end());
        reverse(A.begin(), A.end());
    }

    return maxCoins(A,B);
}

Cave Coin Collection ✅

#include<bits/stdc++.h>
#define ll long long
using namespace std;
ll solve(vector<ll>&a,vector<ll>&b,ll n,ll m)
{
    ll ans=0;
    ll s1=0,s2=0;
    ll i=0,j=0;
    while(i<n and j<m)
    {
        if(a[i]<b[j]) s1+=a[i++];
        else if(a[i]>b[j]) s2+=b[j++];
        else
        {
            ans+=max(s1,s2)+a[i];
            i++;
            j++;
            s1=0;
            s2=0;
        }
    }
    while(i<n) s1+=a[i++];
    while(j<m) s2+=b[j++];
    return max(s1,s2)+ans;
}
signed main()
{
    ll n; cin>>n;
    vector<ll>a(n);
    for(ll i=0;i<n;i++) cin>>a[i];
    ll m; cin>>m;
    vector<ll>b(m);
    for(ll i=0;i<n;i++) cin>>b[i];
    cout<<solve(a,b,n,m);
}

Letter Candles ✅

int solve(vector<vector<int>>& grid) {
        int n=grid.size(),m=grid[0].size();
        int dirx[4]={-1,1,0,0};
        int diry[4]={0,0,-1,1};
        queue<pair<int,int>> q;
        int cnt=0,cnt2=0;
        vector<vector<int>> vis(n,vector<int>(m,-1));
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(grid[i][j]==2){
                    q.push({i,j});
                    vis[i][j]=1;
                    cnt2++;
                }else if(grid[i][j]==1){
                     cnt++;
                }
            }
        }
       
        int len=0;
        while(q.size()){
           
            int sz=q.size();
            if(cnt==0) return len;
            for(int l=0;l<sz;l++){
               
               
                pair<int,int> p1=q.front();
                q.pop();
                int i=p1.first,j=p1.second;
               
               
                for(int k=0;k<4;k++){
                    int x=i+dirx[k];
                    int y=j+diry[k];
                   
                    if(x>=0 and x<n and y>=0 and y<m and vis[x][y]==-1 and grid[x][y]==1){
                        q.push({x,y});
                        vis[x][y]=1;
                        cnt--;
                    }  
                }  
            }
           
            len++;
        }
        if(cnt>0) return -1;
        return 0;
    }
int main() {
 
  int n,m;
  cin>>n>>m;
  vector<vector<int>> v(n,vector<int>(m));
  for(int i=0;i<n;i++)
  for(int j=0;j<m;j++)
     cin>>v[i][j];
    
  cout<<solve(v);    
 
 
    }

Virus Spread ✅

#include <bits/stdc++.h>
using namespace std;
#define MAXN 30005
vector<int> adj[MAXN];
int value[MAXN];
int xor_from_root[MAXN];
bool visited[MAXN];
void dfs(int node, int xor_val) {
    visited[node] = true;
    xor_from_root[node] = xor_val ^ value[node];
    
    for (int neighbor : adj[node]) {
        if (!visited[neighbor]) {
            dfs(neighbor, xor_from_root[node]);
        }
    }
}
void solve(int N, int Q, vector<int>& values, vector<pair<int, int>>& edges, vector<tuple<int, int, int>>& queries) {
    for (int i = 1; i <= N; ++i) {
        value[i] = values[i - 1];
    }
    
    for (auto& edge : edges) {
        int a, b;
        tie(a, b) = edge;
        adj[a].push_back(b);
        adj[b].push_back(a);
    }
    
    memset(visited, false, sizeof(visited));
    dfs(1, 0);
    
    for (auto& query : queries) {
        int u, v, k;
        tie(u, v, k) = query;
        
        int path_xor = xor_from_root[u] ^ xor_from_root[v];
        bool found = false;

        if (path_xor == k) {
            found = true;
        } else {
            for (int i = 1; i <= N; ++i) {
                if ((xor_from_root[u] ^ xor_from_root[v] ^ value[i]) == k) {
                    found = true;
                    break;
                }
            }
        }

        if (found) {
            cout << "YES" << endl;
        } else {
            cout << "NO" << endl;
        }
    }
}
int main() {
    int N, Q;
    cin >> N >> Q;
    
    vector<int> values(N);
    for (int i = 0; i < N; ++i) {
        cin >> values[i];
    }
    
    vector<pair<int, int>> edges(N - 1);
    for (int i = 0; i < N - 1; ++i) {
        int a, b;
        cin >> a >> b;
        edges[i] = {a, b};
    }
    
    vector<tuple<int, int, int>> queries(Q);
    for (int i = 0; i < Q; ++i) {
        int u, v, k;
        cin >> u >> v >> k;
        queries[i] = {u, v, k};
    }
    
    solve(N, Q, values, edges, queries);
    
    return 0;
}

XOR Tree ✅

Salesforce hiring for below roles :

AMTS role :

Btech 2024 grads with 7 CGPA and above



Apply Here for Referral :
https://forms.gle/D4MMFK6tY4jB8QCu8

Wissen Technology is hiring for Java Developer

Eligibility : 2024 passouts , CS/IT Btech/ Mtech , 7.5 CGPA or higher

Send your resume for referral to :
abhay.tripathi@wissen.com
Or
trupthi.shetty@wissen.com