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

int prime[100001] = {0};
int k[100001] = {0};

void Sieve() {
    for (int i = 1; i < 100001; i++)
        k[i] = i;

    for (int i = 2; i < 100001; i++) {
        if (prime[i] == 0) {
            for (int j = i; j < 100001; j += i) {
                prime[j] = 1;
                while (k[j] % (i * i) == 0)
                    k[j] /= (i * i);
            }
        }
    }
}

int countPairs(int arr[], int n) {
    unordered_map<int, int> freq;
    for (int i = 0; i < n; i++) {
        freq[k[arr[i]]]++;
    }

    int sum = 0;
    for (auto i : freq) {
        sum += ((i.second - 1) * i.second) / 2;
    }

    return sum;
}

Square investment ✅
Angle one

#include <bits/stdc++.h>
using namespace std;
class SegmentTree {
public:
    int n;
    vector<vector<int>> tree; 
    SegmentTree(const vector<int>& salaries) {
        n = salaries.size();
        tree.resize(4 * n);
        build(0, 0, n - 1, salaries);
    }
    void build(int node, int start, int end, const vector<int>& salaries) {
        if (start == end) {
            tree[node] = {salaries[start]};
        } else {
            int mid = (start + end) / 2;
            build(2 * node + 1, start, mid, salaries);
            build(2 * node + 2, mid + 1, end, salaries);
       merge(tree[2 * node + 1].begin(), tree[2 * node + 1].end(),
                  tree[2 * node + 2].begin(), tree[2 * node + 2].end(),
                  back_inserter(tree[node]));
        }
    }
    int query(int node, int start, int end, int L, int R, int x) {
        if (start > R || end < L) {
            return 0;
        }
        if (start >= L && end <= R) {
            return tree[node].end() - upper_bound(tree[node].begin(), tree[node].end(), x);
        }
        int mid = (start + end) / 2;
        int left_result = query(2 * node + 1, start, mid, L, R, x);
        int right_result = query(2 * node + 2, mid + 1, end, L, R, x);
        return left_result + right_result;
    }
};

vector<int> solve(int N, vector<vector<int>> A, int Q, vector<vector<int>> queries) {
    vector<int> salaries(N);
    for (int i = 0; i < N; ++i) {
        salaries[i] = A[i][1];
    }
    SegmentTree segTree(salaries);
    vector<int> result;
    for (const auto& query : queries) {
        int L = query[0];
        int R = query[1];
        int x = query[2];
        L--; R--;
        result.push_back(segTree.query(0, 0, N - 1, L, R, x));
    }
    return result;
}

Tax payment ✅
angel one

#include <iostream>
#include <vector>
using namespace std;
int firstMomentAllGreen(int N, int T, const vector<vector<int>>& A) {
    for (int t = 0; t < T; ++t) {
        bool allGreen = true;
                for (int i = 0; i < N; ++i) {
            if (A[i][t] == 0) {
                allGreen = false;
                break;
            }
        }
        
        if (allGreen) {
            return t;
        }
    }
    
    return -1; 
}

Cognizant ✅

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


vector<vector<int>> solve(vector<int> &v){
    int n=v.size();
    vector<bool> found(n+1,false);
    int curr=1;
    vector<vector<int>> ans;   
    for(auto x:v){
        found[x]=true;
        vector<int> temp;
        if(found[curr]){
            while(curr<=n  && found[curr] ){
                temp.push_back(curr);
                curr++;
            }
        }
        else{
            temp.push_back(-1);
        }
        ans.push_back(temp);
    }
    return ans;

}


int32_t main(){
    int n;
    cin >> n;
    vector<int> v(n);
    for(int i = 0; i < n; i++){
       cin>>v[i];
    }
    vector<vector<int>> ans=solve(v);
    for(int i=0;i<ans.size();i++){
        for(int j=0;j<ans[i].size();j++){
            cout<<ans[i][j]<<" ";
        }
        cout<<endl;
    }
}

Amazon ✅

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>

vector<int> sortByAbsoluteDifference(vector<int> A, int M) {
    sort(A.begin(), A.end(), [M](int a, int b) {
        int diffA = abs(a - M);
        int diffB = abs(b - M);
        if (diffA == diffB) {
            return false;
        }
        return diffA < diffB;
    });
    return A;
}

Sunlife ✅

#include <iostream>
#include <vector>
using namespace std;

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

    int maxSum = -1;
    int maxMonthIndex = -1;
    for (int i = 0; i < N; i++) {
        int monthSum = 0;
        for (int j = 0; j < N; j++) {
            monthSum += expenses[i][j];
        }
        if (monthSum > maxSum) {
            maxSum = monthSum;
            maxMonthIndex = i;
        }
    }
    for (int j = 0; j < N; j++) {
        cout << expenses[maxMonthIndex][j];
        if (j < N - 1) {
            cout << " ";
        }
    }
    cout << endl;

    return 0;
}

Sunlife ✅

#include <bits/stdc++.h>
using namespace std;
int solve(vector<int>& A) {
    int n = A.size();
    sort(A.begin(), A.end());
    int b = A[n / 2];
    int a = 0;
    for (int i : A) {
        a += abs(i - b);
    }
    return a;
}

Tiger Analytics ✅

