Count Subarrays With Fixed Bounds - Practice Coding Problems

Count Subarrays With Fixed Bounds - Problem

Given an integer array nums and two integers minK and maxK, you need to find the number of fixed-bound subarrays.

A fixed-bound subarray is a contiguous portion of the array that satisfies both conditions:
• The minimum value in the subarray equals minK
• The maximum value in the subarray equals maxK

For example, in array [1, 3, 5, 2, 7, 5] with minK = 1 and maxK = 5, the subarray [1, 3, 5] is valid because its minimum is 1 and maximum is 5. However, [3, 5, 2] is not valid because its minimum is 2, not 1.

Your task is to count how many such valid subarrays exist in the given array.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1, 3, 5, 2, 7, 5], minK = 1, maxK = 5

› Output: 2

💡 Note: The valid subarrays are [1,3,5] and [1,3,5,2]. Both have minimum 1 and maximum 5.

example_2.py — Single Element

$ Input: nums = [1, 1, 1, 1], minK = 1, maxK = 1

› Output: 10

💡 Note: All possible subarrays have min=1 and max=1. For array of length 4, there are 4+3+2+1 = 10 subarrays total.

example_3.py — No Valid Subarrays

$ Input: nums = [1, 2, 3], minK = 2, maxK = 4

› Output: 0

💡 Note: No subarray has maximum value 4, so no valid subarrays exist.

Visualization

Tap to expand

Understanding the Visualization

Track Key Days

Remember the last day we saw the exact min temp, max temp, and any invalid temp

Slide Through Time

For each day, update our tracking pointers based on the current temperature

Count Valid Periods

Calculate how many valid periods can end on this day

Add to Total

Add the count of valid periods to our running total

Key Takeaway

🎯 Key Insight: By tracking the last positions of our target values and boundary violations, we can efficiently count all valid ranges without checking every possible subarray combination.

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: O(n²) for all subarray pairs, O(n) to find min/max of each subarray

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables for tracking min, max, and count

✓ Linear Space

Constraints

2 ≤ nums.length ≤ 10⁵
1 ≤ nums[i], minK, maxK ≤ 10⁶
minK ≤ maxK (guaranteed)

Asked in

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

The optimal solution uses a sliding window approach with position tracking. We maintain three key pointers: the last position of minK, the last position of maxK, and the last position of any element outside [minK, maxK]. For each position, we calculate how many valid subarrays can end there by determining the valid starting range. This achieves O(n) time complexity with O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subarrays)	O(n³)	O(1)	Check every possible subarray to see if its min equals minK and max equals maxK
Optimized Brute Force (Sliding Window)	O(n)	O(1)	Use sliding window technique with tracking of boundary violations

Brute Force (Check All Subarrays) — Algorithm Steps

Iterate through each possible starting index i
For each i, iterate through each possible ending index j >= i
For subarray [i, j], find minimum and maximum values
If min equals minK and max equals maxK, increment counter
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first element

Begin checking subarrays starting from index 0

Extend subarray

For each start position, try all possible end positions

Find min/max

Calculate minimum and maximum values in current subarray

Check conditions

Verify if min equals minK and max equals maxK

Code -

solution.c — C

#include <stdio.h>
#include <limits.h>

long long countSubarrays(int* nums, int numsSize, int minK, int maxK) {
    long long count = 0;
    
    // Try all possible subarrays
    for (int i = 0; i < numsSize; i++) {
        for (int j = i; j < numsSize; j++) {
            // Find min and max of subarray nums[i:j+1]
            int minVal = INT_MAX;
            int maxVal = INT_MIN;
            
            for (int k = i; k <= j; k++) {
                if (nums[k] < minVal) minVal = nums[k];
                if (nums[k] > maxVal) maxVal = nums[k];
            }
            
            // Check if this subarray satisfies conditions
            if (minVal == minK && maxVal == maxK) {
                count++;
            }
        }
    }
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: O(n²) for all subarray pairs, O(n) to find min/max of each subarray

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables for tracking min, max, and count

✓ Linear Space

Constraints

2 ≤ nums.length ≤ 10⁵
1 ≤ nums[i], minK, maxK ≤ 10⁶
minK ≤ maxK (guaranteed)

28.4K Views

High Frequency

~25 min Avg. Time

1.3K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check All Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler