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

typedef long long ll;

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
   
    ll m, n;
    cin >> m >> n;
   
    vector<ll> cars(m);
    for(auto &x: cars) cin >> x;
   
    sort(cars.begin(), cars.end());
   
    ll coverage = 0;
    int added = 0;
    int i = 0;
   
    while(coverage < n){
      
        if(i < m && cars[i] <= coverage + 1){
            coverage += cars[i];
            i++;
        }
        else{
          
            ll new_car = coverage + 1;
            coverage += new_car;
            added++;
            if(coverage > n) coverage = n;
        }
    }
   
    cout << added;
}

static final int MOD = 1000000007;

    public static int getNumPerfectPackaging(int[] prices) {
        int n = prices.length;
        if (n == 0) return 0;
        if (n == 1) return 5;

        long[] dpPrev = new long[6]; // index 1 to 5
        for(int s = 1; s <=5; s++) {
            dpPrev[s] = 1;
        }

        long[] dp = new long[6];

        for(int i =1; i < n; i++) {
            for(int s =1; s <=5; s++) {
                dp[s] =0;
            }

            if(prices[i] > prices[i-1]) {
                long[] prefix = new long[6];
                prefix[0] =0;
                for(int s =1; s <=5; s++) {
                    prefix[s] = (prefix[s-1] + dpPrev[s]) % MOD;
                }
                for(int s=1; s <=5; s++) {
                    dp[s] = prefix[s-1];
                }
            }
            else if(prices[i] < prices[i-1]) {
                long[] suffix = new long[7]; 
                suffix[6] =0;
                for(int s =5; s >=1; s--) {
                    suffix[s] = (suffix[s+1] + dpPrev[s]) % MOD;
                }
                for(int s=1; s <=5; s++) {
                    dp[s] = suffix[s+1];
                }
            }
            else {
                long[] prefix = new long[6];
                prefix[0] =0;
                for(int s =1; s <=5; s++) {
                    prefix[s] = (prefix[s-1] + dpPrev[s]) % MOD;
                }
                for(int s=1; s <=5; s++) {
                    dp[s] = prefix[s];
                }
            }

            for(int s=1; s <=5; s++) {
                dpPrev[s] = dp[s] % MOD;
            }
        }

        long total =0;
        for(int s=1; s <=5; s++) {
            total = (total + dpPrev[s]) % MOD;
        }
        return (int) total;
    }

Amazon ✅

SEND RESUME AT
joinus@texarxs.com

📌Job Company: CyberNxt Solutions LLP

Job Role: Graduates and Interns for CyberSecurity / NetworkSecurity
Job Location: Mumbai


If you are interested, please feel free to share your CV at- raksha.singh@cybernxt.in

def solve(arr, n, num):
    if n == 0 or num == 0:
        return 0
    memo = {}
    def dp(i, remaining):

        if (i, remaining) in memo:
            return memo[(i, remaining)]
        if i >= n:
            return 0
        if remaining < arr[i]:
            return 0
     
        pick = arr[i] + dp(i + 2, remaining - arr[i])
        skip = dp(i + 1, remaining)
        memo[(i, remaining)] = max(pick, skip)
        return memo[(i, remaining)]
    return dp(0, num)

Samsung ✅

#include <vector>
#include <string>
#include <sstream>
#include <algorithm>
#include <cctype>  // For std::tolower

using namespace std;

const int ALPHABET_SIZE = 26;

struct TrieNode {
    struct TrieNode* children[ALPHABET_SIZE];
    bool isEndOfWord;
    
    TrieNode() {
        isEndOfWord = false;
        for (int i = 0; i < ALPHABET_SIZE; i++) {
            children[i] = nullptr;
        }
    }
    
    ~TrieNode() {
        for (int i = 0; i < ALPHABET_SIZE; i++) {
            delete children[i];
        }
    }
};

void insertWord(TrieNode* root, const string& word) {
    TrieNode* current = root;
    
    for (char c : word) {
        // Convert character to lowercase before processing
        c = tolower(c);
        
        // Only process lowercase letters
        if (c >= 'a' && c <= 'z') {
            int index = c - 'a';
            if (!current->children[index]) {
                current->children[index] = new TrieNode();
            }
            current = current->children[index];
        }
    }
    current->isEndOfWord = true;
}

