class Solution {
public:
            vector<int> countServers(int N, vector<vector<int>>& L, int x, vector<int>& Q) {
        vector<int> idx, res(Q.size(), 0);
        for(int i = 0; i < Q.size(); i++) idx.push_back(i);
        sort(begin(idx), end(idx), [&](auto a, auto b) {return Q[a] < Q[b];});
        sort(begin(L), end(L), [](auto &a, auto &b) {return a[1] < b[1];});
        int p0 = 0, p1 = 0, cnt = 0;
        unordered_map<int, int> mp;
        for(int i = 0; i < idx.size(); i++) {
            while(p1 < L.size() && L[p1][1] <= Q[idx[i]]) if(++mp[L[p1++][0]] == 1) cnt++;
            while(p0 < L.size() && L[p0][1] < Q[idx[i]]-x) if(--mp[L[p0++][0]] == 0) cnt--;
            res[idx[i]] = N - cnt;
        }
        return res;
            }
};

Meesho ✅

int mincost(vector<int> &pods,vector<int> &cost){
  map<int,multiset<int>> mp;
  for(int i=0;i<pods.size();i++){
    mp[pods[i]].insert(cost[i]);
  }
  int ans = 0;
  int curr = (*mp.begin()).first,sm = 0;
  multiset<int> se;
  while(1){
    if(se.size()==0){
      if(mp.lower_bound(curr) == mp.end()) break;
      curr = (*mp.lower_bound(curr)).first;
    }

    if(mp.find(curr) != mp.end())
    for(auto &x:mp[curr]){
        se.insert(x);
        sm += x;
    }

    auto it = se.end();
    it--;
    sm -= *it;
    ans += sm;
    se.erase(it);
    curr++;
  }

  return ans;
}

Meesho ✅

def is_possible(network_nodes, network_from, network_to):
    from collections import defaultdict
   
    tree = defaultdict(list)
    for i in range(len(network_from)):
        tree[network_from[i]].append(network_to[i])
        tree[network_to[i]].append(network_from[i])
   
    result = ['0'] * (network_nodes + 1)
   
    def dfs(node, parent):
        paired = False
        for child in tree[node]:
            if child != parent:
                if not dfs(child, node):
                    if paired:
                        return False
                    paired = True
        if paired:
            result[node] = '1'
            return True
        return False
   
    dfs(1, -1)
   
    return ''.join(result[1:])

network_nodes = 4
network_from = [3,2,1]
network_to = [4,4,2]
print(is_possible(network_nodes, network_from, network_to))

//messho 3

int mincost(vector<int> &pods,vector<int> &cost){
  map<int,multiset<int>> mp;
  for(int i=0;i<pods.size();i++){
    mp[pods[i]].insert(cost[i]);
  }
  int ans = 0;
  int curr = (*mp.begin()).first,sm = 0;
  multiset<int> se;
  while(1){
    if(se.size()==0){
      if(mp.lower_bound(curr) == mp.end()) break;
      curr = (*mp.lower_bound(curr)).first;
    }

    if(mp.find(curr) != mp.end())
    for(auto &x:mp[curr]){
        se.insert(x);
        sm += x;
    }

    auto it = se.end();
    it--;
    sm -= *it;
    ans += sm;
    se.erase(it);
    curr++;
  }

  return ans;
}

// Meesho 2

package client;

import java.util.Arrays;
import java.util.Scanner;

public class HackerRank1 {
    public static String text = "engine";
    public static String prefix = "raven";
    public static String suffix = "ginkgo";

    public static void main(String[] args) {
        String result = calculateScore(text, prefix, suffix);
        System.out.println(result);
    }

    static String calculateScore(String text, String prefix, String suffix) {
        int max = 0;
        int max_pre  = 0;
        String result = "";

        for (int i = 0; i < text.length(); i++) {
            for (int j = i + 1; j <= text.length(); j++) {
                String subStr = text.substring(i, j);
                int pre = findPreLength(subStr, prefix);
                int post = findPostLength(subStr, suffix);

                if(max < (pre + post)) {
                    max = pre + post;
                    result = subStr;
                    max_pre = pre;
                }
                else if(max == pre + post){
                    if(pre > max_pre) {
                        max_pre = pre;
                        result = subStr;
                    }
                    else{
                        String[] arr = {result,subStr};
                        Arrays.sort(arr);
                        if(arr[0].equals(subStr)){
                            result = subStr;
                            max_pre = pre;
                        }
                    }
                }


            }
        }
        return result;
    }


