Company : Stripe
Batch : 2025
Role : SWE-New Grad

For School Name if not available use Other.

Apply : https://stripe.com/jobs/listing/software-engineer-new-grad/6172694

Company Name: Park+
Role: Frontend Intern
Batch eligible: 2025 and 2026 grads

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

Internship in Germany
Fully Funded
https://apply.cis.mpg.de/register/internship

int getDistance(string word){
    unordered_map<char , pair<int,int>> mpp;
    mpp['Q'] = {0, 0};
    mpp['W'] = {0, 1};
    mpp['E'] = {0, 2};
    mpp['R'] = {0, 3};
    mpp['T'] = {0, 4};
    mpp['Y'] = {0, 5};
    mpp['U'] = {0, 6};
    mpp['I'] = {0, 7};
    mpp['O'] = {0, 8};
    mpp['P'] = {0, 9};

    mpp['A'] = {1, 0};
    mpp['S'] = {1, 1};
    mpp['D'] = {1, 2};
    mpp['F'] = {1, 3};
    mpp['G'] = {1, 4};
    mpp['H'] = {1, 5};
    mpp['J'] = {1, 6};
    mpp['K'] = {1, 7};
    mpp['L'] = {1, 8};

    mpp['Z'] = {2, 1};
    mpp['X'] = {2, 2};
    mpp['C'] = {2, 3};
    mpp['V'] = {2, 4};
    mpp['B'] = {2, 5};
    mpp['N'] = {2, 6};
    mpp['M'] = {2, 7};
    int result= 0;
    pair<int,int> cur = {0,0};
    for (char x : word){
        result = result + abs(cur.first-mpp[x].first) + abs(cur.second-mpp[x].second);
        cur = mpp[x];
    }

    return result;
}

Typing Distance
Hackerrank ✅

def getDistance(word):
    m = {c: (r, i + (1 if r == 2 else 0)) 
         for r, row in enumerate(["QWERTYUIOP", "ASDFGHJKL", "ZXCVBNM"]) 
         for i, c in enumerate(row)}
    total, pos = 0, m['Q']
    for c in word:
        p = m[c]
        total += abs(pos[0] - p[0]) + abs(pos[1] - p[1])
        pos = p
    return total

Typing Distance ✅

Send your latest CV to info@drobospacex.com

Contact: 9442159128, 9489910176

💻 Apply: https://docs.google.com/forms/d/e/1FAIpQLSd0WlFMyAOWSCWXJit8U-aDeEv1IZhZt1-PzDUS9qj7ezxRCQ/viewform

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

const int INF = INT_MAX;

vector<int> dijkstra(int s, int n, const vector<vector<pair<int, int>>>& adj) {
    vector<int> d(n + 1, INF);
    d[s] = 0;
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
    pq.push({0, s});

    while (!pq.empty()) {
        int cd = pq.top().first;
        int u = pq.top().second;
        pq.pop();

        if (cd > d[u]) continue;

        for (const auto& nbr : adj[u]) {
            int v = nbr.first;
            int w = nbr.second;

            if (d[u] + w < d[v]) {
                d[v] = d[u] + w;
                pq.push({d[v], v});
            }
        }
    }
    return d;
}

int minCostPath(int n, vector<int>& from, vector<int>& to, vector<int>& w, int x, int y) {
    vector<vector<pair<int, int>>> adj(n + 1);
    for (int i = 0; i < from.size(); i++) {
        int u = from[i], v = to[i], wt = w[i];
        adj[u].push_back({v, wt});
        adj[v].push_back({u, wt});  
    }

    vector<int> ds = dijkstra(1, n, adj);
    vector<int> dx = dijkstra(x, n, adj);
    vector<int> dy = dijkstra(y, n, adj);
    int min_cost = ds[x] + dx[y] + dy[n];

    return min_cost;
}

Two junctions ✅

