Longest Strictly Increasing or Strictly Decreasing Subarray

Longest Strictly Increasing or Strictly Decreasing Subarray - Problem

Array Easy

Given an array of integers nums, you need to find the longest contiguous subarray that is either strictly increasing or strictly decreasing.

A subarray is strictly increasing if each element is greater than the previous one (no equal elements allowed). Similarly, a subarray is strictly decreasing if each element is smaller than the previous one.

Goal: Return the maximum length among all such subarrays.

Example: In array [1, 3, 2, 4], we have increasing subarray [1, 3] of length 2, and decreasing subarray [3, 2] of length 2. The answer is 2.

Input & Output

example_1.py — Basic Increasing and Decreasing

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

› Output: 2

💡 Note: The array contains [1,3] (increasing, length 2) and [3,2] (decreasing, length 2). Both have length 2, so the answer is 2.

example_2.py — Longer Increasing Sequence

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

› Output: 5

💡 Note: The longest subarray is [1,2,3,4,5] which is strictly increasing with length 5. There's also [5,3,2,1] (decreasing, length 4), but 5 is larger.

example_3.py — Single Element

$ Input: [5]

› Output: 1

💡 Note: A single element forms a subarray of length 1, which is considered both increasing and decreasing.

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i] ≤ 10⁹
Note: Single element subarrays have length 1

Visualization

Tap to expand

Understanding the Visualization

Start the Journey

Begin at the first elevation point with both uphill and downhill counters set to 1

Track Direction Changes

As you move, increment the appropriate counter based on elevation change

Reset on Direction Change

When switching from uphill to downhill (or vice versa), reset the opposite counter

Record Maximum

Keep track of the longest consistent segment you've encountered

Key Takeaway

🎯 Key Insight: Track both increasing and decreasing trends simultaneously in one pass, resetting counters when direction changes - this gives us O(n) optimal performance.

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal solution uses a one-pass tracking approach with O(n) time complexity. We maintain two counters for current increasing and decreasing streak lengths, updating them as we traverse the array. When we see an increase, we extend the increasing streak and reset decreasing to 1. When we see a decrease, we extend the decreasing streak and reset increasing to 1. The key insight is that we can track both trends simultaneously without needing to restart from each position.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subarrays)	O(n²)	O(1)	Check every possible subarray to find the longest strictly monotonic one
One-Pass Tracking (Optimal)	O(n)	O(1)	Track increasing and decreasing streaks in a single pass through the array

Brute Force (Check All Subarrays) — Algorithm Steps

For each starting index i, try to build the longest increasing subarray
For each starting index i, try to build the longest decreasing subarray
Keep track of the maximum length encountered
Return the overall maximum length

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at index 0

Try building increasing and decreasing subarrays from position 0

Move to index 1

Repeat the process from position 1

Continue for all positions

Check all starting positions and track maximum length

Code -

solution.c — C

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

int longestMonotonicSubarray(int* nums, int n) {
    if (n == 0) return 0;
    
    int maxLength = 1;
    
    for (int i = 0; i < n; i++) {
        // Try increasing subarray starting at i
        int length = 1;
        for (int j = i + 1; j < n; j++) {
            if (nums[j] > nums[j - 1]) {
                length++;
            } else {
                break;
            }
        }
        if (length > maxLength) maxLength = length;
        
        // Try decreasing subarray starting at i
        length = 1;
        for (int j = i + 1; j < n; j++) {
            if (nums[j] < nums[j - 1]) {
                length++;
            } else {
                break;
            }
        }
        if (length > maxLength) maxLength = length;
    }
    
    return maxLength;
}

int main() {
    int nums[1000];
    int n = 0;
    char c;
    while (scanf("%d%c", &nums[n], &c)) {
        n++;
        if (c == ']') break;
    }
    printf("%d\n", longestMonotonicSubarray(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n starting positions, we might expand up to n elements

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track current and maximum lengths

✓ Linear Space

28.5K Views

Medium Frequency

~15 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