    private static int findPostLength(String subStr, String suffix) {
        int max = 0;
        for (int i = 0; i < subStr.length(); i++) {
            int len = 0;
            String str = subStr.substring(i);
            int k =0;
            for (int j = 0; j <suffix.length() && k < str.length(); j++, k++) {
                if (str.charAt(k) == suffix.charAt(j))
                    len++;
                else
                    break;
            }
            if (len > max && k == str.length())
                max = len;
        }
        return max;
    }


    private static int findPreLength(String subStr, String prefix) {
        int max = 0;
        for (int i = 1; i < subStr.length() + 1; i++) {
            int len = 0;
            int j = prefix.length() - 1;
            String str = subStr.substring(0, i);
            int k =str.length() - 1;

            for (; j >= 0 && k >=0; j--, k--) {
                if (str.charAt(k) == prefix.charAt(j))
                    len++;
                else
                    break;
            }
            if (len > max && k == -1)
                max = len;
        }
        return max;
    }
}

Meesho ✅

Company Name: Hinge Health

🛄 Job Title: Software Engineer Intern
✍🏻 YOE: 2025 grads

➡️ Apply: https://jobs.lever.co/hingehealth/735ce79b-221d-4a08-8218-f6de5055c101/

Please do share in your college grps and in case you are applying please react on this post:) 😇❤️

