Number of Valid Subarrays - Practice Coding Problems

Number of Valid Subarrays - Problem

You are given an integer array nums. A valid subarray is defined as a contiguous portion of the array where the leftmost element is not larger than any other element in that subarray.

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

Example: In array [3, 4, 1, 5], the subarray [3, 4] is valid because 3 ≤ 3 and 3 ≤ 4. However, [4, 1] is not valid because 4 > 1.

Goal: Return the total count of all valid subarrays in the input array.

Input & Output

example_1.py — Basic Case

$ Input: [1, 4, 2, 5, 3]

› Output: 11

💡 Note: Valid subarrays: [1], [1,4], [1,4,2], [1,4,2,5], [1,4,2,5,3], [4], [4,5], [2], [2,5], [5], [3]. The leftmost element in each subarray is not larger than any other element in that subarray.

example_2.py — Decreasing Array

$ Input: [3, 2, 1]

› Output: 3

💡 Note: Only single-element subarrays are valid: [3], [2], [1]. Any multi-element subarray would have a leftmost element larger than some element to its right.

example_3.py — Increasing Array

$ Input: [1, 2, 3]

› Output: 6

💡 Note: All possible subarrays are valid: [1], [1,2], [1,2,3], [2], [2,3], [3]. In an increasing array, every subarray satisfies the condition.

Constraints

1 ≤ nums.length ≤ 5 × 10⁴
1 ≤ nums[i] ≤ 10⁵
Follow-up: Can you solve this in O(n) time complexity?

Visualization

Tap to expand

Understanding the Visualization

Choose a Leader

Each array position can be a potential team leader

Extend the Team

Keep adding team members as long as leader ≤ all members

Count Valid Teams

Use monotonic stack to efficiently count all valid team formations

Key Takeaway

🎯 Key Insight: Instead of checking each subarray individually, use a monotonic stack to find where each "leadership chain" breaks, allowing O(n) solution.

Asked in

G Google 45 a Amazon 38 f Meta 25 ⊞ Microsoft 22

The optimal solution uses a monotonic stack to efficiently find the next smaller element for each position. For each starting position, we count how many valid subarrays can begin there by finding where the first violation occurs. This achieves O(n) time complexity compared to the brute force O(n³) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n³)	O(1)	Check all possible subarrays by examining each starting position with every possible ending position
Monotonic Stack (Optimal)	O(n)	O(n)	Use monotonic stack to find the next smaller element for each position efficiently

Brute Force (Nested Loops) — Algorithm Steps

Iterate through each possible starting position i
For each starting position, try all ending positions j >= i
For subarray from i to j, check if nums[i] <= all elements in range
If valid, increment the count
Return total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose starting position

Pick index i as the leftmost element

Try all ending positions

For each j >= i, form subarray [i, j]

Validate subarray

Check if nums[i] <= all elements in range [i, j]

Code -

solution.c — C

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

int validSubarrays(int* nums, int numsSize) {
    int count = 0;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i; j < numsSize; j++) {
            // Check if nums[i] is not larger than any element in subarray [i:j+1]
            bool valid = true;
            for (int k = i; k <= j; k++) {
                if (nums[i] > nums[k]) {
                    valid = false;
                    break;
                }
            }
            if (valid) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    int nums[1000];
    int size = 0;
    char c;
    int num = 0;
    bool reading_num = false;
    
    while ((c = getchar()) != EOF && c != ']') {
        if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
            reading_num = true;
        } else if (c == ',' || c == ']') {
            if (reading_num) {
                nums[size++] = num;
                num = 0;
                reading_num = false;
            }
        }
    }
    if (reading_num) {
        nums[size++] = num;
    }
    
    printf("%d\n", validSubarrays(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: starting position (n), ending position (n), and validation (n)

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler