Syvora hiring Devops Engineers

For 2024, 2023, 2022 grads

Full Time opportunity

https://www.linkedin.com/posts/rakhi-jain-8a46b41b5_hi-linkedln-people-syvora-is-hiring-for-devops-activity-7193196514175791104-xusq?utm_source=share&utm_medium=member_android

Job Title: Backend Engineer
Company: Leegality
Location: Work From Home
Grads: 2022, 2023
Job Link: https://www.instahyre.com/job-315010-backend-engineer-at-leegality-work-from-home/

Software Engineer (Backend) - Full-time - Remote at Peakflo

Batch: 2023
Expected CTC : 18-20 LPA

https://app.dover.io/apply/peakflo/31a45429-59c0-450b-8562-6f8e0753d7fc?rs=42706078

Swiggy Hiring 2023/2024 Interns

#include <iostream>
#include <string>
#include <unordered_map>

using namespace std;

long getkRepValue(string user_history, long k) {
    long n = user_history.size();
    unordered_map<char, long> count;
    long left = 0, right = 0, ans = 0;

    while (right < n) {
        count[user_history[right]]++;
        while (count[user_history[right]] >= k && left <= right) {
            ans += n - right;
            count[user_history[left]]--;
            left++;
        }
        right++;
    }

    return ans;
} 

Machine learning Amazon ✅

int solve(vector<int> tc) {
    int n = tc.size();
    vector<int> p(n), s(n);

    p[0] = tc[0];
    for (int i = 1; i < n; ++i) {
        p[i] = p[i - 1] + tc[i];
    }

    s[n - 1] = tc[n - 1];
    for (int i = n - 2; i >= 0; --i) {
        s[i] = s[i + 1] + tc[i];
    }

    int m = max(p[0], s[0]);
    for (int i = 1; i < n; ++i) {
        m = max(m, max(p[i], s[i]));
    }

    return m;
}

Amazon ✅

long Count_sol (int N, vector<int> A, vector<int> B) {
   // Write your code here
   vector<long>dp(MAXN,0);
   unordered_map<int, int>f;
   unordered_map<int, int>g;
   for(int i=0;i<N;i++)
   {
    f[A[i]]++;
    g[B[i]]++;
   }
   long ans=0;
   for(int i=100000;i>=2;--i)
   {
    int c=0;
    int d=0;
    int s=0;
    for(int j=i;j<=100000;j+=i)
    {
        c+=f[j];
        d+=g[j];
        s+=dp[j];
    }
    long pw=(long)c*d;
    pw=pw-s;
    ans+=pw;
    dp[i]=pw;
   }
   return ans;
}

Count the Pairs ✅

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

using namespace std;

int numIdleDrives(vector<int>& x, vector<int>& y) {
    int n = x.size();

    unordered_map<int, vector<int>> xMap, yMap;
    for (int i = 0; i < n; ++i) {
        xMap[y[i]].push_back(x[i]);
        yMap[x[i]].push_back(y[i]);
    }

    for (auto& pair : xMap) {
        sort(pair.second.begin(), pair.second.end());
    }

    for (auto& pair : yMap) {
        sort(pair.second.begin(), pair.second.end());
    }

    int count = 0;

    for (int i = 0; i < n; ++i) {
        int currX = x[i], currY = y[i];

        auto& yVec = xMap[currY];
        auto it1 = upper_bound(yVec.begin(), yVec.end(), currX);
        auto it2 = lower_bound(yVec.begin(), yVec.end(), currX);

        bool above = (it1 != yVec.end());
        bool below = (it2 != yVec.begin());

        auto& xVec = yMap[currX];
        it1 = upper_bound(xVec.begin(), xVec.end(), currY);
        it2 = lower_bound(xVec.begin(), xVec.end(), currY);

        bool left = (it1 != xVec.end());
        bool right = (it2 != xVec.begin());

        if (above && below && left && right) {
            count++;
        }
    }

    return count;
}

Amazon ✅

from collections import defaultdict

def Parenting(N, U, Val, V):
    characters = Val
    n = len(characters)
    edges = [(U[i], V[i]) for i in range(len(U))]
    answer = [1 for _ in range(n)]
    adj = defaultdict(list)
   
    def recurse(node, parent):
        curr_char = characters[node]
        comp = [0 for _ in range(26)]
        comp[ord(curr_char) - ord('a')] += 1
        for node_ in adj[node]:
            if node_ != parent:
                comp = merge(comp, recurse(node_, node))
        answer[node] = comp[ord(curr_char) - ord('a')]
        return comp

    def merge(arr1, arr2):
        for i, el in enumerate(arr2):
            arr1[i] += el
        return arr1

    for x, y in edges:
        adj[x-1].append(y-1)
        adj[y-1].append(x-1)

    recurse(0, -1)
    return answer

Parent Node ✅

int Arr_Diff (vector<int> arr) {
   // Write your code here
   int n=arr.size();
   int maxi=INT_MIN;
   int mini=INT_MAX;
   for(int i=0;i<n;i++)
   {
    if(arr[i]%2!=0)
    arr[i]=2*arr[i];
    maxi=max(maxi,arr[i]);
    mini=min(mini,arr[i]);
   }
   priority_queue<int>pq;
   for(int i=0;i<n;i++)
   {
    pq.push(arr[i]);
   }
   int min_dev=maxi-mini;
   int top=0;
   while(pq.top()%2==0)
   {
    top=pq.top();
    pq.pop();
    min_dev=min(min_dev,top-mini);
    mini=min(mini,top/2);
    pq.push(top/2);
   }
   top=pq.top();
   min_dev=min(min_dev,top-mini);
   return min_dev;
}

Array Difference ✅