#include <bits/stdc++.h>
using namespace std;
void generateresult(const string& s) {
    regex zero_regex("0+");
    sregex_token_iterator it(s.begin(), s.end(), zero_regex, -1);
    sregex_token_iterator end;
    vector<string> ans;
    
    for (; it != end; ++it) {
        ans.push_back(*it);
    }
    
    for (const auto& substr : ans) {
        cout << substr << endl;
    }
}

int main() {
    string s;
    getline(cin, s);
    generateresult(s);
    return 0;
}

Employee Details
GS✅

#include <iostream>
#include <vector>
#include <unordered_map>
#define int long long
using namespace std;

class Tracker {
private:
    int n;
    vector<int> rowXor;
    vector<int> colXor;
    vector<vector<int>> grid;

    void updateXor(int r, int c, int s, bool add) {
        if (add) {
            rowXor[r] ^= s;
            colXor[c] ^= s;
        } else {
            rowXor[r] ^= s;
            colXor[c] ^= s;
        }
    }
   
    int countAttackable() {
        int count = 0;
        for (int r = 1; r <= n; ++r) {
            for (int c = 1; c <= n; ++c) {
                if ((rowXor[r] ^ colXor[c]) > 0) {
                    ++count;
                }
            }
        }
        return count;
    }

public:
    Tracker(int N) : n(N), rowXor(N + 1, 0), colXor(N + 1, 0), grid(N + 1, vector<int>(N + 1, 0)) {}

    void addPanda(int r, int c, int s) {
        if (grid[r][c] > 0) {
            updateXor(r, c, grid[r][c], false);
        }
        grid[r][c] = s;
        updateXor(r, c, s, true);
    }

    void movePanda(int r1, int c1, int r2, int c2) {
        if (grid[r1][c1] > 0) {
            updateXor(r1, c1, grid[r1][c1], false);
            addPanda(r2, c2, grid[r1][c1]);
            grid[r1][c1] = 0;
        }
    }

    void processMove(int r1, int c1, int r2, int c2) {
        movePanda(r1, c1, r2, c2);
        cout << countAttackable() << endl;
    }
};

signed main() {
    int N, P, M;
    cin >> N >> P >> M;

    Tracker trk(N);

    for (int i = 0; i < P; ++i) {
        int r, c, s;
        cin >> r >> c >> s;
        trk.addPanda(r, c, s);
    }

    for (int i = 0; i < M; ++i) {
        int r1, c1, r2, c2;
        cin >> r1 >> c1 >> r2 >> c2;
        trk.processMove(r1, c1, r2, c2);
    }

    return 0;
}

Company Name: CloudSek
Role: SDE - Frontend

Batch eligible: 2025 and 2026 grads

Apply: https://www.cloudsek.com/openings?gh_jid=4435378004

Need IT Recruiter - Fresher (For Bangalore Location) ❤️💪💪

Skills/Requirements:
1. Bachelor’s degree in any discipline.
2. Strong communication skills and customer centric approach.
3. Ability to learn quickly and adapt to changing situation.
4. Basic computer skills and familiar with Ms Office
5. Problem Solving Attitude and willingness to take on new challenges.
6. Willingness to work in flexible hours.

Contact : HR Poornima

Date of Interview: 7th August – 9th August

Reporting Time:  10.00 AM

Join the Venue at Radar Technosoft India Pvt Ltd , 4th floor , Lisa Arcade, 5th main Road, Sector 6, HSR Layout, Pin code – 560102

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
using namespace std;
bool helper(const vector<int>& serverLoad, int maxOperations, int K) {
    vector<int> loads = serverLoad;
    int n = loads.size();

    for (int op = 0; op < maxOperations; ++op) {
        if (loads.empty()) return true; 
        int maxLoad = *max_element(loads.begin(), loads.end());
        int threshold = maxLoad / 2;
        vector<int> newLoads;
        for (int load : loads) {
            if (load <= threshold) {
                newLoads.push_back(load);
            }
        }

        loads = newLoads;
    }
    return loads.size() <= K;
}

int getMinToolRuns(const vector<int>& serverLoad, int K) {
    int left = 0;
    int right = serverLoad.size();

    int result = right;

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

        if (helper(serverLoad, mid, K)) {
            result = mid;
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }

    return result;
}

BNY ✅

