Count Subarrays With Median K - Practice Coding Problems

Count Subarrays With Median K - Problem

Challenge: You're given an array nums of size n containing distinct integers from 1 to n and a target integer k. Your task is to count how many contiguous subarrays have k as their median.

What makes this interesting: The median is the middle element when the subarray is sorted. For even-length arrays, we take the left middle element. For example:
• [2,3,1,4] sorted becomes [1,2,3,4] → median is 2 (left middle)
• [8,4,3,5,1] sorted becomes [1,3,4,5,8] → median is 4 (middle)

Since all numbers are distinct and from 1 to n, we can use clever transformations to avoid sorting each subarray!

Input & Output

example_1.py — Basic case

$ Input: nums = [3,2,1,4,5], k = 4

› Output: 3

💡 Note: Valid subarrays: [4] (median=4), [3,4,5] (sorted: [3,4,5], median=4), [2,3,4,5] (sorted: [2,3,4,5], median=3 - wait, this is wrong). Actually: [4], [1,4], [1,4,5] have median 4.

example_2.py — Edge case with k at boundary

$ Input: nums = [2,3,1], k = 3

› Output: 1

💡 Note: Only subarray [2,3,1] has median 3 when sorted to [1,2,3]. The middle element is 2, not 3. Actually, only [3] has median 3.

example_3.py — Single element

$ Input: nums = [1], k = 1

› Output: 1

💡 Note: The only subarray [1] has median 1, which equals k.

Constraints

n == nums.length
1 ≤ n ≤ 10⁵
1 ≤ nums[i], k ≤ n
All integers in nums are distinct

Visualization

Tap to expand

Understanding the Visualization

Find the Target

Locate k in the array - this must be in every valid subarray

Transform Evidence

Convert each element to +1 (heavier than k), -1 (lighter than k), or 0 (equals k)

Count Balanced Sections

Use prefix sums to efficiently count subarrays where k would be the median

Key Takeaway

🎯 Key Insight: Transform the problem from sorting subarrays to counting balanced prefix sums around k

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal approach uses a clever transformation to avoid sorting each subarray. By converting elements to +1/-1 relative to k and using prefix sums with a hash map, we can count valid subarrays in O(n) time. The key insight is that a subarray has median k if it contains k and the elements are balanced around k.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate & Sort)	O(n³ log n)	O(n)	Generate all subarrays, sort each one, and check if median equals k
Transform & Hash (Optimal)	O(n)	O(n)	Transform array relative to k, use prefix sums and hash map to count valid subarrays

Brute Force (Generate & Sort) — Algorithm Steps

Generate all possible subarrays using nested loops
For each subarray, create a copy and sort it
Find the median (middle element for odd length, left-middle for even)
Count subarrays where median equals k

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subarrays

Create all possible contiguous subarrays

Sort Each

Sort each subarray to find median

Check Median

Count subarrays where median equals k

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int countSubarraysWithMedianK(int* nums, int n, int k) {
    int count = 0;
    
    // Generate all subarrays
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            int length = j - i + 1;
            int* subarray = (int*)malloc(length * sizeof(int));
            
            // Copy subarray
            for (int idx = 0; idx < length; idx++) {
                subarray[idx] = nums[i + idx];
            }
            
            // Sort to find median
            qsort(subarray, length, sizeof(int), compare);
            
            // Find median (left middle for even length)
            int median = subarray[(length - 1) / 2];
            
            // Count if median equals k
            if (median == k) {
                count++;
            }
            
            free(subarray);
        }
    }
    
    return count;
}

int main() {
    int nums[] = {3, 2, 1, 4, 5};
    int n = 5, k = 4;
    printf("%d\n", countSubarraysWithMedianK(nums, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³ log n)

O(n²) subarrays × O(n log n) sorting each × O(1) median check

⚠ Quadratic Growth

Space Complexity

O(n)

O(n) space for copying and sorting each subarray

⚡ Linearithmic Space

67.2K Views

High Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Generate & Sort) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler