Jade Global is organising a Walkin Interview for 2024 Graduates (No Post-Graduates) ❤️❤️❤️

Stream:
BSc (CS / IT / Stats / Maths / Physics / Electronics)
BCA
BBA-CA (Freshers)

Year of passing: 2024
60% Overall.

Joining: By Mid September

Opportunities
1. Sponsered MSc and MTech Degree from BITS Pilani.
2. Technical and Self- Development Program.

Drive: Monday to Friday (Coming Week) from 10 AM to 12 Noon.

Venue: Wadgaonsheri Office, Nyati Tech Park, 7th Floor, Near Brahma Suncity, Behind Nyati Meadows, Wadgaon Sheri Pune- 411014

Company Name: Clearfeed
Role: Software Engineer Intern

Batch eligible: 2025 grads only

Apply: https://clearfeed.keka.com/careers/jobdetails/150

Company Name: Akamai Technology

Role: Software Engineer (Remote)
Batch eligible: 2023 and 2024 grads

Apply: https://akamaicareers.inflightcloud.com/jobdetails/aka_ext/035360

Amgen is hiring Associate Software Engineer

For 2021, 2022, 2023, 2024 grads
Location: Hyderabad

https://careers.amgen.com/en/job/hyderabad/associate-software-engineer/87/68552403264

https://x.com/Arpitaaa01/status/1822328904599880063?t=pL-Cb2_RoxUz6JRQBqVGiw&s=35

Myntra Referral form :

https://docs.google.com/forms/d/e/1FAIpQLSeHEIZDYx5OxiFAVplcZc3DIw_-t43XKnuThLSZGQbyeJNv2w/viewform

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

int solve(int N, int K, const std::vector<int>& houses) {
    vector<int> indices(N);
    for (int i = 0; i < houses.size(); i++) {
        indices[houses[i] - 1] = i + 1;
    }

deque<int> maxDeque;
    int ans = INT_MAX;

    for (int i = 0; i < K; i++) {
        while (!maxDeque.empty() && indices[i] >= indices[maxDeque.back()]) {
            maxDeque.pop_back();
        }
        maxDeque.push_back(i);
    }

    ans = indices[maxDeque.front()];

    for (int i = K; i < N; i++) {
        if (maxDeque.front() <= i - K) {
            maxDeque.pop_front();
        }
        while (!maxDeque.empty() && indices[i] >= indices[maxDeque.back()]) {
            maxDeque.pop_back();
        }
        maxDeque.push_back(i);

        ans = std::min(ans, indices[maxDeque.front()]);
    }

    return ans;
}

.

UC Happy Neighborhood ✅

def solve(N, M, K, arr):
    target_avg = K / N
    prefix_sum = [0] * (N + 1)
    for i in range(N):
        prefix_sum[i + 1] = prefix_sum[i] + arr[i]
    
    def checkPerm():
        score = 0
        for i in range(N):
            if score / (i + 1) < target_avg:
                score += M
            elif score / (i + 1) > target_avg:
                return False
        return score / N == target_avg
    
    def averageScore(index, currSum):
        if index == N:
            return currSum == K
        
        for i in range(index, N):
            arr[index], arr[i] = arr[i], arr[index]
            if currSum + arr[index] <= K and averageScore(index + 1, currSum + arr[index]):
                return True
            arr[index], arr[i] = arr[i], arr[index]
        
        return False

    if checkPerm() or averageScore(0, 0):
        return "NO"
    return "YES"

Average score GE ✅

def solve(start, stop):
    def isPerfect(num):
        original = num
        while num > 0:
            digit = num % 10
            if digit == 0 or original % digit != 0:
                return False
            num //= 10
        return True

    perfSum = 0
    for num in range(start, stop + 1):
        if isPerfect(num):
            perfSum += num
    
    return perfSum

Perfect number
Motorq ✅

import math

def sieve_of_eratosthenes(n):
    primes = [True] * (n + 1)
    primes[0] = primes[1] = False
    for i in range(2, int(math.sqrt(n)) + 1):
        if primes[i]:
            for j in range(i * i, n + 1, i):
                primes[j] = False
    return primes

def least_prime_factor(n, primes):
    for i in range(2, n + 1):
        if primes[i] and n % i == 0:
            return i
    return n

def divisor_queries(N, Q, a, queries):
    max_val = max(max(a), 10**6)
    primes = sieve_of_eratosthenes(max_val)
    
    results = []
    for query in queries:
        query_type = query[0]
        
        if query_type == 1:
            l, r = query[1], query[2]
            for i in range(l - 1, r):
                lpf = least_prime_factor(a[i], primes)
                a[i] //= lpf
        
        elif query_type == 2:
            l, r = query[1], query[2]
            sum_range = sum(a[l-1:r])
            results.append(sum_range)
        
        elif query_type == 3:
            i, k = query[1], query[2]
            a[i-1] = k
    
    return results

