Company Name: Coding Blocks

Role: DSA Mentor (Java)

Batch eligible: 2023 and previous grads

Apply: https://www.linkedin.com/jobs/view/3716093858

P.S: Apply only if you have decent knowledge of DSA in Java language.

Congratulations to all Amazon ML Summer School selected candidates♥️

float calculate_total_amount(int count_50, int count_1, int count_2, int count_5){
    float a = count_50 * 0.50;  
    float b = count_1 * 1.00;    
    float c = count_2 * 2.00;  
    float d = count_5 * 5.00;  

    float res = a + b + c + d;

    return res;
}

bool isDancingNumber(int num) {
    string str_num = to_string(num);

    for (int i = 1; i < str_num.length(); i++) {
        int diff = abs(str_num[i] - str_num[i - 1]);
        if (diff != 1 && diff != 9) {
            return false;
        }
    }

    return true;
}

vector<int> print_dancing_numbers(int dancing_limit) {
    vector<int> dancingNumbers;

    for (int i = 0; i <= dancing_limit; i++) {
        if (isDancingNumber(i)) {
            dancingNumbers.push_back(i);
        }
    }

    return dancingNumbers;
}

string convert(string s, int numRows) {
        int n = 0;
        int i = 0;
        bool direction = true;
        map<int,vector<char>> ds;
        for(auto e:s)
        {
            ds[n].push_back(s[i]);
            if(n == numRows-1)
            {
                direction = false;
            }
            if(n == 0)
            {
                direction = true;
            }
            i++;
            if(direction)
            {
                n++;
            }
            else
            {
                n--;
            }
        }
        string ans = "";
        for(auto e:ds)
        {
            reverse(e.second.begin(),e.second.end());
            for(auto k:e.second)
            {
                ans.push_back(k);
            }
        }
        reverse(ans.begin(),ans.end());
        return ans;
    }

Company Name : Beepkart

Role : Software Engineer Internship

Batch : 2023,2024,2022 passouts

Duration : 6-9 months

Link : https://docs.google.com/forms/d/e/1FAIpQLScbkovP5Ef_sALJDgD4X81nvQ68ty8af729OyZq0NaxeLS-gg/viewform

unordered_map<string, int> memo;

int recur_cost(const vector<int>& lst, int x, int y, int pos, int curr_cost, int count) {
    int minm_cost = INT_MAX;
    string key = to_string(pos) + "|" + to_string(count);

    if (memo.find(key) != memo.end()) {
        return memo[key];
    }

    if (pos >= lst.size() && count == 0) {
        return curr_cost;
    }

    if (pos >= lst.size()) {
        return minm_cost;
    }

    if (count == 0) {
        return curr_cost;
    }

    int curr = recur_cost(lst, x, y, pos + y, lst[pos] + curr_cost, count - 1);
    int skip_curr = recur_cost(lst, x, y, pos + 1, 0, x);
    minm_cost = min(minm_cost, min(curr, skip_curr));
    memo[key] = minm_cost;
    return minm_cost;
}

int minm_rehab_cost_r(const vector<int>& lst, int x, int y) {
    memo.clear();
    return recur_cost(lst, x, y, 0, 0, x);
}

Microsoft Task 1✅

int solution(int N, vector<int>& A, vector<int>& B) {
    unordered_map<int, int> d2;

    for (int i = 0; i < N; i++) {
        d2[i] = 0;
    }

    int count = 0;
    vector<pair<int, int>> arr;
    for (int i = 0; i < A.size(); i++) {
        arr.push_back(make_pair(A[i], B[i]));
    }

    while (true) {
        for (int i = 0; i < A.size() + 1; i++) {
            for (auto c : arr) {
                if (i == c.first || i == c.second) {
                    d2[i]++;
                }
            }
        }

        vector<pair<int, int>> arr1 = arr;
        for (int i = 0; i < A.size() + 1; i++) {
            if (d2[i] <= 1) {
                arr.erase(remove_if(arr.begin(), arr.end(), [i](pair<int, int> p) {
                    return p.first == i || p.second == i;
                }), arr.end());
            }
        }

        if (arr.size() == arr1.size()) {
            return count + 1;
        }

        count++;
    }

    return 0;
}