void collectWords(TrieNode* node, string currentWord, vector<string>& result) {
    if (node->isEndOfWord) {
        result.push_back(currentWord);
    }
    
    for (int i = 0; i < ALPHABET_SIZE; i++) {
        if (node->children[i]) {
            collectWords(node->children[i], currentWord + char('a' + i), result);
        }
    }
}

vector<string> solution(const string& words) {
    TrieNode* root = new TrieNode();
    
    istringstream iss(words);
    string word;
    
    while (iss >> word) {
        insertWord(root, word);
    }
    
    vector<string> result;
    collectWords(root, "", result);
    
    sort(result.begin(), result.end(), 
         [](const string& a, const string& b) {
             if (a.length() != b.length()) {
                 return a.length() < b.length();
             }
             return a < b;
         });
    
    delete root;
    
    return result;
}

int main() {
    string input = "Hello world, this is a Trie example!";
    vector<string> words = solution(input);
    
    for (const string& word : words) {
        cout << word << endl;
    }

    return 0;
}

Cohesity ✅

Anyone got this mail who gave uber exam just react

def can_convert(C, F, N):
    for i in range(len(C)):
        shift_needed = (ord(F[i]) - ord(C[i]) + 26) % 26
        if shift_needed > N:
            return "No"
    return "Yes"

MAQ Software ✅

from collections import Counter
def solve(a):
    b = Counter(a)
    c = [] 
    d = '' 
    for e in sorted(b.keys()):
        f = b[e]
        if f % 2 == 1:
            if not d:
                d = e
            f -= 1
        c.append(e * (f // 2))
    g = ''.join(c)
    return g + d + g[::-1]
h = int(input().strip())
i = []
for _ in range(h):
    j = input().strip()
    i.append(solve(j))
print("\n".join(i))

MAQ Software ✅

Company: GXS Bank
Role: Software Engineering Internship
Batch: 2025, 2026, 2027
https://www.linkedin.com/jobs/view/4071854518

Company : SupraOracles
Program: Career Academy
Batch: 2027

Rewards: Mentorship + Skills + Interview Opportunity at Paypal
https://boards.greenhouse.io/supraoracles/jobs/5191557004

Company: SuperKalam (YC W23)
Role: Backend Engineer (Internship)
Stipend: ₹30K - ₹47K INR
Location: Bengaluru, KA, IN / Remote (Bengaluru, KA, IN)

https://www.ycombinator.com/companies/superkalam/jobs/rxajsHH-backend-engineer-internship

Company : Paypal
Program: Career Academy
Batch: 2027

Rewards: Mentorship + Skills + Interview Opportunity at PayPal

http://paypal.eightfold.ai/events/candidate/landing?plannedEventId=OYoXKVoK&source=KrishanKumarLinkedin

#include <iostream>
#include <string>
#include <vector>
using namespace std;
vector<int> computeLPSArray(const string& str) {
    int n = str.length();
    vector<int> lps(n, 0);
        int len = 0;
    int i = 1;
    while (i < n) {
        if (str[i] == str[len]) {
            len++;
            lps[i] = len;
            i++;
        }
        else {
            if (len != 0) {
                len = lps[len - 1];
            }
            else {
                lps[i] = 0;
                i++;
            }
        }
    }
    
    return lps;
}
int solution(string& S) {
    int n = S.length();
    if (n <= 1) return 0;
        vector<int> lps = computeLPSArray(S);
    return lps[n-1] < n ? lps[n-1] : lps[lps[n-1]-1];
} 

Task1
Amex ✅

#include <iostream>
#include <string>
#include <vector>
using namespace std;
int solution(string &S) {
    int N = S.length();
    long long operations = 0; 
        int start = 0;
    while (start < N && S[start] == '0') {
        start++;
    }
        if (start == N) return 0;
        for (int i = start; i < N; i++) {
        if (S[i] == '1') {
      
            operations += 2; 
        } else {
            operations += 1;
        }
    }
    operations--;
    
    return operations;
}  

Task2
Amex✅

int solution(vector<int> &A)
{
    int n = A.size();
    int res = 0;
    multiset<int>st;
    map<int, int>mp;
    for (int i = 0; i < n; i++)
    {
        mp[A[i]]++;
        st.insert(i);
        while (mp.size() > 2) {
            auto cur = *st.begin();
            st.erase(cur);
            mp[A[cur]]--;
            if (mp[A[cur]] == 0) {
                mp.erase(A[cur]);
            }

        }
        res = max(res, (int)(st.size()));
    }

    return res;
}

 

Task3
Amex ✅