#include <iostream>
#include <vector>
#include <string>
using namespace std;
const int MOD = 1000000007;
int solve(const string& s2, int n, int x, int y) {
    int s_length = s2.length();
    vector<char> s(s_length);
        for (int i = 0; i < s_length; i++) {
        s[i] = s2[i];
    }
    
    vector<int> prevSame(s_length, -1);
    int idxL = -1;
    int idxR = -1;
    
    for (int i = 0; i < s_length; i++) {
        if (s[i] == 'l') {
            prevSame[i] = idxL;
            idxL = i;
        } else {
            prevSame[i] = idxR;
            idxR = i;
        }
    }

    vector<vector<long>> dp(s_length + 1, vector<long>(n + 1, 0));
    dp[0][x] = 1;
    
    for (int i = 1; i <= s_length; i++) {
        for (int j = 0; j <= n; j++) {
            dp[i][j] = dp[i - 1][j];
            if (s[i - 1] == 'l') {
                if (j + 1 <= n) dp[i][j] += dp[i - 1][j + 1];
                if (j + 1 <= n && prevSame[i - 1] >= 0) dp[i][j] -= dp[prevSame[i - 1] + 1 - 1][j + 1];
            } else {
                if (j - 1 >= 0) dp[i][j] += dp[i - 1][j - 1];
                if (j - 1 >= 0 && prevSame[i - 1] >= 0) dp[i][j] -= dp[prevSame[i - 1] + 1 - 1][j - 1];
            }
            dp[i][j] = (dp[i][j] + MOD) % MOD;
        }
    }
    
    return static_cast<int>(dp[s_length][y]);
}

BNY ✅

private static int findFarthest(int[] arr) {
int N = arr.length;
Arrays.sort(arr);
if (Math.abs(arr[0]) > Math.abs(arr[N-1]))
return arr[0];
else
return arr[N-1];
}

FARTHEST TO ZERO✅
Zenoti

#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;

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

    int maxA = *max_element(A.begin(), A.end());
    vector<long long> dp(maxA + 1, 0);
    vector<long long> count(maxA + 1, 0);

    for (int i = 0; i < N; i++) {
        count[A[i]]++;
    }
    for (int g = maxA; g >= 1; g--) {
        long long cnt = 0;
        for (int mul = g; mul <= maxA; mul += g) {
            cnt = (cnt + dp[mul]) % MOD;
        }
        cnt = (cnt + (1LL << count[g]) - 1) % MOD;
        dp[g] = cnt;
    }

    for (int i = 0; i < N; i++) {
        cout << dp[A[i]] << " ";
    }
    cout << endl;

    return 0;
}

gcd and bob ✅
Winzo

#include <iostream>
#include <vector>
#include <cmath>
using namespace std;
vector<int> solve(int T, vector<long long>& test_cases) {
    vector<int> results;
    results.reserve(T);
    
    for (const auto& N : test_cases) {
        results.push_back(static_cast<int>(sqrt(N)));
    }
    
    return results;
}

FLIP FLOOP AND SWITCHES✅
Zenoti

#include<bits/stdc++.h>
using namespace std;
#define ll long long
ll solve(ll n)
{
    vector<ll>dp(n+10);
    dp[0]=1;
    dp[1]=2;
    dp[2]=5;
    ll mod=1e9+7;
    for(ll i=3;i<n;i++)
    {
        dp[i]=(2*dp[i-1]+dp[i-3])%mod;
    }
    return dp[n-1];
}
signed main()
{  
    ll n; cin>>n;
    cout<<solve(n);
    return 0;
}

Play with Tiles ✅
Winzo

#include<stdio.h>
#include<stdlib.h>
long long arr[100005];
int cmpfunc (const void * a, const void * b)
{
   return ( *(int *)a - *(int *)b );
}
int main()
{
long long n,c,i,j,ans=0,a,sum=0;
scanf("%lld %lld",&n,&c);
for(i=0;i<n;i++)
{scanf("%lld",arr+i);sum+=arr[i];}
qsort(arr,n,sizeof(long long),cmpfunc);

for(i=0;i<n-1;i++)
{
sum-=arr[i];
ans+=sum-(arr[i]*(n-1-i));
}
if(n>1){
a=n/2;
ans+=a*(a+1)*c;
a=(n-1)/2;
ans+=a*(a+1)*c;
}
printf("%lld",ans);
return 0;
}

The Strange Array ✅
Winzo

Bureau is hiring Engineering intern

For 2024, 2025, 2026 grads

Location: Bangalore

https://jobs.bureau.id/?ashby_jid=7d547bf9-e182-4fbc-b026-d92093fe757a

#include <iostream>
#include <vector>
using namespace std;
vector<vector<int>> findMatrix(const vector<vector<int>>& a) {
    int n = a.size();
    int m = a[0].size();
        vector<vector<int>> prefix(n, vector<int>(m, 0));
    vector<vector<int>> b(n, vector<int>(m, 0));
        for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            prefix[i][j] = a[i][j];
            if (i > 0) prefix[i][j] += prefix[i-1][j];
            if (j > 0) prefix[i][j] += prefix[i][j-1];
            if (i > 0 && j > 0) prefix[i][j] -= prefix[i-1][j-1];
        }
    }

    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            b[i][j] = prefix[i][j];
        }
    }
    
    return b;
}

Simple Matrix summation ✅