Number of Subarrays with Bounded Maximum - Practice Coding Problems

Number of Subarrays with Bounded Maximum - Problem

Given an integer array nums and two integers left and right, we need to find the number of contiguous non-empty subarrays where the maximum element falls within the range [left, right] (inclusive).

Think of this as finding all possible "windows" in the array where the largest number in that window is neither too small (less than left) nor too large (greater than right).

Example: If we have array [2, 1, 4, 9, 3] with left = 2 and right = 4, we count subarrays like [2], [2, 1], [4], [3], etc., but not [9] or [4, 9] since 9 is too large.

The challenge is to do this efficiently without checking every possible subarray individually!

Input & Output

example_1.py — Basic Case

$ Input: nums = [2,1,4,9,3], left = 2, right = 4

› Output: 3

💡 Note: Valid subarrays are [2], [4], [3]. Subarrays like [2,1] have max=2 (valid), [1,4] has max=4 (valid), [4,9] has max=9 (invalid), etc. Total count is 3.

example_2.py — All Elements in Range

$ Input: nums = [2,9,2,5,6], left = 2, right = 8

› Output: 7

💡 Note: Elements 2,2,5,6 are in range [2,8], only 9 is out of range. Valid subarrays: [2],[2],[5],[6],[2,2],[2,5],[5,6] = 7 subarrays.

example_3.py — Single Element

$ Input: nums = [1], left = 1, right = 1

› Output: 1

💡 Note: Only one subarray [1] exists, and its maximum (1) is within range [1,1], so answer is 1.

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁹
0 ≤ left ≤ right ≤ 10⁹
The answer is guaranteed to fit in a 32-bit integer

Visualization

Tap to expand

Understanding the Visualization

Count groups with quality ≤ upper limit

Walk the conveyor belt and count all consecutive groups where no product exceeds the upper quality limit

Count groups with quality ≤ (lower limit - 1)

Do the same counting but with a threshold one less than our lower quality limit

Subtract to get perfect range

The difference gives us exactly the groups with quality in our target range

Key Takeaway

🎯 Key Insight: Instead of checking O(n²) subarrays individually, we count valid subarrays mathematically using subtraction: count(max ≤ right) - count(max ≤ left-1) = count(max ∈ [left,right])

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses a two-pointers contribution counting approach with the key insight: subarrays with max in [left, right] = subarrays with max ≤ right - subarrays with max ≤ left-1. This achieves O(n) time complexity by making two passes through the array instead of checking all O(n²) subarrays individually.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers with Contribution Counting	O(n)	O(1)	Use two pointers to track valid regions and count subarrays efficiently
Brute Force (Nested Loops)	O(n³)	O(1)	Check all possible subarrays and count those with maximum in range

Two Pointers with Contribution Counting — Algorithm Steps

Create helper function countSubarrays(nums, threshold) to count subarrays with max ≤ threshold
In helper function, use two pointers to maintain a valid window
When current element > threshold, move left pointer past current position
For each valid position, add (right - left + 1) subarrays ending at current position
Return countSubarrays(nums, right) - countSubarrays(nums, left-1)

Visualization

Tap to expand

Step-by-Step Walkthrough

Count subarrays with max ≤ right (4)

Use sliding window to count all subarrays with maximum ≤ 4

Count subarrays with max ≤ left-1 (1)

Use sliding window to count all subarrays with maximum ≤ 1

Subtract to get final answer

Result = count(≤4) - count(≤1) gives subarrays with max in [2,4]

Code -

solution.c — C

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

int countSubarrays(int* nums, int numsSize, int threshold) {
    // Count subarrays where maximum <= threshold
    int count = 0;
    int leftPtr = 0;
    
    for (int rightPtr = 0; rightPtr < numsSize; rightPtr++) {
        // If current element > threshold, reset window
        if (nums[rightPtr] > threshold) {
            leftPtr = rightPtr + 1;
        } else {
            // Add subarrays ending at rightPtr
            count += rightPtr - leftPtr + 1;
        }
    }
    
    return count;
}

int numSubarrayBoundedMax(int* nums, int numsSize, int left, int right) {
    return countSubarrays(nums, numsSize, right) - countSubarrays(nums, numsSize, left - 1);
}

int main() {
    int nums[1000];
    int n = 0;
    int num;
    
    // Read array
    while (scanf("%d", &num) == 1) {
        nums[n++] = num;
        if (getchar() == '\n') break;
    }
    
    int left, right;
    scanf("%d %d", &left, &right);
    printf("%d\n", numSubarrayBoundedMax(nums, n, left, right));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the array, each taking O(n) time

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables for pointers and counters

✓ Linear Space

62.0K Views

Medium 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

Two Pointers with Contribution Counting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler