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 ✅

#include <iostream>
#include <vector>
using namespace std;

long getMaximumPower(vector<int>& power) {
    long max_power = *max_element(power.begin(), power.end()); // Find the maximum value in the power vector
    vector<long> power_counts(max_power + 1, 0); // Create a vector to store power counts

    for (int p : power) {
        power_counts[p] += p;
    }

    long prev_power = 0;
    long curr_power = power_counts[1];

    for (int i = 2; i <= max_power; i++) {
        long new_power = max(curr_power, prev_power + power_counts[i]);
        prev_power = curr_power;
        curr_power = new_power;
    }

    return curr_power;
}

int main() {
    // Sample Input
    vector<int> power = {1, 2, 3, 4, 5};

    // Calculate and print the maximum possible sum
    long result = getMaximumPower(power);
    cout << result << endl;

    return 0;
}

Process Execution✅

def prime(n):
    if n <= 1:
        return False
    if n <= 3:
        return True
    if n % 2 == 0 or n % 3 == 0:
        return False
    i = 5
    while i * i <= n:
        if n % i == 0 or n % (i + 2) == 0:
            return False
        i += 6
    return True

def subseq(s, i=0, c=""):
    if i == len(s):
        if not c:
            return []
        return [c]
    a = subseq(s, i+1, c + s[i])
    b = subseq(s, i+1, c)
    return a + b

def solve(b):
    s = subseq(b)
    p = [int(x, 2) for x in s if x and x[0] != '0' and prime(int(x, 2))]
    return max(p) if p else -1

print(solve("1011"))

Maximum Prime ✅