Microsoft Task 2✅

int solution(vector<int> &v, int x, int y)
{
int n=v.size();
vector<int>dp(n+1,0);
for(int i=0;i<n;i++)
{
dp[i+1]=v[i];
if(i>=y-1)
dp[i+1]+=dp[i+1-y];
}

for(int i=0;i<=n;i++)
cout << dp[i] << " ";
cout << endl;
int len = y*(x-1);
int ans=INT_MAX;
for(int i=len+1;i<=n;i++)
{
int z=0;
if(i>=x*y)
{
z=dp[i-(x*y)];
}
ans=min(ans,dp[i]-z);
}
return ans;
}

MS Task 1

from collections import defaultdict
def solveLC(n, visitNodes, edges):
    parent = defaultdict(lambda:-1)
    G = defaultdict(list)
    for v,w in edges:
        G[v].append(w)
        G[w].append(v)
    visited = set()
    def dfs(v, u):
        if v in visited: return
        parent[v] = u
        visited.add(v)
        for w in G[v]:
            if w == u: continue
            dfs(w, v)
    dfs(1,-1)
    cores = set()
    v = n
    res = -1
    while v != -1:
        cores.add(v)
        res += 1
        v = parent[v]
    for v in visitNodes:
        tmpres = 0
        while v not in cores:
            cores.add(v)
            tmpres += 2
            v = parent[v]
        res += tmpres
    return res

Tree UI Path ✅

Company Name: Altair

Role: SDE - C++

Batch eligible: 2022 and 2023 grads

Apply: https://phh.tbe.taleo.net/phh01/ats/careers/v2/viewRequisition?org=ALTAENGI&cws=39&rid=44326

vector<int> mergeArrays(vector<int> a, vector<int> b)
{
    int n1 = a.size(), n2 = b.size();
    int i = 0, j = 0, k = 0;
    vector<int> ans(n1 + n2);
    while (i < n1 && j < n2)
    {
        if (a[i] < b[j])
            ans[k++] = a[i++];
        else
            ans[k++] = b[j++];
    }

    while (i < n1)
        ans[k++] = a[i++];
    while (j < n2)
        ans[k++] = b[j++];
    return ans;
}

Atlasian ✅

int countAnalogousArrays(vector<int>& arr, int lower, int higher) {
    ll n = arr.size() + 1;

    vector<ll> v = arr;
    vector<ll> ans(n, 0);

    for (ll i = n - 2; i >= 0; i--) {
        ans[i] = ans[i + 1] + v[i];
    }

    ll mn = INT32_MAX;
    ll mx = INT32_MIN;

    for (ll i = 0; i < n; i++) {
        mn = min(mn, ans[i]);
        mx = max(mx, ans[i]);
    }

    if (mx >= higher || mn >= higher) {
        return 0;
    }

    if (mx - mn >= higher - lower) {
        return 0;
    }

    ll new_mx = mx - mn + lower;

    return higher - new_mx + 1;
}

Atlasian ✅

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

int mod = 1e9+7;
int main() {
  int k;
  string s1,s2;
  cin >> s1>>s2 >> k;
  int n = s1.length();
  int f[1005];
  memset(f,0,sizeof(f));
  string sx = s1+s1;
  set<int> st;
  for(int i = 0;i<n;++i){
    if(sx.substr(i,n) == s2)
      st.insert(i);
    if(i != 0)
      f[i] = 1;
  }
  int sum0 = 0;
  for(int i = 0;i<n;++i)
    sum0 += f[i];
  for(int j = 2;j<=k;++j){
    int sum1 = 0;
    for(int i = 0;i<=1;++i){
      f[i] = ((sum0 - f[i])%mod + mod)%mod;
      f[i] %= mod;
    }
    sum1 =  ( (long long )f[1] * (n-1) + f[0])%mod;
    sum0 = sum1;
  }
  int sum = 0;
  for(auto x: st) {
    if(x%n == 0)
      sum += f[0];
    else
      sum += f[1];
    sum%=mod;
  }
  cout << (sum+mod)%mod <<endl;
  return 0;

}

NLP Atlasian ✅