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

int main() {
    int n;
    cin >> n;
    vector<int> numbers(n);
    map<int, int> frequency;

    for (int i = 0; i < n; i++) {
        cin >> numbers[i];
        frequency[numbers[i]]++;
    }

    bool isBalanced = true;

    for (auto &entry : frequency) {
        int a = entry.first;
        int b = -entry.first;

        if (frequency[a] != frequency[b]) {
            isBalanced = false;
            break;
        }
    }

    if (isBalanced) {
        cout << 1;
    } else {
        cout << 0;
    }

    return 0;
}

Balance Array
Amazon ✅

Company Name: Siemens-Healthineers

Role: Graduate Engineer Trainee

Batch eligible: 2022 and 2023 grads

Apply: https://bit.ly/3RBuEB9

#include<bits/stdc++.h>
using namespace std;
#define ll long long
int dp[100001];
int solve(int n,vector<int>& ar,int ci){
    if(ci>=n) return INT_MAX;
    if(ci==n-1){
        return 0;
    }
    if(dp[ci]!=-1) return dp[ci];
    int a=INT_MAX,b=INT_MAX,c=INT_MAX;
    if(ci+1<n){
        int a1=0;
        a1+=abs(ar[ci]-ar[ci+1])+solve(n,ar,ci+1);
        a=min(a1,a);
    }
    if(ci+2<n){
        int b1=0;
        b1+=abs(ar[ci]-ar[ci+2])+solve(n,ar,ci+2);
        b=min(b1,b);
    }
    if(ci+3<n){
        int c1=0;
        c1+=abs(ar[ci]-ar[ci+3])+solve(n,ar,ci+3);
        c=min(c1,c);
    }
    return dp[ci]=min(a,min(b,c));
}
int main(){
    int n;
    cin>>n;
    vector<int>ar;
    for(int i=0;i<n;i++){
        int a;
        cin>>a;
        ar.push_back(a);
    }
    if(n==1) return ar[0];
    memset(dp,-1,sizeof(dp));
    cout<<solve(n,ar,0);
}

Jump 3
Amazon ✅

int main(){
    int n;
    cin>>n;
    vector<int>ar;
    for(int i=0;i<n;i++){
        int a;
        cin>>a;
        ar.push_back(a);
    }
    int ans=0;
    for(int i=0;i<n;i++){
        for(int j=i+1;j<n;j++){
            int x=__gcd(ar[i],ar[j]);
            int y=(ar[i]*ar[j])/x;
            if((y-x)==0) ans++;
        }
    }
    cout<<ans;
}


Null GL pairs✅

#include <iostream>
using namespace std;

int calculateCombinations(int totalSum, int maxNumber) {
    int count = 0;
    for (int i = 1; i <= maxNumber; i++) {
        for (int j = 1; j <= maxNumber; j++) {
            int thirdNumber = totalSum - i - j;
            if (thirdNumber <= maxNumber && thirdNumber > 0 && thirdNumber <= maxNumber) {
                count++;
            }
        }
    }
    return count;
}

int main() {
    int sum, maxNum;
    cin >> sum >> maxNum;
    cout << calculateCombinations(sum, maxNum);
    return 0;
}

Distributed Car toy ✅

Tomorrow anyone give Google OA will share codes

Also Share this group with college mates

New Shelf Amazon solution

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

long long int calculateInverse(long long int number, long long int modulus) {
    long long int modulus0 = modulus;
    long long int resultY = 0, resultX = 1;

    if (modulus == 1)
        return 0;

    while (number > 1) {
        long long int quotient = number / modulus;
        long long int temp = modulus;

        modulus = number % modulus;
        number = temp;
        temp = resultY;

        resultY = resultX - quotient * resultY;
        resultX = temp;
    }

    if (resultX < 0)
        resultX += modulus0;

    return resultX;
}

long long calculateUniqueCount(vector<long long> &numbers) {
    vector<long long> uniqueNumbers;
    for (auto &num : numbers) {
        auto it = lower_bound(uniqueNumbers.begin(), uniqueNumbers.end(), num);
        if (it == uniqueNumbers.end())
            uniqueNumbers.push_back(num);
        else
            *it = num;
    }
    return uniqueNumbers.size();
}

int main() {
    long long int numElements;
    cin >> numElements;
    vector<long long> inputNumbers(numElements);
    for (int i = 0; i < numElements; i++)
        cin >> inputNumbers[i];

    long long uniqueCount = calculateUniqueCount(inputNumbers);
    int modulusM = (int)(1e6 + 7);
    cout << calculateInverse(uniqueCount, modulusM);

    return 0;
}

#include <iostream>
using namespace std;

int calculateDigitSum(int number) {
    int digitSum = 0;

    while (number > 0 || digitSum > 9) {
        if (number == 0) {
            number = digitSum;
            digitSum = 0;
        }
        digitSum += number % 10;
        number /= 10;
    }
    return digitSum;
}

int main() {
    long long int inputNumber;
    cin >> inputNumber;
    cout << 1LL * inputNumber * calculateDigitSum(inputNumber);

    return 0;
}