def countGroups(tags, queries):
    from collections import defaultdict
    res = []
    for l, r in queries:
        c = defaultdict(int)
        for i in range(l-1, r):
            c[tags[i]] += 1
        cnt = sum(v // 2 for v in c.values())
        res.append(cnt)
    return res

Twillo (intern) ✅

def counts(a, b):
    a.sort()
    res = []
    for x in b:
        l, r = 0, len(a)
        while l < r:
            mid = (l + r) // 2
            if a[mid] <= x:
                l = mid + 1
            else:
                r = mid
        res.append(l)
    return res

Twillo (Intern) ✅

import heapq

def solve(n,m,size,taste):
dishes = sorted(zip(taste,size),reverse=True)
pq = []
res, sizeSum = 0 , 0
for t,s in dishes :
heapq.heappush(pq,s)
sizeSum += s
if len(pq) > m :
sizeSum -= heapq.heappop(pq)
performance = sizeSum*t
res = max(res,performance)
return res

Tasty Dishes ✅

Company Name: Meesho
Role: Data Science Intern
Batch eligible: 2025 and 2026 grads

Apply: https://docs.google.com/forms/d/e/1FAIpQLScTnsGrLT2SQGiJKInMNjnAKu8MNQgqTc3Pg-EMa_IY_ApwqQ/viewform

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

bool check(int K, const vector<int> &B, int C)
{
    int A = B.size();
    vector<int> S(A);
    for (int i = 0; i < A; ++i)
    {
        S[i] = (B[i] >= K) ? 1 : -1;
    }
    vector<int> P(A + 1, 0);
    for (int i = 1; i <= A; ++i)
    {
        P[i] = P[i - 1] + S[i - 1];
    }
    int min_prefix = 0;
    for (int i = C; i <= A; ++i)
    {
        min_prefix = min(min_prefix, P[i - C]);
        if (P[i] - min_prefix > 0)
        {
            return true;
        }
    }
    return false;
}

int solve(int A, const vector<int> &B, int C)
{
    int Left = 1, Right = A;
    int answer = A; 
    while (Left <= Right)
    {
        int Mid = (Left + Right) / 2;
        if (check(Mid, B, C))
        {
            answer = A - (Mid - 1);
            Left = Mid + 1;
        }
        else
        {
            Right = Mid - 1;
        }
    }
    if (answer > A)
    {
        answer = A;
    }
    return answer;
}

int main()
{
    int A = 5;
    cin >> A;

    vector<int> B(A) ;
    for(auto &i:B) cin>>i;
    int C = 3;
    cin>>C;
    cout << solve(A, B, C) << endl;

    return 0;
}

Trilogy
Book Collector ✅

int solution(vector<int> arr, vector<vector<int>> mat) {
int totalUpdates = 0;
    int n = arr.size();
   
    for (const auto &query : mat) {
        int X = query[0] - 1;
        int Y = query[1];
        int Z = query[2];

        int bitMask = (1 << (Y - 1));

        int endIndex = X;
        while (endIndex < n && (arr[endIndex] & bitMask)) {
            endIndex++;
        }
       
        int sizeToUpdate = endIndex - X;
       
        if (sizeToUpdate > 0) {
            for (int i = X; i < endIndex; ++i) {
                arr[i] ^= Z;
            }
            totalUpdates += sizeToUpdate;
        }
    }
   
    return totalUpdates;
}

Xor(Trilogy)✅

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

const int MOD = 1e9 + 7;
typedef vector<vector<long long>> Matrix;
Matrix multiply(const Matrix &A, const Matrix &B) {
    int n = A.size();
    Matrix result(n, vector<long long>(n, 0));
    for (int i = 0; i < n; ++i) {
        for (int k = 0; k < n; ++k) {
            if (A[i][k]) {
                for (int j = 0; j < n; ++j) {
                    result[i][j] = (result[i][j] + A[i][k] * B[k][j]) % MOD;
                }
            }
        }
    }
    return result;
}

Matrix matrix_power(Matrix base, long long exponent) {
    int n = base.size();
    Matrix result(n, vector<long long>(n, 0));
    for (int i = 0; i < n; ++i)
        result[i][i] = 1;

    while (exponent > 0) {
        if (exponent % 2 == 1)
            result = multiply(result, base);
        base = multiply(base, base);
        exponent /= 1LL << 1;
    }
    return result;
}

int solve(long long A, int B, int C) {
    if (A == 0)
        return 0;
    vector<long long> S0(B, 0);
    S0[0] = C % MOD;
    Matrix M(B, vector<long long>(B, 0));

    for (int k = 0; k < B; ++k) {
        if (k + 1 < B) {
            M[k][k + 1] = 1;
        }
        M[k][0] = (C - 1) % MOD;
    }
    Matrix M_power = matrix_power(M, A - 1);
    vector<long long> S(B, 0);
    for (int i = 0; i < B; ++i) {
        for (int j = 0; j < B; ++j) {
            S[i] = (S[i] + S0[j] * M_power[j][i]) % MOD;
        }
    }
    long long total = 0;
    for (int i = 0; i < B; ++i) {
        total = (total + S[i]) % MOD;
    }

    return (int)total;
}

Valid Array (Trilogy) ✅