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

int solve(int N, vector<int> A, vector<int> B) {
    set<int> B_set(B.begin(), B.end());
    int smallest_missing = INT_MAX;
    for (int i = 0; i < N; i++) {
        if (B_set.find(A[i]) == B_set.end()) {
            smallest_missing = min(smallest_missing, A[i]);
        }
    }
    return (smallest_missing == INT_MAX) ? -1 : smallest_missing;
}

Missing Elements ✅

public static int getMaxSubarrayLen(int[] batch_a, int[] batch_b) {
        int n = batch_a.length;
        int[] dpA = new int[n];
        int[] dpB = new int[n];

        dpA[0] = dpB[0] = 1;
        int maxLength = 1;

        for (int i = 1; i < n; i++) {
            dpA[i] = dpB[i] = 1;
            if (batch_a[i] >= batch_a[i - 1]) {
                dpA[i] = Math.max(dpA[i], dpA[i - 1] + 1);
            }
            if (batch_a[i] >= batch_b[i - 1]) {
                dpA[i] = Math.max(dpA[i], dpB[i - 1] + 1);
            }
            if (batch_b[i] >= batch_b[i - 1]) {
                dpB[i] = Math.max(dpB[i], dpB[i - 1] + 1);
            }
            if (batch_b[i] >= batch_a[i - 1]) {
                dpB[i] = Math.max(dpB[i], dpA[i - 1] + 1);
            }

            maxLength = Math.max(maxLength, Math.max(dpA[i], dpB[i]));
        }

        return maxLength;
    }

Save the humanity from Covid -X✅

def minimum_swaps_to_sort_packages(n, x, packages):
    swaps = 0
    holding = x

    for i in range(n):
      
        if packages[i] > holding:
            if i == 0 or packages[i] >= packages[i-1]:
                holding, packages[i] = packages[i], holding
                swaps += 1

   
    if all(packages[i] <= packages[i + 1] for i in range(n - 1)):
        return swaps
    else:
        return -1

Sort Packages ✅

inbliss-ai is hiring AI Freshers with LLM knowledge for the Baner, Pune Location.

Qualifications:
- Bachelor’s degree in engineering branch (CS, Mech, ENTC, and Instrumentation), Artificial Intelligence, Data Science, or a related field.
· Basic understanding of AI concepts, machine learning algorithms, and natural language processing.
· Familiarity with Large Language Models such as GPT-3, GPT-4, BERT, or similar.
· Proficiency in programming languages such as Python, and experience with AI/ML libraries (e.g., TensorFlow, PyTorch).

Interested candidates can submit their Profiles and relevant project portfolios or links to hr@inbliss-ai.com

Trumio is hiring Full Stack Intern

For 2024, 2025, 2026 grads

https://wellfound.com/jobs/3061177-full-stack-intern?s=08

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int solve(int n, vector<int>& a, int m, vector<int>& b, int c) {
    sort(a.begin(), a.end());
    sort(b.begin(), b.end());
    int d = 0;
    int e = 0; 
    for (int f : a) {
        int g = 0;
        while (e < m && b[e] <= f) {
            g++;
            e++;
        }
        if (g >= c) {
            d = b[g - c] - 1;
            break;
        } else {
            d = f;
        }
    }
    return d;
}.

Paris Olympics 2024✅
PhonePe

#include <bits/stdc++.h>
using namespace std;
#define ll long long
ll solve(vector<ll>&a,ll n,ll k)
{
    ll sum=0;
    for(ll i=0;i<n;i++) sum+=a[i];
    a.insert(a.begin(),0);
    vector<ll>dp(n+1);
    deque<ll>dq;
    for(ll i=1;i<=k;i++)
    {
        while(!dq.empty() and dp[i-1]+a[i]<=dp[dq.back()-1]+a[dq.back()])
        {
            dq.pop_back();
        }
        dq.push_back(i);
    }
    for(ll i=k+1;i<=n;i++)
    {
        while(!dq.empty() and dp[i-1]+a[i]<=dp[dq.back()-1]+a[dq.back()])
        {
            dq.pop_back();
        }
        dq.push_back(i);
        dp[i]=dp[dq.front()-1]+a[dq.front()];
        if(dq.front()==i-k) dq.pop_front();
    }
    return sum-dp[n];
}
signed main()
{
    ll n,k; cin>>n>>k;
    vector<ll>a(n);
    for(ll i=0;i<n;i++) cin>>a[i];
    cout<<solve(a,n,k);
}

Paris Olympics 2024✅

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
int solve(int N, int M, vector<vector<int>>& matrix) {
    vector<pair<int, int>> directions = {{0, 1}, {1, 0}};
        queue<tuple<int, int, int>> q;
    q.push({0, 0, 0});
   
    vector<vector<bool>> visited(N, vector<bool>(M, false));
    visited[0][0] = true;
   
    while (!q.empty()) {
        auto [x, y, moves] = q.front();
        q.pop();
       
        if (x == N - 1 && y == M - 1) {
            return moves;
        }
       
        int jump = matrix[x][y];
       
        for (const auto& [dx, dy] : directions) {
            int nx = x + dx * jump;
            int ny = y + dy * jump;
           
            if (nx >= 0 && nx < N && ny >= 0 && ny < M && !visited[nx][ny]) {
                visited[nx][ny] = true;
                q.push({nx, ny, moves + 1});
            }
        }
    }
   
    return -1;
}.

REACH THE END ✅
PhonePE

ticket.com is hiring for Quality Assurance Intern

25-30 k per month

2025/2024 passouts ( 2026 may can also try )

https://jobs.lever.co/tiket/a571df49-c862-4280-becc-dccf4d593a52

public static String decodePassword(String encodedPassword) {
        String reversedString = new StringBuilder(encodedPassword).reverse().toString();
       
        StringBuilder decodedPassword = new StringBuilder();
        int i = 0;
        while (i < reversedString.length()) {
            int asciiValue;
            if (i + 2 < reversedString.length()) {
                asciiValue = Integer.parseInt(reversedString.substring(i, i + 3));
                if (asciiValue >= 32 && asciiValue <= 122) {
                    i += 3;
                } else {
                    asciiValue = Integer.parseInt(reversedString.substring(i, i + 2));
                    i += 2;
                }
            } else {
                asciiValue = Integer.parseInt(reversedString.substring(i, i + 2));
                i += 2;
            }
            decodedPassword.append((char) asciiValue);
        }
       
        return decodedPassword.toString();
    }

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;
class SGTree {
    vector<long long> seg;

public:
    SGTree(long long n) {
        seg.resize(4 * n, 0);
    }

    void build(long long ind, long long low, long long high, vector<long long>& arr) {
        if (low == high) {
            seg[ind] = arr[low];
            return;
        }

        long long mid = (low + high) >> 1;
        build(2 * ind + 1, low, mid, arr);
        build(2 * ind + 2, mid + 1, high, arr);
        seg[ind] = (seg[2 * ind + 1] + seg[2 * ind + 2]);
    }

    long long query(long long ind, long long low, long long high, long long l, long long r) {
        if (r < low || high < l) return 0;
        if (l <= low && high <= r) return seg[ind];

        long long mid = (low + high) >> 1;
        long long left = query(2 * ind + 1, low, mid, l, r);
        long long right = query(2 * ind + 2, mid + 1, high, l, r);
        return (left + right);
    }

    void update(long long ind, long long low, long long high, long long i, long long val) {
        if (low == high) {
            seg[ind] = val;
            return;
        }

        long long mid = (low + high) >> 1;
        if (i <= mid) update(2 * ind + 1, low, mid, i, val);
        else update(2 * ind + 2, mid + 1, high, i, val);
        seg[ind] = (seg[2 * ind + 1] + seg[2 * ind + 2]);
    }
};

vector<int> even_odd(int N, vector<long long> A) {
    vector<long long> val1(N);
    vector<long long> val2(N);
    vector<pair<long long, long long>> chota(N);
    vector<pair<long long, long long>> bada(N);

    for (long long i = 0; i < N; ++i) {
        chota[i] = { A[i], i };
        bada[i] = { A[i], i };
    }

    sort(chota.begin(), chota.end());
    sort(bada.begin(), bada.end(), greater<pair<long long, long long>>());

    SGTree sgt1(N);
    sgt1.update(0, 0, N - 1, chota[0].second, chota[0].first);

    for (long long i = 1; i < N; ++i) {
        long long val = sgt1.query(0, 0, N - 1, 0, chota[i].second);
        val1[chota[i].second] = val;
        sgt1.update(0, 0, N - 1, chota[i].second, chota[i].first);
    }

    SGTree sgt2(N);
    sgt2.update(0, 0, N - 1, bada[0].second, 1);

    for (long long i = 1; i < N; ++i) {
        long long val = sgt2.query(0, 0, N - 1, 0, bada[i].second);
        val2[bada[i].second] = val;
        sgt2.update(0, 0, N - 1, bada[i].second, 1);
    }

    vector<int> res(N);
    for (long long i = 0; i < N; ++i) {
        long long curr = val1[i] + (val2[i] * A[i]);
        res[i] = (curr % 2 == 0) ? 1 : 0;
    }
    return res;
}.

EVEN ODD SUM 
Sprinklr ✅

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

using namespace std;

vector<long long> palindromes;

void generatePalindromes(int idx, string p, int flag);

long long calculate(string p) {
    string p1 = p;
    reverse(p1.begin(), p1.end());
    string fullPalindrome = p + p1;
    long long ans = 0;
    for (int i = fullPalindrome.length() - 1; i >= 0; i--) {
        if (fullPalindrome[i] == '1') {
            ans += (1LL << (fullPalindrome.length() - 1 - i));
        }
    }
    return ans;
}