Elia and number

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

int alphaBitwise(vector<int>& A) {
    int N = A.size();
    int result = 0;

    for (int i = 0; i < 32; i++) {
        int count = 0;
        for (int num : A) {
            if ((num >> i) & 1) {
                count++;
            }
        }
        if (count > N / 2) {
            result |= (1 << i);
        }
    }

    return result;
}

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

    int alpha = alphaBitwise(A);
    cout << alpha << endl;

    return 0;
}

Alpha bitwise✅

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



int main() {
 
  int n;
  cin>>n;
 
  cout<<(n*(n-1)) - n/2 ;

}

Gcd and lcm ✅

int calculateMaxLength(vector<int> &values) {
    vector<int> longestIncreasingSubsequence;
    int currentIndex = 1, size = values.size();
    longestIncreasingSubsequence.push_back(values[0]);

    while (currentIndex < size) {
        if (values[currentIndex] < longestIncreasingSubsequence.back()) {
            if (currentIndex == size - 1 || values[currentIndex] + longestIncreasingSubsequence.back() <= values[currentIndex + 1]) {
                longestIncreasingSubsequence.back() += values[currentIndex];
                currentIndex++;
            } else {
                values[currentIndex + 1] += values[currentIndex];
                currentIndex++;
            }
        } else {
            longestIncreasingSubsequence.push_back(values[currentIndex]);
            currentIndex++;
        }
    }

    return longestIncreasingSubsequence.size();
}

Non Decreasing Array ✅

#include <iostream>
#include <string>
#include <vector>
#include <set>

using namespace std;

void generate_strings(vector<string>& strings, string prefix, int remaining) {
    if (remaining == 0) {
        strings.push_back(prefix);
        return;
    }
    generate_strings(strings, prefix + '0', remaining - 1);
    generate_strings(strings, prefix + '1', remaining - 1);
}

bool is_substring(const string& input_string, const string& substring) {
    for (int i = 0; i < input_string.length(); ++i) {
        string rotated_string = input_string.substr(i) + input_string.substr(0, i);
        if (rotated_string.find(substring) != string::npos) {
            return true;
        }
    }
    return false;
}

int count_distinct_strings(const string& str, int N) {
    vector<string> strings;
    generate_strings(strings, "", N);
    set<string> distinct_strings;

    for (const string& s : strings) {
        if (is_substring(s, str)) {
            distinct_strings.insert(s);
        }
    }

    return distinct_strings.size();
}

int main() {
    string str;
    int N;
   
   
  
    cin >> N;
    cin >> str;

    int count = count_distinct_strings(str, N);
    cout << count << endl;

    return 0;
}

Look A Like ✅

// rat and chesse
#include<bits/stdc++.h>
using namespace std;
int bfs(vector<vector<int>>&grid){
        queue<pair<int,int>>q;
        int dx[4]={0,0,1,-1};
        int dy[4]={1,-1,0,0};
        for(int i=0;i<grid.size();i++){
            for(int j=0;j<grid[0].size();j++){
                if(grid[i][j]==2)q.push({i,j});
            }
        }
        int time=0;
        while(!q.empty()){
            int k=q.size();
            bool found=false;
            while(k--){
                int r=q.front().first,c=q.front().second;
                q.pop();
                grid[r][c]=2;
                for(int i=0;i<4;i++){
                    int row=r+dx[i],col=c+dy[i];
                    if(row>=0&&row<grid.size()&&col>=0&&col<grid[0].size()&&grid[row][col]==1){
                        q.push({row,col});found=true;
                        grid[row][col]=2;
                    }
                }
            }
            if(found)
             time++;
        }
        // check -1
        for(int i=0;i<grid.size();i++){
            for(int j=0;j<grid[0].size();j++){
                if(grid[i][j]==1)return -1;
            }
        }
        return time;
    }
int main(){
    vector<vector<int>>v={{2,1,1},{1,1,0},{0,1,1}};
    cout<<bfs(v);
}

Get the Max product✅

#include<bits/stdc++.h>
using namespace std;
int length(string s){
    bool found=false;
    int temp=0;
    for(int i=0;i<s.size();i++){
        if(isdigit(s[i])){
            found=true;
            temp*=10;
            temp+=(s[i]-'0');
        }
    }
    if(found==false){
        return s.size();
    }
    return temp;
}
long long  solve(vector<string>v,int n){
    vector<int>len;
    for(int i=0;i<n;i++){
        len.push_back(length(v[i]));
    }
    int max1=0,max2=0;
    for(int i=0;i<n;i++){
        if(len[i]>max1){
             max2=max1;
            max1=len[i];
        }
        else if(len[i]>max2){
            max2=len[i];
        }
    }
    return max1*max2*1ll;
    return len[n-1]*len[n-2]*1ll;
}
int main(){
    int n;cin>>n;
    vector<string>v(n,"");
    for(int i=0;i<n;i++)
    {
        cin>>v[i];
    }
    cout<<solve(v,n);
}