vector<int> runningMedian(vector<int> arr) {
    priority_queue<int> low;
    priority_queue<int, vector<int>, greater<int>> high;
    vector<int> res;
   
    for (int num : arr) {
        low.push(num);
        high.push(low.top());
        low.pop();
        if (low.size() < high.size()) {
            low.push(high.top());
            high.pop();
        }
        res.push_back(low.top());
    }
    return res;
} 


RunningMedium ✅
ION

Medial is hiring for Full Stack Developer

3 month intern - 50 k per month REMOTE

2026/2025/2024 passouts eligible

Fte based on performance

Send resume : jobs@medial.app

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

struct Edge {
    int u, v, c;
    bool operator<(const Edge& other) const {
        return c < other.c;
    }
};

int find(vector<int>& parent, int u) {
    if (parent[u] != u) parent[u] = find(parent, parent[u]);
    return parent[u];
}

void unite(vector<int>& parent, vector<int>& rank, int u, int v) {
    int root_u = find(parent, u);
    int root_v = find(parent, v);
    if (root_u != root_v) {
        if (rank[root_u] > rank[root_v]) {
            parent[root_v] = root_u;
        } else if (rank[root_u] < rank[root_v]) {
            parent[root_u] = root_v;
        } else {
            parent[root_v] = root_u;
            rank[root_u]++;
        }
    }
}

long long solve(int n, vector<Edge>& edges) {
    sort(edges.begin(), edges.end());
    vector<int> parent(n + 1), rank(n + 1, 0);
    iota(parent.begin(), parent.end(), 0);
    long long cost = 0;
    int edges_used = 0;
    for (const auto& edge : edges) {
        if (find(parent, edge.u) != find(parent, edge.v)) {
            unite(parent, rank, edge.u, edge.v);
            cost += edge.c;
            edges_used++;
            if (edges_used == n - 1) break;
        }
    }
    return cost;
}

Break and Add ✅
Google

def findMinChanges(taskDependency):
    n = len(taskDependency)
    changes = 0
    final_task = -1
    
    for i in range(n):
        if taskDependency[i] == i + 1:
            final_task = i + 1
            break
    
    if final_task == -1:
        final_task = n
        changes += 1
    
    visited = set()
    for i in range(1, n + 1):
        if i not in visited:
            current = i
            path = set()
            while current not in visited:
                if current == final_task:
                    break
                if current in path:
                    # Found a cycle, break it
                    changes += 1
                    break
                path.add(current)
                visited.add(current)
                current = taskDependency[current - 1]

    for i in range(1, n + 1):
        if i != final_task and taskDependency[i - 1] == i:
            changes += 1
    
    return changes

Gamestop scheduling n tasks

bool solve(vector<int>& A, int N, int M, int L, int x) {
    vector<int> B = A;  
    int op = 0;

    for (int i = 0; i < N; ++i) {
        if (B[i] > x) {
            int dec = B[i] - x;
            int length = min(L, N - i); 
            
            for (int j = 0; j < length; ++j) {
                B[i + j] -= dec;  
            }
            op += dec;

            if (op > M) {
                return false; 
            }
        }
    }

    return true;  
}


int minimizeMaxElement(vector<int>& A, int N, int M, int L) {
    int low = -1e9;
    int high = *max_element(A.begin(), A.end());

    while (low < high) {
        int mid = low + (high - low) / 2;

        if (solve(A, N, M, L, mid)) {
            high = mid;  
        } else {
            low = mid + 1;  
        }
    }

    return low;
}

Array and queries
google✅

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int collectMax(vector<vector<int>>& mat) {
    int n = mat.size();
    if (n == 0) return 0;
        vector<vector<vector<int>>> dp(n, vector<vector<int>>(n, vector<int>(2, -1)));
    
    dp[0][0][1] = (mat[0][0] == 1) ? 1 : 0;
        for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            if (mat[i][j] == -1) continue;
            if (i > 0 && dp[i-1][j][1] != -1)
                dp[i][j][1] = max(dp[i][j][1], dp[i-1][j][1] + (mat[i][j] == 1));
            if (j > 0 && dp[i][j-1][1] != -1)
                dp[i][j][1] = max(dp[i][j][1], dp[i][j-1][1] + (mat[i][j] == 1));
        }
    }
    
    if (dp[n-1][n-1][1] == -1) return 0;
    dp[n-1][n-1][0] = dp[n-1][n-1][1];
    for (int i = n-1; i >= 0; --i) {
        for (int j = n-1; j >= 0; --j) {
            if (mat[i][j] == -1) continue;
            if (i < n-1 && dp[i+1][j][0] != -1)
                dp[i][j][0] = max(dp[i][j][0], dp[i+1][j][0] + (mat[i][j] == 1));
            if (j < n-1 && dp[i][j+1][0] != -1)
                dp[i][j][0] = max(dp[i][j][0], dp[i][j+1][0] + (mat[i][j] == 1));
        }
    }
    
    return dp[0][0][0];
}

Gamekraft ✅

from collections import defaultdict
def getMaxRacers(speed, k):
    ans = 0
    D = defaultdict(list)
    for i, e in enumerate(speed):
        D[e].append(i)
    for arr in D.values():
        l = 0
        for r in range(len(arr)):
            while r > l and arr[r] - arr[l] - (r - l) > k:
                l += 1
            ans = max(ans, r - l + 1)
    
    return ans

GAMESKRAFT MAXRACERS ✅

#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
long long answer(vector<int>& arr, int i, vector<long long>& dp) {
    if (i >= arr.size()) {
        return 0; 
    }
    if (dp[i] != -1) {
        return dp[i];
    }
    
    long long include = arr[i] | answer(arr, i + 1, dp);
    long long exclude = answer(arr, i + 1, dp);
    
    return dp[i] = max(include, exclude);
}

long long solve(int N, vector<int>& arr) {
    vector<long long> dp(N, -1);
    return answer(arr, 0, dp);
}

OR Bit ✅
Siemens

def solve(N, workload):
    msd = 0
    cs = 0 
    for hours in workload:
        if hours > 6:
            cs += 1
            msd = max(msd, cs)
        else:
            current_streak = 0
    return msd

Peak output ✅
Siemens

def solve(N, Q, Specs, Queries):
    aa = {}
    for price, ram, storage in Specs:
        if (ram, storage) in aa:
            aa[(ram, storage)] = min(aa[(ram, storage)], price)
        else:
            aa[(ram, storage)] = price
    results = []
    for ram_req, storage_req in Queries:
        if (ram_req, storage_req) in aa:
            results.append(aa[(ram_req, storage_req)])
        else:
            results.append(-1)
    return results

Who wins the game
Google ✅