long long calculateWithRemovedCenter(string p) {
    string p1 = p;
    reverse(p1.begin(), p1.end());
    if (!p1.empty())
        p1.erase(p1.begin());
    string fullPalindrome = p + p1;
    long long ans = 0;
    for (int i = fullPalindrome.length() - 1; i >= 0; i--) {
        if (fullPalindrome[i] == '1') {
            ans += (1LL << (fullPalindrome.length() - 1 - i));
        }
    }
    return ans;
}

void generatePalindromes(int idx, string p, int flag) {
    if (idx == 16) {
        palindromes.push_back(calculate(p));
        if (!p.empty()) {
            palindromes.push_back(calculateWithRemovedCenter(p));
        }
        return;
    }
    if (flag == 0) {
        generatePalindromes(idx + 1, p, 0);
        generatePalindromes(idx + 1, p + "1", 1);
    } else {
        generatePalindromes(idx + 1, p + "0", 1);
        generatePalindromes(idx + 1, p + "1", 1);
    }
}

long long solve(long long num) {
    auto it = lower_bound(palindromes.begin(), palindromes.end(), num);
    long long result = LLONG_MAX;
    if (it != palindromes.end()) {
        result = min(result, abs(*it - num));
    }
    if (it != palindromes.begin()) {
        result = min(result, abs(num - *(--it)));
    }
    return result;
}

int main() {
    generatePalindromes(0, "", 0);
    sort(palindromes.begin(), palindromes.end());

    long long num;
    cin >> num;
    cout << solve(num) << endl;

    return 0;
}
Binary palindrome number  Sprinklr ✅

Company Name: Eagleview

🛄 Job Title: Software Engineer
✍🏻 YOE: 2022, 2023 and 2024 grads

➡️ Apply:
1) https://careers.eagleview.com/jobs/2157?lang=en-us
2) https://careers.eagleview.com/jobs/2158?lang=en-us

Please do share in your college grps and in case you are applying please react on this post:) 😇❤️

Company Name: Western Digital

🛄 Job Title: Software Engineer
✍🏻 YOE: 2024 grads only

➡️ Apply: https://jobs.smartrecruiters.com/WesternDigital/744000001182425-engineer-software-engineering-ncg-hiring-be-2024-c-or-c-

Please do share in your college grps and in case you are applying please react on this post:) 😇❤️

Flipkart is hiring (2024 grads)

Roles: SDE 1, UI-1 and Data Engineer 1

Eligibility: 2024 engg graduates (CSE, IT, ECE & EE streams only)

CTC: 32.57 LPA (18 lakhs base, 10% variable, ESOPs worth 5 Lakh, Joining Bonus- 3 lakh and Retention bonus: 3 lakh + retirals & other benefits)

Apply: https://docs.google.com/forms/d/e/1FAIpQLSdpZOBSMreLO3ahwEHHsAunsGUl1uoYPAVVyFpBEFZYaQGeNA/viewform

import java.util.*;

public class MaxBinaryPath {
    static int N;
    static String S;
    static List<Integer>[] adj;
    static boolean[] visited;
    static String maxBinary = "";

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        N = sc.nextInt();

        S = sc.next();

        adj = new ArrayList[N + 1];
        for (int i = 1; i <= N; i++) {
            adj[i] = new ArrayList<>();
        }

        for (int i = 0; i < N - 1; i++) {
            int u = sc.nextInt();
            int v = sc.nextInt();
            adj[u].add(v);
            adj[v].add(u);
        }

        visited = new boolean[N + 1];

        for (int i = 1; i <= N; i++) {
            Arrays.fill(visited, false);
            dfs(i, "");
        }

        int maxLength = N; 
        System.out.println(String.format("%" + maxLength + "s", maxBinary).replace(' ', '0'));

        sc.close();
    }

    private static void dfs(int node, String path) {
        visited[node] = true;
        path += S.charAt(node - 1);

        if (path.length() == N && path.compareTo(maxBinary) > 0) {
            maxBinary = path;
        } else if (path.length() > N) {
            if (path.substring(0, N).compareTo(maxBinary) > 0) {
                maxBinary = path.substring(0, N);
            }
        }

        for (int neighbor : adj[node]) {
            if (!visited[neighbor]) {
                dfs(neighbor, path);
            }
        }

        visited[node] = false;
    }
}

#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
int solution(vector<int> &A, vector<int> &B) {
    int N = A.size();
    vector<vector<int>> dp(2, vector<int>(N, 0));
    dp[0][0] = A[0];
    dp[1][0] = max(A[0], B[0]);
   
    for (int j = 1; j < N; ++j) {
        dp[0][j] = max(dp[0][j - 1], A[j]);
        dp[1][j] = min(max(dp[0][j], B[j]), max(dp[1][j - 1], B[j]));
    }
   
    return dp[1][N - 1];
} /// MS TASK 2