Company Name: McAfee
Batch eligible: 2025 and 2026 grads

1) Software Engineering Intern
Apply: https://careers.mcafee.com/global/en/job/MCAFGLOBALJR0031354ENGLOBALEXTERNAL/Software-Engineering-Intern

2) Graduate Technical Intern
Apply: https://careers.mcafee.com/global/en/job/JR0031351/Graduate-Technical-Intern

3) Graduate Technical Intern
Apply: https://careers.mcafee.com/global/en/job/JR0031352/Graduate-Technical-Intern

Drona Pay is hiring for Data Engineering - Intern  (Remote)

Experience : 0 - 1 year's
Expected Stipend : 5-6 LPA

Apply here : https://wellfound.com/jobs/3129311-data-engineering-intern

Meesho is hiring Senior Business Associate

MBA grads ( Tier l )
2023/2024 passouts

Apply Here : https://forms.gle/X6XwQ7sUq8eKeeCL8

Mokkup.ai is hiring Product Manager

For 2022, 2023, 2024 grads
Location: Remote
https://www.linkedin.com/jobs/view/4036407648

MindTickle is hiring Front-end Engineer

For 2021, 2022, 2023 grads
Location: Bangalore

https://jobs.lever.co/mindtickle/011afcfc-09da-48f6-8acc-d49a13791327/apply?source=LinkedIn

Check out this job at GrowthX®: https://www.linkedin.com/jobs/view/4042232766

Jobs at Bungee
https://bungeetech-talent.freshteam.com/jobs/_bMAyd64_HRK/data-engineer-intern-remote?ft_source=5000529098&ft_medium=5000472938

Check out this job at HoloHire: https://www.linkedin.com/jobs/view/4051629407

https://docs.google.com/forms/d/e/1FAIpQLSeyLRT0NUVM0isRGZuROAihHGa4BPE9w7BIZx0ANmfiRyhOzQ/viewform?usp=sf_link

NIT olny

nt FUNC(vector<int> &v){
    unordered_set<int> st(v.begin(),v.end());

    for(int i=0;i<31;i++){
        if(st.find(1<<i)==st.end()){
            return 1<<i;
        }
    }

    return -1;

}

Aptiv ✅

def solution(p, q, r):
    factorial_q = math.factorial(q)   
    result = pow(p, factorial_q, r)
    return result

Uber ✅

#define ll long long
#define N 110
#define MOD 1000000007
int solution(string p, string q, string r) {
    int n = p.size();
    int m = q.size();
    int k = r.size();

    // 1-indexing
    p = "*" + p;
    q = "*" + q;
    r = "*" + r;

    ll dp[N][N][N] = {};  // Initialize the dp array to zero
    dp[0][0][0] = 1;      // Base case

    // Fill the dp table
    for (int i = 0; i <= n; i++) {
        for (int j = 0; j <= m; j++) {
            for (int len = 0; len < k; len++) {
                if (dp[i][j][len]) {
                    // Check the next characters from string p
                    for (int ni = i + 1; ni <= n; ni++) {
                        if (p[ni] == r[len + 1]) {
                            dp[ni][j][len + 1] = (dp[ni][j][len + 1] + dp[i][j][len]) % MOD;
                        }
                    }
                    // Check the next characters from string q
                    for (int nj = j + 1; nj <= m; nj++) {
                        if (q[nj] == r[len + 1]) {
                            dp[i][nj][len + 1] = (dp[i][nj][len + 1] + dp[i][j][len]) % MOD;
                        }
                    }
                }
            }
        }
    }

    // Calculate the final answer
    ll ans = 0;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            ans = (ans + dp[i][j][k]) % MOD;
        }
    }

    return ans;  // Return the calculated result
}

Uber ✅

def ss(wordlist):
    a = [] 
    for word in wordlist:
        if len(word) % 2 == 0:
            a.append(word[::-1])
        else:
            a.append(word.upper())
    return a

Uber ✅

from collections import Counter
def digit_root(n):
    if n == 0:
        return 0
    return 1 + (n - 1) % 9
def ss(readings):
    reduced_readings = [digit_root(num) for num in readings]
    freq = Counter(reduced_readings)
    v = max(freq.keys(), key=lambda x: (freq[x], x))
    return v

Uber ✅

//BREAK SOME friendships
class UnionFind:
    def __init__(self, n):
        self.parent = list(range(n))
        self.rank = [0] * n

    def find(self, u):
        if self.parent[u] != u:
            self.parent[u] = self.find(self.parent[u])
        return self.parent[u]

    def unite(self, u, v):
        root_u = self.find(u)
        root_v = self.find(v)
        if root_u != root_v:
            if self.rank[root_u] > self.rank[root_v]:
                self.parent[root_v] = root_u
            elif self.rank[root_u] < self.rank[root_v]:
                self.parent[root_u] = root_v
            else:
                self.parent[root_v] = root_u
                self.rank[root_u] += 1

def solve(n, k, defaulters, m, friends):
    uf = UnionFind(n + 1)
    defaulter_set = set(defaulters)
    min_breaks = 0

    for u, v in friends:
        u_defaulter = u in defaulter_set
        v_defaulter = v in defaulter_set

        if (u_defaulter and v_defaulter) or (not u_defaulter and not v_defaulter):
            uf.unite(u, v)
        else:
            min_breaks += 1

    return min_breaks

Break some friendships ✅
Namma yatri