Count Strictly Increasing Subarrays - Practice Coding Problems

Count Strictly Increasing Subarrays - Problem

Count Strictly Increasing Subarrays is a fascinating problem that tests your ability to identify patterns in array sequences.

Given an array nums consisting of positive integers, you need to count how many subarrays are in strictly increasing order. A subarray is a contiguous part of an array, and strictly increasing means each element must be greater than the previous one (not equal).

For example, in the array [1, 3, 2, 4, 5]:
• [1], [3], [2], [4], [5] are all strictly increasing (single elements)
• [1, 3] is strictly increasing
• [2, 4], [4, 5], [2, 4, 5] are strictly increasing
• But [3, 2] is not (decreasing)

Your task: Return the total count of all strictly increasing subarrays in the given array.

Input & Output

example_1.py — Basic Case

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

› Output: 9

💡 Note: The strictly increasing subarrays are: [1], [3], [2], [4], [5], [1,3], [2,4], [4,5], [2,4,5]. Total count = 9.

example_2.py — Monotonic Increasing

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

› Output: 10

💡 Note: All subarrays are strictly increasing: [1], [2], [3], [4], [1,2], [2,3], [3,4], [1,2,3], [2,3,4], [1,2,3,4]. Total = 4*5/2 = 10.

example_3.py — Single Element

$ Input: [5]

› Output: 1

💡 Note: Only one subarray exists: [5], which is trivially strictly increasing. Count = 1.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
All elements are positive integers

Visualization

Tap to expand

Understanding the Visualization

Identify Climbing Segments

Find all consecutive ascending segments in your route

Count Routes per Segment

For each ascending segment of length n, you can create n*(n+1)/2 different climbing routes

Sum All Possibilities

Add up the route counts from all ascending segments to get the total

Key Takeaway

🎯 Key Insight: When you find a sequence of n consecutive ascending elevations, you automatically get n*(n+1)/2 different climbing routes within that segment. Count all segments and sum their contributions for the optimal O(n) solution!

Asked in

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

The optimal solution uses a single-pass approach with mathematical insight. Instead of checking every subarray, we track consecutive increasing sequences and use the formula n*(n+1)/2 to count subarrays within each sequence. This achieves O(n) time complexity and O(1) space complexity, making it highly efficient for large inputs.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Check every possible subarray to see if it's strictly increasing
Optimized Single Pass (Optimal)	O(n)	O(1)	Count subarrays by tracking consecutive increasing sequences in one pass

Brute Force (Nested Loops) — Algorithm Steps

Use outer loop to iterate through each possible starting position
Use inner loop to extend subarray from current starting position
For each subarray, verify if it's strictly increasing
Count valid strictly increasing subarrays
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

Validate increasing property

Check if current subarray is strictly increasing

Count valid subarrays

Increment counter for each valid strictly increasing subarray

Code -

solution.c — C

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

int countSubarrays(int* nums, int numsSize) {
    if (numsSize == 0) return 0;
    
    int count = 0;
    
    // Check every possible subarray
    for (int i = 0; i < numsSize; i++) {
        for (int j = i; j < numsSize; j++) {
            // Check if subarray from i to j is strictly increasing
            int isIncreasing = 1;
            for (int k = i; k < j; k++) {
                if (nums[k] >= nums[k + 1]) {
                    isIncreasing = 0;
                    break;
                }
            }
            
            if (isIncreasing) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100];
    int size = 0;
    
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", countSubarrays(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops: outer loop runs n times, inner loop runs up to n times for each iteration

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for counting, no additional data structures needed

✓ Linear Space

42.0K Views

High Frequency

~15 min Avg. Time

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