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 ✅

#define ll long long

ll f(vector<int> &a, int n, int x){
    map<ll, ll> mp;
    ll ans = 0, i = 0, j = -1, cur = 0;
    while(i < n){
        while(j + 1 < n && (cur < x || (cur == x && mp[a[j + 1]] != 2))){
            mp[a[++j]]++;
            if(mp[a[j]] == 3) cur++;
        }
        ans += (j - i + 1);

        if(i <= j){
            if(mp[a[i]] == 3) cur--;
            mp[a[i++]]--;
        }else i++, j++;
    }
    return ans;
}
long long goodsub(int n, int x, vector<int> arr){
    return f(arr, n, x) - f(arr, n, x - 1);
}

Good Subarray
Adobe ✅

#include <iostream>
#include <vector>
#include <algorithm>
#include <limits>
#include <cmath>

using namespace std;

const int MAXN = 1000;
const int LOG = 20;

vector<int> graph[MAXN];
vector<int> euler, depth, first_occurrence;
vector<vector<int>> min_weight;
int node_weight[MAXN];
int parent[MAXN];
int n;

void dfs(int v, int p, int d) {
    parent[v] = p;
    first_occurrence[v] = euler.size();
    euler.push_back(v);
    depth.push_back(d);
   
    for (int u : graph[v]) {
        if (u != p) {
            dfs(u, v, d + 1);
            euler.push_back(v);
            depth.push_back(d);
        }
    }
}

void build_rmq() {
    int m = euler.size();
    min_weight.assign(m, vector<int>(LOG, -1));

    for (int i = 0; i < m; ++i) {
        min_weight[i][0] = euler[i];
    }

    for (int j = 1; (1 << j) <= m; ++j) {
        for (int i = 0; (i + (1 << j) - 1) < m; ++i) {
            int left = min_weight[i][j - 1];
            int right = min_weight[i + (1 << (j - 1))][j - 1];
            min_weight[i][j] = (depth[first_occurrence[left]] < depth[first_occurrence[right]]) ? left : right;
        }
    }
}

int query_rmq(int l, int r) {
    int j = log2(r - l + 1);
    int left = min_weight[l][j];
    int right = min_weight[r - (1 << j) + 1][j];
    return (depth[first_occurrence[left]] < depth[first_occurrence[right]]) ? left : right;
}

int get_lca(int u, int v) {
    int left = first_occurrence[u];
    int right = first_occurrence[v];
    if (left > right) swap(left, right);
    return query_rmq(left, right);
}

int get_min_weight(int u, int v) {
    int lca = get_lca(u, v);
    int min_w = node_weight[lca];
    int current = u;

    while (current != lca) {
        min_w = min(min_w, node_weight[current]);
        current = parent[current];
    }

    current = v;
    while (current != lca) {
        min_w = min(min_w, node_weight[current]);
        current = parent[current];
    }

    return min_w;
}

int sum_of_min_weights() {
    int total_sum = 0;
    for (int i = 0; i < n; ++i) {
        for (int j = i + 1; j < n; ++j) {
            total_sum += get_min_weight(i, j);
        }
    }
    return total_sum;
}

int main() {
    n = 5;
    vector<pair<int, int>> edges = {{0, 1}, {1, 2}, {0, 4}, {2, 3}};
    vector<int> input_weights = {6, 1, 2, 5, 3};

    for (int i = 0; i < n; ++i) {
        node_weight[i] = input_weights[i];
    }

    for (const auto& edge : edges) {
        graph[edge.first].push_back(edge.second);
        graph[edge.second].push_back(edge.first);
    }

    first_occurrence.resize(n);
    depth.reserve(2 * n);
    euler.reserve(2 * n);

    dfs(0, -1, 0);
    build_rmq();

    cout << "Sum of minimum weights: " << sum_of_min_weights() << endl;

    return 0;
}

Minimum Sum ✅
Adobe

Happy Weekend 😂🙈

Affected by Blue 🔵 Screen Error?
Due to the CrowdStrike Update 💀

public static int minTimeToSolvePuzzles(int n, int[] time, int[] search, int k) {
        int[] dp = new int[n + 1];
        Arrays.fill(dp, Integer.MAX_VALUE);
        dp[0] = 0;

        for (int i = 1; i <= n; i++) {
            dp[i] = dp[i - 1] + time[i - 1];
           
            for (int j = 1; j <= k && i - j >= 0; j++) {
                dp[i] = Math.min(dp[i], dp[i - j] + search[i - j]);
            }
        }
       
        return dp[n];
    }

Minimum Time ✅