Steps to Make Array Non-decreasing

Steps to Make Array Non-decreasing - Problem

You are given a 0-indexed integer array nums. In one step, remove all elements nums[i] where nums[i - 1] > nums[i] for all 0 < i < nums.length.

Return the number of steps performed until nums becomes a non-decreasing array.

A non-decreasing array means each element is greater than or equal to the previous element: nums[i] >= nums[i-1].

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: Step 1: Remove 3,1 (violations where prev > current), left with [5,4,4]. Step 2: Remove first 4, left with [5,4]. Step 3: Remove 4, left with [5]. Total: 3 steps

Example 2 — Already Non-decreasing

$ Input: nums = [4,5,7,7,13]

› Output: 0

💡 Note: Array is already non-decreasing, no steps needed

Example 3 — Single Element

$ Input: nums = [1]

› Output: 0

💡 Note: Single element is always non-decreasing

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 20 a Amazon 15

The key insight is that elements get removed in cascading waves, and we need to track how many rounds each element survives. The optimal approach uses a monotonic stack to efficiently compute survival rounds in O(n) time.

Common Approaches

✓ Brute Force Simulation

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

In each step, scan the array and remove all elements that violate the non-decreasing property (where nums[i-1] > nums[i]). Repeat until no more removals are needed.

Monotonic Stack (Optimal)

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

Process elements left to right using a stack. For each element, pop smaller elements and track the maximum rounds any popped element survived. The current element survives one more round than the maximum.

Brute Force Simulation — Algorithm Steps

Step 1: Scan array to find violations where nums[i-1] > nums[i]
Step 2: Remove all violating elements simultaneously
Step 3: Repeat until array is non-decreasing

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Array

Start with original array

Find Violations

Identify elements where nums[i-1] > nums[i]

Remove & Repeat

Remove violations and continue until sorted

Code -

solution.c — C

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

int solution(int* nums, int size) {
    if (size == 0) return 0;
    
    static int current[1000];
    static int next[1000];
    
    memcpy(current, nums, size * sizeof(int));
    int currentSize = size;
    int steps = 0;
    
    while (1) {
        next[0] = current[0];
        int nextSize = 1;
        int removed = 0;
        
        for (int i = 1; i < currentSize; i++) {
            if (current[i-1] <= current[i]) {
                next[nextSize++] = current[i];
            } else {
                removed = 1;
            }
        }
        
        if (!removed) {
            break;
        }
        
        memcpy(current, next, nextSize * sizeof(int));
        currentSize = nextSize;
        steps++;
    }
    
    return steps;
}

int parseArray(const char* str, int* arr) {
    int size = 0;
    const char* p = str;
    
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        char* endptr;
        arr[size++] = (int)strtol(p, &endptr, 10);
        p = endptr;
    }
    
    return size;
}

int main() {
    static char line[10000];
    fgets(line, sizeof(line), stdin);
    
    static int nums[1000];
    int size = parseArray(line, nums);
    
    int result = solution(nums, size);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, each step removes one element, leading to n steps with n operations each

✓ Linear Growth

Space Complexity

O(n)

Need extra space to store the modified array in each iteration

⚡ Linearithmic Space

29.5K Views

Medium Frequency

~25 min Avg. Time

843 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler