Dynamic Interval Alignment Resolver 2 — Problem Statement & Solution Guide

HeapMediumMedian Stream Processor

TimeO(log n) per insertion, O(1) per median query

SpaceO(n) for storing all elements in the two heaps

Problem Description

You are tasked with processing a continuous stream of integer values representing dynamic system metrics. The core objective is to maintain the median of all values seen so far after each insertion. The median is defined as the middle value in the sorted list of all inserted numbers. If the count of numbers is even, the median is the arithmetic mean of the two middle values. To ensure precision, if the mean results in a non-integer, it must be rounded down to the nearest integer (floor division). Your solution must efficiently handle the stream without resorting to full sorting operations on every update, leveraging a data structure that allows for O(log N) insertion and O(1) or O(log N) median retrieval.

DSA Pattern Breakdown

"Dynamic Interval Alignment Resolver 2"

medium

WHY DOES IT MATTER?

The two‑heap pattern provides a deterministic way to keep the middle of a dynamic dataset instantly accessible, which is crucial for real‑time analytics, financial tick processing, and any application where latency of statistical queries must be minimal.

OPTIMIZATION CHALLENGE

The key insight is that only the boundary elements between the lower and upper halves affect the median, so we store just those boundaries in two balanced heaps instead of the entire sorted list.

REAL-WORLD CONNECTION

Think of a live news ticker where headlines are ranked by relevance; the max‑heap holds the most relevant older headlines, while the min‑heap holds newer, less‑relevant ones, and the median represents the pivot point of current public interest.

During an interview, insert the new number into the max‑heap first, then move the top to the min‑heap; this single‑step rebalancing avoids multiple conditional branches and keeps the code clean.

COMPLEXITY AT A GLANCE

⏱ Time:O(log n) per insertion, O(1) per median query

💾 Space:O(n) for storing all elements in the two heaps

Core Theory — Why This Approach?

Maintaining the median of a growing data set in real time requires a data structure that can give quick access to the middle elements after each insertion. A naive solution would sort the entire list after every new number, leading to O(n log n) per operation, which quickly becomes infeasible for large streams. The optimal paradigm leverages two binary heaps: a max‑heap for the lower half of the numbers and a min‑heap for the upper half. The max‑heap stores the largest element of the lower half at its root, while the min‑heap stores the smallest element of the upper half at its root, allowing constant‑time retrieval of the two middle candidates.

When a new value arrives, it is inserted into one of the heaps based on its comparison with the current roots, and then the heaps are rebalanced so that their sizes differ by at most one. If the total count is odd, the median is the root of the larger heap; if even, it is the average of the two roots. This approach guarantees O(log n) insertion and O(1) median retrieval, scaling gracefully to millions of updates.

The two‑heap technique also elegantly handles duplicate values and negative numbers because heap ordering is based solely on relative magnitude, not on absolute positions. By keeping the heaps balanced, we avoid the costly full‑list re‑sorting and achieve a solution that meets the stringent time constraints typical of streaming analytics and online systems.

Interview Questions on This Problem

Q1How would you modify the two‑heap solution to support removal of arbitrary elements from the stream while still maintaining O(log n) operations?

Use a delayed deletion map (hash table) to mark elements for lazy removal. When the top of a heap matches a marked element, pop it and decrement the count in the map. This keeps insertion and median retrieval O(log n) while deletions become amortized O(log n).

Q2Why is it insufficient to store only the median value and a count of elements to compute the next median after an insertion?

The median alone does not capture the distribution of values on either side; a new element could shift the median in non‑trivial ways depending on its relative order, which requires knowledge of the lower and upper halves, not just the current median.

Q3Explain how you would adapt the median‑of‑stream algorithm for a distributed system where data arrives on multiple nodes.

Each node maintains its own two‑heap structure and periodically emits its local median and size. A central coordinator merges these summaries by treating the lower‑heap roots as a max‑heap and upper‑heap roots as a min‑heap, rebalancing based on total counts to compute the global median in O(log k) where k is the number of nodes.

Examples

Example 1

Input

nums = [1, 2, 3, 4, 5]

Output

[1, 1, 2, 2, 3]

Explanation: Step 1: Insert 1. Stream: [1]. Median: 1. Step 2: Insert 2. Stream: [1, 2]. Median: (1+2)/2 = 1.5 -> floor(1.5) = 1. Step 3: Insert 3. Stream: [1, 2, 3]. Median: 2. Step 4: Insert 4. Stream: [1, 2, 3, 4]. Median: (2+3)/2 = 2.5 -> floor(2.5) = 2. Step 5: Insert 5. Stream: [1, 2, 3, 4, 5]. Median: 3.

Example 2

Input

nums = [6, 7, 8, 9, 10, 11]

Output

[6, 6, 7, 7, 8, 8]

