Maximum Length of Semi-Decreasing Subarrays - Problem

You are given an integer array nums. Return the length of the longest semi-decreasing subarray of nums, and 0 if there are no such subarrays.

A subarray is a contiguous non-empty sequence of elements within an array. A non-empty array is semi-decreasing if its first element is strictly greater than its last element.

Input & Output

Example 1 — Basic Case

$ Input: nums = [7,6,8,1,2]

› Output: 3

💡 Note: The subarray [8,1,2] has first element 8 > last element 2, with length 3. This is the longest such subarray.

Example 2 — No Semi-Decreasing

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

› Output: 0

💡 Note: All elements are in increasing order, so no subarray has first > last. Return 0.

Example 3 — Single Decreasing Pair

$ Input: nums = [5,1]

› Output: 2

💡 Note: The entire array [5,1] is semi-decreasing since 5 > 1, length is 2.

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 a Amazon 15

The key insight is that a semi-decreasing subarray must have its first element strictly greater than its last element. The brute force approach checks all possible subarrays in O(n²) time. The optimal approach uses the observation that for each ending position, we want to find the furthest left position with a larger value. Time: O(n²), Space: O(1)

Common Approaches

✓ Dfs

⏱️ Time: N/A Space: N/A

Brute Force - Check All Subarrays

⏱️ Time: O(n²) Space: O(1)

For each starting position, check all possible ending positions to find subarrays where the first element is strictly greater than the last element. Track the maximum length found.

Monotonic Stack Optimization

⏱️ Time: O(n) Space: O(n)

We can optimize by realizing that for any ending position, we want the largest possible starting value that comes before it. Use a stack to maintain potential starting positions in decreasing order.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int solution(int* nums, int n) {
    int maxLength = 0;
    
    // For each position, find the furthest left position with larger value
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < i; j++) {
            if (nums[j] > nums[i]) {
                int length = i - j + 1;
                if (length > maxLength) {
                    maxLength = length;
                }
                break;
            }
        }
    }
    
    return maxLength;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Parse the array manually
    int nums[1000];
    int count = 0;
    
    char* ptr = strchr(input, '[');
    if (ptr) {
        ptr++; // Skip '['
        char* end = strchr(ptr, ']');
        if (end) {
            *end = '\0'; // Null terminate
            
            if (strlen(ptr) > 0) {
                char* token = strtok(ptr, ",");
                while (token != NULL) {
                    // Trim whitespace
                    while (*token == ' ') token++;
                    nums[count++] = atoi(token);
                    token = strtok(NULL, ",");
                }
            }
        }
    }
    
    int result = solution(nums, count);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

✓ Linear Space

12.0K Views

Medium Frequency

~25 min Avg. Time

520 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