def getAnagramPeriod(s):
    n = len(s)
    for i in range(1, n + 1):
        if n % i == 0:
            period = s[:i]
            if sorted(period * (n // i)) == sorted(s):
                return i
    return n

static String divideParticipants(int N, int[] strengths) {
        if (N % 2 != 0) {
            return "-1";
        }
       
        int[][] dp = new int[N][2];
        int[][] parent = new int[N][2];
       
        dp[0][0] = strengths[0];
        dp[0][1] = -strengths[0];
       
        for (int i = 1; i < N; i++) {
            if (dp[i-1][0] != Integer.MIN_VALUE) {
                dp[i][0] = strengths[i] + dp[i-1][1];
                parent[i][0] = 1;
            }
            if (dp[i-1][1] != Integer.MIN_VALUE) {
                dp[i][1] = -strengths[i] + dp[i-1][0];
                parent[i][1] = 0;
            }
        }
       
        if (dp[N-1][0] == Integer.MIN_VALUE || dp[N-1][1] == Integer.MIN_VALUE) {
            return "-1";
        }
       
        char[] result = new char[N];
        int current = dp[N-1][0] >= dp[N-1][1] ? 0 : 1;
       
        for (int i = N-1; i >= 0; i--) {
            result[i] = current == 0 ? 'R' : 'D';
            current = parent[i][current];
        }
       
        return new String(result);
    }

Uber ✅

Who have Adobe exam guys tomorrow solutions will be provide

Anyone give exam send question here

import heapq

def max_skill(s, n, d, problems):
    problems.sort()
   
    max_heap = []
    max_index = 0
   
    while d > 0:
        while max_index < n and problems[max_index][0] <= s:
            heapq.heappush(max_heap, (-problems[max_index][1], problems[max_index][0]))
            max_index += 1
       
        if not max_heap:
            break
       
        best_gain = -heapq.heappop(max_heap)[0]
        s += best_gain
        d -= 1
   
    return s

Adobe ✅

from collections import defaultdict, Counter

def count_good_edges(n, k, values, edges):
    tree = defaultdict(list)
    for u, v in edges:
        tree[u].append(v)
        tree[v].append(u)
   
    subtree_freq = [Counter() for _ in range(n + 1)]
   
    def dfs(node, parent):
        subtree_freq[node][values[node-1]] += 1
        for neighbor in tree[node]:
            if neighbor != parent:
                dfs(neighbor, node)
                for val, count in subtree_freq[neighbor].items():
                    subtree_freq[node][val] += count
   
    dfs(1, -1)
   
    good_edges_count = 0
   
    for u, v in edges:
        if subtree_freq[v][values[v-1]] > subtree_freq[u][values[u-1]]:
            u, v = v, u
        subtree_values = subtree_freq[v]
        other_subtree_values = subtree_freq[1] - subtree_values
       
        if all(count <= k for count in subtree_values.values()) and all(count <= k for count in other_subtree_values.values()):
            good_edges_count += 1
   
    return good_edges_count

Adobe ✅

#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;
class Solution {
public:
    int countGoodEdge(int n, int k, vector<int>& values, vector<vector<int>>& edges) {
        vector<vector<int>> adj(n + 1);
        for (auto& edge : edges) {
            adj[edge[0]].push_back(edge[1]);
            adj[edge[1]].push_back(edge[0]);
        }
       
        vector<unordered_map<int, int>> subtreeFreq(n + 1);
        unordered_map<int, int> totalFreq;
        dfs1(1, -1, values, adj, subtreeFreq, totalFreq);
        int goodEdges = 0;
        dfs2(1, -1, values, adj, subtreeFreq, totalFreq, k, goodEdges);
       
        return goodEdges;
    }

private:
    void dfs1(int node, int parent, vector<int>& values, vector<vector<int>>& adj,
              vector<unordered_map<int, int>>& subtreeFreq, unordered_map<int, int>& totalFreq) {
        subtreeFreq[node][values[node - 1]]++;
        totalFreq[values[node - 1]]++;

        for (int neighbor : adj[node]) {
            if (neighbor != parent) {
                dfs1(neighbor, node, values, adj, subtreeFreq, totalFreq);
                for (auto& kv : subtreeFreq[neighbor]) {
                    subtreeFreq[node][kv.first] += kv.second;
                }
            }
        }
    }

    void dfs2(int node, int parent, vector<int>& values, vector<vector<int>>& adj,
              vector<unordered_map<int, int>>& subtreeFreq, unordered_map<int, int>& totalFreq,
              int k, int& goodEdges) {
        for (int neighbor : adj[node]) {
            if (neighbor != parent) {
                bool isGood = true;
               
                for (auto& kv : subtreeFreq[neighbor]) {
                    if (kv.second > k) {
                        isGood = false;
                        break;
                    }
                }
                for (auto& kv : totalFreq) {
                    if (kv.second - subtreeFreq[neighbor][kv.first] > k) {
                        isGood = false;
                        break;
                    }
                }
               
                if (isGood) {
                    goodEdges++;
                }
               
                dfs2(neighbor, node, values, adj, subtreeFreq, totalFreq, k, goodEdges);
            }
        }
    }
};

Count Good Edge ✅
Adobe

what your opinion guys 😂

#include <iostream>
#include <vector>
#include <queue>
#include <climits>
using namespace std;
class Solution {
public:
int getMinWeight(int u, int v, const vector<int>& weight, const vector<vector<int>>& adj) {
        if (u == v) return weight[u];
        vector<bool> visited(adj.size(), false);
        vector<int> minWeight(adj.size(), INT_MAX);
        queue<int> q;
       
        q.push(u);
        visited[u] = true;
        minWeight[u] = weight[u];

        while (!q.empty()) {
            int node = q.front();
            q.pop();

            for (int neighbor : adj[node]) {
                if (!visited[neighbor]) {
                    visited[neighbor] = true;
                    minWeight[neighbor] = min(minWeight[node], weight[neighbor]);
                    q.push(neighbor);

                    if (neighbor == v) {
                        return minWeight[v];
                    }
                }
            }
        }

        return -1;
    }

    long long goodSubarrays(int n, int x, const vector<int>& weight, const vector<vector<int>>& edges) {
        vector<vector<int>> adj(n);
        for (const auto& edge : edges) {
            int u = edge[0];
            int v = edge[1];
            adj[u].push_back(v);
            adj[v].push_back(u);
        }

        long long totalSum = 0;
        for (int i = 0; i < n; ++i) {
            for (int j = i + 1; j < n; ++j) {
                totalSum += getMinWeight(i, j, weight, adj);
            }
        }

        return totalSum;
    }
}; 

// MINIMUM SUM
Adobe ✅