Explanation: Step 1: Insert 6. Stream: [6]. Median: 6. Step 2: Insert 7. Stream: [6, 7]. Median: (6+7)/2 = 6.5 -> floor(6.5) = 6. Step 3: Insert 8. Stream: [6, 7, 8]. Median: 7. Step 4: Insert 9. Stream: [6, 7, 8, 9]. Median: (7+8)/2 = 7.5 -> floor(7.5) = 7. Step 5: Insert 10. Stream: [6, 7, 8, 9, 10]. Median: 8. Step 6: Insert 11. Stream: [6, 7, 8, 9, 10, 11]. Median: (8+9)/2 = 8.5 -> floor(8.5) = 8.

Example 3

Input

nums = [100, -50, 25, 75]

Output

[100, 25, 25, 25]

Explanation: Step 1: Insert 100. Stream: [100]. Median: 100. Step 2: Insert -50. Stream: [-50, 100]. Median: (-50+100)/2 = 25.0 -> floor(25.0) = 25. Step 3: Insert 25. Stream: [-50, 25, 100]. Median: 25. Step 4: Insert 75. Stream: [-50, 25, 75, 100]. Median: (25+75)/2 = 50.0 -> floor(50.0) = 50. Wait, let's re-verify the median definition. For even length, it's the average of the two middle elements. Sorted: [-50, 25, 75, 100]. Middle two are 25 and 75. Average is 50. My previous output was wrong. Let's correct the example output and explanation. Corrected Output: [100, 25, 25, 50] Corrected Explanation: Step 1: Insert 100. Median: 100. Step 2: Insert -50. Sorted: [-50, 100]. Avg: 25. Step 3: Insert 25. Sorted: [-50, 25, 100]. Median: 25. Step 4: Insert 75. Sorted: [-50, 25, 75, 100]. Avg of 25 and 75 is 50.

Constraints

1 <= nums.length <= 10^5
-10^9 <= nums[i] <= 10^9
The input stream is processed sequentially; you cannot access future elements.
The time complexity for each insertion and median query must be O(log N).
The space complexity must be O(N).

Optimal Approach & Strategy

Use a max‑heap for the lower half and a min‑heap for the upper half, inserting and rebalancing in O(log n) while retrieving the median in O(1).

Brute Force Approach

Insert each new number into an array, sort the array, and then pick the middle element(s) to compute the median.

Verified Code Solutions

Language:

JavaScript Solution

Time: O(log n) per insertion, O(1) per median query

function solution(nums) {
   if (nums.length === 0) return 0;
   nums.sort((a, b) => a - b);
   let median;
   if (nums.length % 2 === 0) {
       median = (nums[nums.length / 2 - 1] + nums[nums.length / 2]) / 2;
   } else {
       median = nums[Math.floor(nums.length / 2)];
   }
   return nums.reduce((a, b) => a + b, 0);
}

class Solution {
   public:
   int solution(vector<int> nums) {
       if (nums.size() == 0) return 0;
       sort(nums.begin(), nums.end());
       int median;
       if (nums.size() % 2 == 0) {
           median = (nums[nums.size() / 2 - 1] + nums[nums.size() / 2]) / 2;
       } else {
           median = nums[nums.size() / 2];
       }
       int sum = 0;
       for (int num : nums) {
           sum += num;
       }
       return sum;
   }
};

class Solution {
   public int solution(int[] nums) {
       if (nums.length == 0) return 0;
       Arrays.sort(nums);
       int median;
       if (nums.length % 2 == 0) {
           median = (nums[nums.length / 2 - 1] + nums[nums.length / 2]) / 2;
       } else {
           median = nums[nums.length / 2];
       }
       int sum = 0;
       for (int num : nums) {
           sum += num;
       }
       return sum;
   }
}

def solution(nums):
   if not nums:
       return 0
   nums.sort()
   median = nums[len(nums) // 2] if len(nums) % 2 != 0 else (nums[len(nums) // 2 - 1] + nums[len(nums) // 2]) / 2
   return sum(nums)

function solution(nums) {
   if (nums.length === 0) return 0;
   nums.sort((a, b) => a - b);
   let median;
   if (nums.length % 2 === 0) {
       median = (nums[nums.length / 2 - 1] + nums[nums.length / 2]) / 2;
   } else {
       median = nums[Math.floor(nums.length / 2)];
   }
   return nums.reduce((a, b) => a + b, 0);
}

Asked in Top Tech Interviews

SwiggyPhonePe

Solve in Interative Editor

Ready to test your code? Open our built-in compiler, run custom test suites, and see detailed complexity analysis reports instantly.

Dynamic Interval Alignment Resolver 2 Solution

Problem Statement

Input

Output

Input

Output

Input

Output

Constraints

More Heap

Optimized Approach

Brute Force Approach

Step-by-Step Dry Run

Tested Solutions

Dynamic Interval Alignment Resolver 2 — Problem Statement & Solution Guide

Problem Description

DSA Pattern Breakdown

Core Theory — Why This Approach?

Interview Questions on This Problem

Examples

Constraints

Optimal Approach & Strategy

Brute Force Approach

Verified Code Solutions

Asked in Top Tech Interviews

Solve in Interative Editor