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) ✅

Don't apply for jobs at Workday and
Prefer applying for jobs at platforms like greenhouse, LinkedIn, lever, indeed or Glassdoor.

Your job application process should scale easily and one application shouldn't take more than 2 min to apply.

Workday sucks at scalability, Better to ignore it.🙌