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, return the number of contiguous non-empty subarrays such that the value of the maximum array element in that subarray is in the range [left, right].

The test cases are generated so that the answer will fit in a 32-bit integer.

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: Valid subarrays are [2], [2,1], and [3]. These have maximums 2, 2, and 3 respectively, all within [2,3]

Example 2 — Larger Range

$ Input: nums = [73,55,36,5,55,14,9,7,72,52], left = 32, right = 69

› Output: 22

💡 Note: Multiple subarrays have their maximum element in the range [32,69], including single elements and combinations

Example 3 — Small Array

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

› Output: 3

💡 Note: All possible subarrays [1], [2], and [1,2] have maximums within [1,2]

Constraints

1 ≤ nums.length ≤ 5 × 10⁴
0 ≤ nums[i] ≤ 10⁹
0 ≤ left ≤ right ≤ 10⁹

Visualization

Tap to expand

Understanding the Visualization

Input

Array [2,1,4,9,3] with range [2,3]

Process

Find all subarrays with max in [2,3]

Output

Count = 3 valid subarrays

Key Takeaway

🎯 Key Insight: Transform the bounded maximum problem into a difference of two 'at most' counting problems for optimal O(n) solution

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to transform this into a difference of two simpler counting problems. Instead of directly counting subarrays with maximum in [left, right], we count subarrays with maximum ≤ right and subtract those with maximum ≤ left-1. Best approach uses the contribution technique in O(n) time with O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Check All Subarrays	O(n²)	O(1)	Generate all possible subarrays and check if maximum is in range
Counting with Contribution Technique	O(n)	O(1)	Use difference of two counting problems: atMost(right) - atMost(left-1)

Brute Force - Check All Subarrays — Algorithm Steps

Iterate through all possible starting positions
For each start, iterate through all ending positions
Track maximum element while extending subarray
Count subarrays with maximum in [left, right]

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subarrays

Create all possible contiguous subarrays

Find Maximum

Track maximum element in each subarray

Count Valid

Count subarrays with max in [left, right]

Code -

solution.c — C

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

int solution(int* nums, int numsSize, int left, int right) {
    int count = 0;
    
    for (int i = 0; i < numsSize; i++) {
        int maxVal = nums[i];
        for (int j = i; j < numsSize; j++) {
            if (nums[j] > maxVal) {
                maxVal = nums[j];
            }
            if (left <= maxVal && maxVal <= right) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n') {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int left, right;
    scanf("%d", &left);
    scanf("%d", &right);
    
    printf("%d\n", solution(nums, numsSize, left, right));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops generate all possible subarrays, each taking constant time to check

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables to track count and maximum, no extra data structures

✓ Linear Space

28.5K Views

Medium Frequency

~25 min Avg. Time

892 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 - Check All Subarrays — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler