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

// TEACH REACT

def dfs(student, graph, visited):
    visited.add(student)
    for friend_id in graph[student]:
        if friend_id not in visited:
            dfs(friend_id, graph, visited)

def solve(n, member_id, m, friends):
    graph = {}
    for u, v in friends:
        if u not in graph:
            graph[u] = []
        if v not in graph:
            graph[v] = []
        graph[u].append(v)
        graph[v].append(u)

    visited = set()
    connected_components = 0

    for student in member_id:
        if student not in visited:
            dfs(student, graph, visited)
            connected_components += 1

    return connected_components

Namma yatri ✅
Teach React

//MINIMUM TIME TO TEACH


from collections import deque, defaultdict

def solve(n, member_id, m, friends, k):
    graph = defaultdict(list)
    for u, v in friends:
        graph[u].append(v)
        graph[v].append(u)

    q = deque([k])
    level = {k: 0}
    visited = {k}
    max_time = 0

    while q:
        current = q.popleft()
        max_time = max(max_time, level[current])

        for neighbor in graph[current]:
            if neighbor not in visited:
                visited.add(neighbor)
                level[neighbor] = level[current] + 1
                q.append(neighbor)

    if len(visited) != n:
        return -1

    return max_time

Namma Yatri ✅
Minimum time to reach

Who gave the Uber OA today how was the experience? How many questions were you able to solve?

Amazon is hiring IT Support Associate

For 2022, 2023, 2024 grads
Location: Bangalore

https://www.amazon.jobs/en/jobs/2809212/it-support-associate