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 ✅

ll solve(vector<int> &arr){
    int n=arr.size();
    vector<ll> pf(n),sf(n);
    pf[0]=arr[0];
    sf[n-1]=arr[n-1];
    for(int i=1;i<n;i++) pf[i]=arr[i]+pf[i-1];
    for(int i=n-2;i>=0;i--) sf[i]=arr[i]+sf[i+1];
    ll sm=0,mn=0;
    ll mx=-1e18;
    for(int i=0;i<n;i++){
        sm+=arr[i];
        if(sm>0) sm=0;
        mn=min(mn,sm);
        mx=max(mx,pf[i]-2*mn-(i<n-1?sf[i+1]:0));
    }
    return mx;
}

Subarray sums ✅

int n;
    cin>>n;
    int starts[n+1];
    for(int i=0;i<n;i++){
        cin>>starts[i];
    }
    int d;
    cin>>d;
    int l=0,r=100000;
    while(l<r){
        int mid=(l+r+1)>>1;
        int ans=1;
        int pr=0;
        for(int i=0;i<n;i++){
            if(pr>starts[i]+d){
                ans=0;
            }else{
                pr=max(pr+mid,starts[i]);
            }
        }
        if(ans){
            l=mid;
        }else{
            r=mid-1;
        }
    }
    cout<<l;

Range Selection ✅

Array Transformation ✅