Least prime factor ✅

#include <bits/stdc++.h>
using namespace std;
vector<int> suffixArray(const string& s) {
    int n = s.size();
    vector<int> p(n), c(n);
    vector<pair<char, int>> a(n);
    for (int i = 0; i < n; i++) a[i] = {s[i], i};
    sort(a.begin(), a.end());
    for (int i = 0; i < n; i++) p[i] = a[i].second;
    c[p[0]] = 0;
    for (int i = 1; i < n; i++) {
        if (a[i].first == a[i - 1].first) {
            c[p[i]] = c[p[i - 1]];
        } else {
            c[p[i]] = c[p[i - 1]] + 1;
        }
    }
    int k = 0;
    vector<int> pn(n), cn(n);
    while ((1 << k) < n) {
        for (int i = 0; i < n; i++) {
            pn[i] = p[i] - (1 << k);
            if (pn[i] < 0) pn[i] += n;
        }
        vector<int> cnt(n);
        for (int x : c) cnt[x]++;
        for (int i = 1; i < n; i++) cnt[i] += cnt[i - 1];
        for (int i = n - 1; i >= 0; i--) p[--cnt[c[pn[i]]]] = pn[i];
        cn[p[0]] = 0;
        for (int i = 1; i < n; i++) {
            pair<int, int> cur = {c[p[i]], c[(p[i] + (1 << k)) % n]};
            pair<int, int> prev = {c[p[i - 1]], c[(p[i - 1] + (1 << k)) % n]};
            if (cur == prev) {
                cn[p[i]] = cn[p[i - 1]];
            } else {
                cn[p[i]] = cn[p[i - 1]] + 1;
            }
        }
        c.swap(cn);
        k++;
    }
    return p;
}

vector<int> lcpArray(const string& s, const vector<int>& p) {
    int n = s.size();
    vector<int> rank(n), lcp(n - 1);
    for (int i = 0; i < n; i++) rank[p[i]] = i;
    int k = 0;
    for (int i = 0; i < n; i++) {
        if (rank[i] == n - 1) {
            k = 0;
            continue;
        }
        int j = p[rank[i] + 1];
        while (i + k < n && j + k < n && s[i + k] == s[j + k]) k++;
        lcp[rank[i]] = k;
        if (k > 0) k--;
    }
    return lcp;
}

int substringCalculator(const string& s) {
    string s_ext = s + "$";
    vector<int> p = suffixArray(s_ext);
    vector<int> lcp = lcpArray(s_ext, p);
    long long total = 0;
    int n = s.size();
    for (int i = 0; i < n; i++) {
        total += lcp[i];
    }
    return (long long)n * (n + 1) / 2 - total;
}

int main() {
    string s;
    cin >> s;
    cout << substringCalculator(s) << endl;
    return 0;
}

substringCalculator ✅

public static int maximumLearning(List<Integer> iv, List<Integer> articles, int p) {
  int size = articles.size();
  int[] art = new int[size];
  int[] ivs = new int[size];
for(int i=0;i<size;i++){
   art[i] = articles.get(i)*2;
   ivs[i] = iv.get(i);
}
return knapSackTopDownCode(ivs, art, p, size) ;
}
public static int knapSackTopDownCode(int[] val, int[] wt, int W, int n) {
   int mat[][] = new int [n+1][W+1];
   for(int i=1;i<n+1;i++) {
     for(int j=1;j<W+1;j++) {
          if(i==0 || j ==0)
              mat[i][j] =0;
          else if(wt[i-1]<=j) {
              mat[i][j] = Math.max(val[i-1]+ mat[i-1][j-wt[i-       1]],mat[i-1][j]);
           }
          else {
              mat[i][j] = mat[i-1][j];}
             }
       }
   return mat[n][W];
}
}

maximumLearning✅

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

int minCntFoun(int a[], int N)
{


int dp[N];


for(int i=0;i<N;i++){
  dp[i]=-1;
}


int idxLeft;

int idxRight;

for (int i = 0; i < N; i++) {
  idxLeft = max(i - a[i], 0);
  idxRight = min(i + (a[i] + 1), N);
  dp[idxLeft] = max(dp[idxLeft],
      idxRight);
}


int cntfount = 1;

idxRight = dp[0];

int idxNext=-1;

for (int i = 0; i < N; i++) 
{
  idxNext = max(idxNext,
     dp[i]);

  if (i == idxRight) 
  {
   cntfount++;
   idxRight = idxNext;
  }
}

return cntfount;
}

fountain ✅

int findmaxPath(int root, int &ans, vector<int> &parent, vector<int> &values, vector<bool> &computed){
    if(computed[root]) return values[root];
    if(parent[root]==-1) {
         computed[root]=true;
    }
    else{
        computed[root]=true;
        int parentpath = findmaxPath(parent[root], ans, parent, values, computed);
        values[root] = max(parentpath+values[root], values[root]);
    }
    ans = max(ans, values[root]);
    return values[root];
}

