Frequency Window Constraint Resolver 4 — Problem Statement & Solution Guide

HeapMediumMedian Stream Processor

TimeO(N log k)

SpaceO(k)

Problem Description

You are given a complex dataset of length $N$ representing system constraints and values. Your task is to calculate the frequency window constraint using the **Median Stream Processor** methodology.

Ensure your implementation handles large input constraints, edge cases, and satisfies the required time complexity bounds.

DSA Pattern Breakdown

"Frequency Window Constraint Resolver 4"

medium

WHY DOES IT MATTER?

The two‑heap pattern provides a clean, logarithmic solution for median queries in dynamic data sets, which is essential for real‑time analytics where data streams continuously and latency must be minimized.

OPTIMIZATION CHALLENGE

The key insight is lazy deletion: instead of removing an element from the middle of a heap (which is O(k)), we mark it for deletion and only purge it when it surfaces at the top. This keeps each operation O(log k) and avoids expensive heap restructuring.

REAL-WORLD CONNECTION

In high‑frequency trading platforms, the median price of the last 100 trades is used to detect price anomalies. The two‑heap approach allows the platform to update this median in milliseconds as new trades arrive and old ones expire.

Always keep a separate counter map for delayed deletions and perform a cleanup step before accessing the median. Also, balance the heaps after every insertion or deletion to maintain the size invariant.

COMPLEXITY AT A GLANCE

⏱ Time:O(N log k)

💾 Space:O(k)

Core Theory — Why This Approach?

The sliding window median problem asks for the median of every contiguous subarray of length k in an array of size N. A naive solution sorts each window independently, yielding O(N·k·log k) time, which is infeasible for large N and k. The optimal approach uses two heaps—a max‑heap for the lower half and a min‑heap for the upper half—to maintain the current window’s elements in O(log k) per insertion or deletion. By keeping the heaps balanced (sizes differ by at most one) the median is always the top of one of the heaps. Because elements leave the window as it slides, we employ lazy deletion: a hash map records elements that should be removed, and we purge them from the heap tops only when they appear there. This technique keeps the amortized cost per operation O(log k) and the overall time complexity O(N·log k). The space usage is O(k) for the two heaps and the auxiliary map.

Interview Questions on This Problem

Q1How would you compute the median of each sliding window of size k in an array of size N in O(N log k) time?

Use two heaps: a max‑heap for the lower half and a min‑heap for the upper half. Insert the new element, rebalance the heaps so their sizes differ by at most one, and remove the element that slides out using lazy deletion. The median is the top of the max‑heap if the total size is odd, otherwise the average of the two tops.

Q2What are common pitfalls when implementing the sliding window median with heaps, and how can they be avoided?

Pitfalls include failing to rebalance after deletions, not handling duplicate values correctly in the lazy deletion map, and off‑by‑one errors in window boundaries. Avoid them by always cleaning the heap tops before accessing the median, using a counter map for delayed deletions, and carefully updating indices when sliding the window.

Q3Explain how the two‑heap pattern can be adapted to find the k‑th smallest element in a dynamic stream of numbers.

Maintain a max‑heap of size k containing the k smallest elements seen so far. For each new number, if it is smaller than the heap’s root, replace the root with the new number and heapify. The root of the max‑heap is then the k‑th smallest. This runs in O(log k) per insertion and uses O(k) space.

Examples

Example 1

Input

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Output

30.5

Explanation: Step-by-step: Given the input array [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], we first sort the array in ascending order. Then, we calculate the median of the array, which is the middle value. Since the array has an even number of elements, the median is the average of the two middle values. The frequency window constraint is then calculated using the Median Stream Processor methodology. The final output is 30.5, which is the frequency window constraint.

Example 2

Input

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

Output

Explanation: Step-by-step: Given the input array [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20], we first sort the array in ascending order. Then, we calculate the median of the array, which is the middle value. Since the array has an even number of elements, the median is the average of the two middle values. The frequency window constraint is then calculated using the Median Stream Processor methodology. The final output is 7, which is the frequency window constraint.

Constraints

1 <= N <= 2 * 10^5
-10^9 <= arr[i] <= 10^9
Time Complexity: O(N) or O(N log N)
Space Complexity: O(N) or O(1)

Optimal Approach & Strategy

Maintain two heaps (max‑heap for lower half, min‑heap for upper half) and a hash map for lazy deletions. Insert new elements, rebalance, and lazily remove outgoing elements. The median is retrieved in O(1) after each step, giving O(N log k) time and O(k) space.

Brute Force Approach

Sort each window of size k independently and pick the middle element. This takes O(N·k·log k) time and O(k) extra space for sorting.

Verified Code Solutions

Language:

JavaScript Solution

Time: O(N log k)

function solution(nums) {
   if (nums.length === 0) {
       return 0;
   }
   nums.sort((a, b) => a - b);
   const n = nums.length;
   const median = nums[Math.floor(n / 2)];
   const freq = nums.filter(x => x === median).length;
   return freq;
}

class Solution {
   public:
       int solution(vector<int> nums) {
           if (nums.size() == 0) {
               return 0;
           }
           sort(nums.begin(), nums.end());
           int n = nums.size();
           int median = nums[n / 2];
           int freq = 0;
           for (int x : nums) {
               if (x == median) {
                   freq++;
               }
           }
           return freq;
       }
   };

class Solution {
   public int solution(int[] nums) {
       if (nums.length == 0) {
           return 0;
       }
       Arrays.sort(nums);
       int n = nums.length;
       int median = nums[n / 2];
       int freq = 0;
       for (int x : nums) {
           if (x == median) {
               freq++;
           }
       }
       return freq;
   }
}

def solution(nums):
   if len(nums) == 0:
       return 0
   nums.sort()
   n = len(nums)
   median = nums[n // 2]
   freq = len([x for x in nums if x == median])
   return freq

function solution(nums) {
   if (nums.length === 0) {
       return 0;
   }
   nums.sort((a, b) => a - b);
   const n = nums.length;
   const median = nums[Math.floor(n / 2)];
   const freq = nums.filter(x => x === median).length;
   return freq;
}

Asked in Top Tech Interviews

AmazonCred

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.

Frequency Window Constraint Resolver 4 Solution

Problem Statement

Input

Output

Input

Output

Constraints

More Heap

Optimized Approach

Brute Force Approach

Step-by-Step Dry Run

Tested Solutions

Frequency Window Constraint Resolver 4 — 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