#include <bits/stdc++.h>
using namespace std;
bool feasible(int d, const vector<int>& u, int k) {
    int n = u.size();
    for (int i = 0; i < n; i++) {
        int r = u[i];
        int cnt = 0;
        for (int j = i + 1; j < n; j++) {
            if (u[j] - r > d) break;
            cnt++;
            if (cnt == k) return true;
        }
    }
    return false;
}

int minDist(int n, const vector<int>& o, int k) {
    set<int> s;
    for (int i = 1; i <= n; i++) s.insert(i);
    for (int x : o) s.erase(x);

    vector<int> u(s.begin(), s.end());
    int l = 0, r = u.back() - u[0];

    while (l < r) {
        int m = (l + r) / 2;
        if (feasible(m, u, k)) r = m;
        else l = m + 1;
    }
    return l;
}

Tiger Analytics✅

def S(s):
    a = "TRBDUS"
    b = {char: 0 for char in a}
    for char in s:
        if char in b:
            b[char] += 1
    return min(b[char] for char in a)

Tiger Analytics ✅

#include <bits/stdc++.h>
using namespace std;
string solve(string s) {
    string result;
    multiset<char> chars(s.begin(), s.end()); 
    while (!chars.empty()) {
        set<char> used;  
        for (auto it = chars.begin(); it != chars.end();) {
            if (used.empty() || *it > *used.rbegin()) {
                result += *it;
                used.insert(*it);  
                it = chars.erase(it);  
            } else {
                ++it;
            }
        }
    }
    return result;
}

Tiger Analytics ✅

def solve(n):
    b = 1
    m = 0
    while n + m != 2 * (n ^ m):
        mask = 2 * b - 1
        if ((n + m) & mask) != ((2 * (n ^ m)) & mask):
            m += b
        b *= 2
    return m

Arithmetic bitwise pairs ✅

United Airlines

#include <iostream>
#include <vector>
using namespace std;
bool isTarget(vector<vector<int>>& g, int a, int b, int i, int j) {
    int d[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
    for (int k = 0; k < 4; ++k) {
        int ni = i + d[k][0], nj = j + d[k][1];
        if (ni >= 0 && ni < a && nj >= 0 && nj < b) {
            if (g[ni][nj] <= g[i][j]) return false;
        }
    }
    return true;
}
void solve(vector<vector<int>>& g, int a, int b) {
    int ti = -1, tj = -1;
    for (int i = 0; i < a; ++i) {
        for (int j = 0; j < b; ++j) {
            if (isTarget(g, a, b, i, j)) {
                if (ti == -1 || i < ti || (i == ti && j < tj)) {
                    ti = i; tj = j;
                }
            }
        }
    }
    if (ti != -1) {
        g[ti][tj]++;
        while (isTarget(g, a, b, ti, tj)) {
            g[ti][tj]++;
        }
    }
}

void printGrid(vector<vector<int>>& g) {
    for (auto& row : g) {
        for (int v : row) {
            cout << v << " ";
        }
        cout << endl;
    }
}

int main() {
    int a, b;
    cin >> a >> b;
    vector<vector<int>> g(a, vector<int>(b));
    for (int i = 0; i < a; ++i) {
        for (int j = 0; j < b; ++j) {
            cin >> g[i][j];
        }
    }
    solve(g, a, b);
    printGrid(g);
    return 0;
}

Target position✅
Walmart

def ss(R, t, k):
    count = 0
    for M in range(1, k + 1):
        min_I = (R + M * (t - 1) + t - 1) // t
       
        if min_I <= k:
            max_I = k
            if min_I < 1:
                min_I = 1
            count += max(0, max_I - min_I + 1)
    return count
R, t, k = map(int, input().split())
print(ss(R, t, k))      

Car Ride ✅
Walmart

def ss(arr):
    total_sum = sum(arr)
    n = len(arr)
    a = set()
    a.add(0) 
    for num in arr:
        b = set()
        for s in a:
            b.add(s + num)
        a.update(b)
    return 0 in a
N = int(input())
arr = list(map(int, input().split()))
result = ss(arr)
print("true" if result else "false")

Negate subsequence
Walmart ✅

#include<bits/stdc++.h>
using namespace std;
int solve(int N, int M, vector<int>& P, vector<int>& W) {
    int wateredCount = 0;
    int i = 0;
    for (int j = 0; j < M && i < N; ++j) {
        int water = W[j];
        
        if (i < N - 1) {
            if (water >= P[i] + P[i + 1]) {
                wateredCount += 2; 
                P[i] = 0; 
                P[i + 1] = 0;
                i += 2;
            } else if (water >= P[i]) {
                wateredCount++;
                P[i] = 0; 
                i++; 
            } else if (water >= P[i + 1]) {
                wateredCount++;
                P[i + 1] = 0;
                i += 2; 
            } else {
                i++;
            }
        } else { 
            if (water >= P[i]) {
                wateredCount++;
                P[i] = 0; 
            }
            break; 
        }
    }
    return wateredCount; 
}

int main() {
    int N, M;
    cin >> N >> M; 
    vector<int> P(N);
    vector<int> W(M);
    
    for (int i = 0; i < N; ++i) {
        cin >> P[i]; 
    }
    
    for (int i = 0; i < M; ++i) {
        cin >> W[i]; 
    }

    int result = solve(N, M, P, W);
    cout << result << endl; 
    return 0;
}

Water Down✅