int bestSumDownwardTreePath(vector<int> parent, vector<int> values) {
    int n=parent.size();
    int ans = values[0];
    vector<bool> computed(n, false);
    for(int i=0; i<n; i++){
        if(computed[i]) continue;
        findmaxPath(i, ans, parent, values, computed);
    }
    return ans;
}

Best Sum Any Tree Path ✅

int N = batch_a.size();

int dp[N][2];

memset(dp, 0, sizeof dp);

dp[0][0] = 1;
dp[0][1] = 1;

for(int i = 1; i < N; i++){
  // batch_a
  int temp = 0;
  if(batch_a[i] >= batch_a[i - 1]) temp = max(temp, dp[i - 1][0]);
  if(batch_a[i] >= batch_b[i - 1]) temp = max(temp, dp[i - 1][1]);

  dp[i][0] = temp + 1;

  temp = 0;
  if(batch_b[i] >= batch_a[i - 1]) temp = max(temp, dp[i - 1][0]);
  if(batch_b[i] >= batch_b[i - 1]) temp = max(temp, dp[i - 1][1]);

  dp[i][1] = temp + 1;
}

int ans = 0;

for(int i = 0; i < N; i++)
  ans = max({ans, dp[i][0], dp[i][1]});

return ans;

getmaxsubarraylen
Meesho✅

#include <bits/stdc++.h>
using namespace std;
vector<int> suffixArray(const string& s) {
    int n = s.size();
    vector<int> p(n), c(n);
    vector<pair<char, int>> a(n);
    for (int i = 0; i < n; i++) a[i] = {s[i], i};
    sort(a.begin(), a.end());
    for (int i = 0; i < n; i++) p[i] = a[i].second;
    c[p[0]] = 0;
    for (int i = 1; i < n; i++) {
        if (a[i].first == a[i - 1].first) {
            c[p[i]] = c[p[i - 1]];
        } else {
            c[p[i]] = c[p[i - 1]] + 1;
        }
    }
    int k = 0;
    vector<int> pn(n), cn(n);
    while ((1 << k) < n) {
        for (int i = 0; i < n; i++) {
            pn[i] = p[i] - (1 << k);
            if (pn[i] < 0) pn[i] += n;
        }
        vector<int> cnt(n);
        for (int x : c) cnt[x]++;
        for (int i = 1; i < n; i++) cnt[i] += cnt[i - 1];
        for (int i = n - 1; i >= 0; i--) p[--cnt[c[pn[i]]]] = pn[i];
        cn[p[0]] = 0;
        for (int i = 1; i < n; i++) {
            pair<int, int> cur = {c[p[i]], c[(p[i] + (1 << k)) % n]};
            pair<int, int> prev = {c[p[i - 1]], c[(p[i - 1] + (1 << k)) % n]};
            if (cur == prev) {
                cn[p[i]] = cn[p[i - 1]];
            } else {
                cn[p[i]] = cn[p[i - 1]] + 1;
            }
        }
        c.swap(cn);
        k++;
    }
    return p;
}

vector<int> lcpArray(const string& s, const vector<int>& p) {
    int n = s.size();
    vector<int> rank(n), lcp(n - 1);
    for (int i = 0; i < n; i++) rank[p[i]] = i;
    int k = 0;
    for (int i = 0; i < n; i++) {
        if (rank[i] == n - 1) {
            k = 0;
            continue;
        }
        int j = p[rank[i] + 1];
        while (i + k < n && j + k < n && s[i + k] == s[j + k]) k++;
        lcp[rank[i]] = k;
        if (k > 0) k--;
    }
    return lcp;
}

int substringCalculator(const string& s) {
    string s_ext = s + "$";
    vector<int> p = suffixArray(s_ext);
    vector<int> lcp = lcpArray(s_ext, p);
    long long total = 0;
    int n = s.size();
    for (int i = 0; i < n; i++) {
        total += lcp[i];
    }
    return (long long)n * (n + 1) / 2 - total;
}

int main() {
    string s;
    cin >> s;
    cout << substringCalculator(s) << endl;
    return 0;
}

Meesho ✅

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

using namespace std;

int ceil(const vector<int>& tail, int left, int right, int x) {
    while (right > left) {
        int mid = left + (right - left) / 2;
        if (tail[mid] >= x) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    return right;
}

int MinDeletion(const vector<int>& arr, int n) {
    vector<int> tail(n, 0);
    tail[0] = arr[0];
    int length = 1;

    for (int i = 1; i < n; ++i) {
        if (arr[i] > tail[length - 1]) {
            tail[length] = arr[i];
            length++;
        } else {
            int c = ceil(tail, 0, length - 1, arr[i]);
            tail[c] = arr[i];
        }
    }

    return n - length;
}

Mindeletion C++
Meesho ✅