Non-decreasing Array - Practice Coding Problems

Non-decreasing Array - Problem

Array Medium

Imagine you're a quality control engineer for a data visualization company. You receive arrays of numerical data that should display as smooth, ascending charts - but sometimes there's exactly one data point that's out of place!

Given an array nums with n integers, determine if you can make it non-decreasing by modifying at most one element. An array is considered non-decreasing when nums[i] <= nums[i + 1] for every valid index i.

Your mission: Return true if the array can be fixed with one change (or is already perfect), false otherwise.

Example: [4,2,3] → Change the 4 to 1, getting [1,2,3] ✅
[4,2,1] → Would need to change both 4 and 2 ❌

Input & Output

example_1.py — Basic Case

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

› Output: true

💡 Note: You can modify the first element from 4 to 1 to get [1,2,3], which is non-decreasing.

example_2.py — Multiple Violations

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

› Output: false

💡 Note: You would need to modify more than one element. Both 4>2 and 2>1 are violations, requiring at least 2 changes.

example_3.py — Already Valid

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

› Output: true

💡 Note: The array is already non-decreasing, so no modifications are needed.

Visualization

Tap to expand

Understanding the Visualization

Inspect Each Step

Walk through the staircase checking each transition

Find Problem

When step i is higher than step i+1, we have a violation

Smart Decision

Choose whether to lower step i or raise step i+1 based on step i-1

Apply Fix

Make the modification and continue inspection

Key Takeaway

🎯 Key Insight: When fixing a violation, always consider which modification maintains better consistency with neighboring elements. This greedy choice leads to the optimal solution!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, each element visited once

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for counters and variables

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁴
-10⁵ ≤ nums[i] ≤ 10⁵
At most one element can be modified

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses a greedy one-pass approach that counts violations and makes smart decisions about which element to modify. When we find a violation nums[i] > nums[i+1], we choose to modify nums[i] if it doesn't break the previous constraint, otherwise we modify nums[i+1]. This achieves O(n) time complexity with constant space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Modifications)	O(n³)	O(1)	Try modifying each element to every possible value and check if array becomes non-decreasing
One-Pass Greedy (Optimal)	O(n)	O(1)	Make smart decisions about which element to modify when violations are found

Brute Force (Try All Modifications) — Algorithm Steps

For each position i in the array
Try replacing nums[i] with each value in the array
Check if the modified array is non-decreasing
If any modification works, return true
If no single modification works, return false

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Original

First verify if array is already non-decreasing

Try Position 0

Try replacing first element with every possible value

Try Position 1

Try replacing second element with every possible value

Continue Process

Repeat for all positions until solution found or exhausted

Code -

solution.c — C

bool isNonDecreasing(int* nums, int numsSize) {
    for (int i = 0; i < numsSize - 1; i++) {
        if (nums[i] > nums[i + 1]) return false;
    }
    return true;
}

bool checkPossibility(int* nums, int numsSize) {
    if (isNonDecreasing(nums, numsSize)) return true;
    
    for (int i = 0; i < numsSize; i++) {
        int original = nums[i];
        
        for (int j = 0; j < numsSize; j++) {
            nums[i] = nums[j];
            if (isNonDecreasing(nums, numsSize)) return true;
        }
        nums[i] = original;
    }
    
    return false;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n) positions × O(n) possible values × O(n) validation = O(n³)

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for loop variables

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁴
-10⁵ ≤ nums[i] ≤ 10⁵
At most one element can be modified

67.5K Views

Medium Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Modifications) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler