int solution(vector<int>& A, vector<int>& B) {
    int n = A.size();
    vector<vector<int>> graph(n + 1);
    vector<bool> visited(n + 1, false);
    int count = 0;
    unordered_map<string, int> directions;

    for (int i = 0; i < n; ++i) {
        graph[A[i]].push_back(B[i]);
        graph[B[i]].push_back(A[i]);
        string directionKey = to_string(A[i]) + "->" + to_string(B[i]);
        directions[directionKey] = 0;
    }

    function<void(int)> dfs = [&](int city) {
        visited[city] = true;
        for (int neighbor : graph[city]) {
            if (visited[neighbor]) {
                continue;
            }
            string changedDirectionKey = to_string(neighbor) + "->" + to_string(city);
            if (directions.find(changedDirectionKey) == directions.end()) {
                count++;
            }
            dfs(neighbor);
        }
    };

    dfs(0);

    return count;
}

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
vector<int> row, col;
void dfs(vector<vector<int>>& matrix, vector<vector<bool>>& visited, int x, int y)
{
    int rows = matrix.size();
    int cols = matrix[0].size();
    visited[x][y] = true;
    for (int k = 0; k < row.size(); ++k)
    {
        int newX = x + row[k];
        int newY = y + col[k];
  if (newX >= 0 && newX < rows && newY >= 0 && newY < cols && matrix[newX][newY] == 1 && !visited[newX][newY])
  {
            dfs(matrix, visited, newX, newY);
        }
    }
}

int hello(vector<vector<int>>& matrix, int adj)
{
    int rows = matrix.size();
    int cols = matrix[0].size();
    vector<vector<bool>> visited(rows, vector<bool>(cols, false));
    int count = 0;
    for (int i = 0; i < rows; ++i)
    {
        for (int j = 0; j < cols; ++j)
        {
            if (matrix[i][j] == 1 && !visited[i][j])
            {
                count++;
                dfs(matrix, visited, i, j);
            }
        }
    }
    return count;
}

int main() {
    int adj, rows, cols;
    cin >> adj;
    cin >> rows >> cols;
   
    vector<vector<int>> matrix(rows, vector<int>(cols));
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            cin >> matrix[i][j];
        }
    }
    if (adj == 1) {
        row = {0, 0};
        col = {-1, 1};
    } else if (adj == 2) {
        row = {-1, 1};
        col = {0, 0};
    } else if (adj == 3) {
        row = {-1, -1, 1, 1};
        col = {-1, 1, -1, 1};
    } else if (adj == 4) {
        row = {0, 0, -1, 1};
        col = {-1, 1, 0, 0};
    } else if (adj == 5) {
        row = {-1, -1, -1, 0, 0, 1, 1, 1};
        col = {-1, 0, 1, -1, 1, -1, 0, 1};
    }

    int result = hello(matrix, adj);
    cout << result << endl;

    return 0;
}

HPC programming ✅

https://registration.techmahindra.com/Candidate/RegDefault.aspx

Only 2024 Batch
Apply Asap

Who have Uber, Sprinklr, DE Shaw exam guys?
Send questions here solutions will be provide

def solve(N, M, A):
    from functools import lru_cache
    import sys
   
    @lru_cache(None)
    def dp(mask):
        if mask == 0:
            return 0
        res = sys.maxsize
        for i in range(N):
            if mask & (1 << i):
                for j in range(M):
                    res = min(res, A[i][j] | dp(mask ^ (1 << i)))
        return res
   
    full_mask = (1 << N) - 1
    return dp(full_mask)

# Input reading
if name == "main":
    import sys
    input = sys.stdin.read
    data = input().split()
   
    N = int(data[0])
    M = int(data[1])
    A = []
    idx = 2
    for i in range(N):
        A.append(list(map(int, data[idx:idx + M])))
        idx += M
   
    print(solve(N, M, A))

Minimum possible sum ✅

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

int solve(string s){
    unordered_map<char, vector<int>> mp;
    for(int i=0;i<s.size();i++){
        mp[s[i]].push_back(i);
    }
    int first=0;
    int last=0;
    int ans=0;
    for(int i=0;i<s.size();i++){
      //  cout<<first<<" "<<last<<endl;
        if((mp[s[i]][mp[s[i]].size()-1])>=last){
           if(mp[s[i]][0]>first && mp[s[i]][0]>last){
            int temp=last-first+1;
            first=mp[s[i]][0];
             last=mp[s[i]][mp[s[i]].size()-1];
             ans+=temp*temp;

           }
           else{
                last=mp[s[i]][mp[s[i]].size()-1];
             
           }
        }
      
    }
    int temp=last-first+1;
    ans+=(temp)*temp;
    return ans;

   
}


int32_t main() {
   string s;
    cin >> s;
    int ans=solve(s);
    cout << ans << endl;
    return 0;
}. 

SLICE MASTER 
Sprinklr ✅

class DisjointSet {
    vector<int>rank, parent, size;
public:
    DisjointSet(int n) {
        rank.resize(n + 1, 0);
        parent.resize(n + 1);
        size.resize(n + 1, 1);
        for (int i = 0; i <= n; i++) {
            parent[i] = i;
        }
    }

    int findUPar(int node) {
        if (node == parent[node])
            return node;
        return parent[node] = findUPar(parent[node]);
    }

    void unionBySize(int u, int v) {
        int ulp_u = findUPar(u);
        int ulp_v = findUPar(v);
        if (ulp_u == ulp_v)return;
        if (size[ulp_u] < size[ulp_v]) {
            parent[ulp_u] = ulp_v;
            size[ulp_v] += size[ulp_u];
        }
        else {
            parent[ulp_v] = ulp_u;
            size[ulp_u] += size[ulp_v];
        }

    }

};

int solve(vector<string>& v) {
    int n = v.size();
    DisjointSet ds(n);
    vector<int>prev(26, -1);
    for (int i = 0; i < n; ++i)
    {
        for (auto it : v[i]) {
            if (prev[it - 'a'] == i)continue;
            if (prev[it - 'a'] != -1)
                ds.unionBySize(i, prev[it - 'a']);
            prev[it - 'a'] = i;
        }
    }
    set<int>st;
    for (int i = 0; i < n; ++i)
    {
        int val = ds.findUPar(i);
        st.insert(val);
    }
    int res = st.size();
    return res;
}.

UBER OTP✅

#include <iostream>
#include <vector>
using namespace std;
class FenwickTree {
private:
    vector<long long> tree;
    int n;
   
public:
    FenwickTree(int size) : n(size), tree(size + 1, 0) {}
   
    void update(int index, int value) {
        while (index <= n) {
            tree[index] += value;
            index += index & -index;
        }
    }
   
    long long query(int index) {
        long long sum = 0;
        while (index > 0) {
            sum += tree[index];
            index -= index & -index;
        }
        return sum;
    }
};

int main() {
    int N;
    cin >> N;
   
    vector<int> marks(N + 1);
    FenwickTree fenwickTree(N);
   
    for (int i = 1; i <= N; ++i) {
        cin >> marks[i];
        fenwickTree.update(i, marks[i]);
    }
   
    int Q;
    cin >> Q;
   
    for (int i = 0; i < Q; ++i) {
        int type;
        cin >> type;
       
        if (type == 1) {
            int X, Y;
            cin >> X >> Y;
            int diff = Y - marks[X];
            marks[X] = Y;
            fenwickTree.update(X, diff);
        } else if (type == 2) {
            int K;
            cin >> K;
            cout << fenwickTree.query(K) << endl;
        }
    }
   
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int helper(vector<vector<int>>& grid, int N, int M) {
vector<vector<pair<int, bool>>> dp(N, vector<pair<int, bool>>(M, {0, false}));
    dp[0][0] = {grid[0][0], (grid[0][0] == 2 || grid[0][0] == -3)};
    for (int i = 0; i < N; ++i) {
    for (int j = 0; j < M; ++j) {
    if (i == 0 && j == 0) continue;
    int max = -1;
    bool has = false;
    if (i > 0) {
    int val = dp[i-1][j].first + grid[i][j];
    bool special = dp[i-1][j].second (grid[i][j] == 2 grid[i][j] == -3);
    if (val > max) {
     max = val;
    has = special;
      }
     }
    if (j > 0) {
    int val = dp[i][j-1].first + grid[i][j];
    bool special = dp[i][j-1].second (grid[i][j] == 2 grid[i][j] == -3);
    if (val > max) {
    max = val;
    has = special;
   }
  }
  dp[i][j] = {max, has};
        }
    }
    int result = dp[N-1][M-1].second ? dp[N-1][M-1].first : 0;
    return result - (dp[N-1][M-1].second ? (grid[N-1][M-1] == 2 || grid[N-1][M-1] == -3 ? grid[N-1][M-1] : 0) : 0);
}

int main() {
    int N, M;
    cin >> N >> M;
    vector<vector<int>> grid(N, vector<int>(M));
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < M; ++j) {
            cin >> grid[i][j];
        }
    }
    int result = helper(grid, N, M);
    cout << result << endl;
    return 0;
}

Space explorer✅

import java.util.Scanner;

public class Main {
   
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
       
        int N = scanner.nextInt();
       
        int[][] S = new int[N][N];
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                S[i][j] = scanner.nextInt();
            }
        }
       

        long[] dp = new long[1 << N];
       
        for (int mask = 0; mask < (1 << N); mask++) {
            for (int i = 0; i < N; i++) {
                if ((mask & (1 << i)) != 0) {
                    for (int j = i + 1; j < N; j++) {
                        if ((mask & (1 << j)) != 0) {
                            dp[mask] += S[i][j];
                        }
                    }
                }
            }
        }
       
       long result = 0;
        for (int mask = 0; mask < (1 << N); mask++) {
            result = Math.max(result, dp[mask]);
        }
       
   }
}

Uber ✅