Non-decreasing Array

Non-decreasing Array - Problem

Array Medium

Given an array nums with n integers, your task is to check if it could become non-decreasing by modifying at most one element.

We define an array is non-decreasing if nums[i] <= nums[i + 1] holds for every i (0-based) such that 0 <= i <= n - 2.

Input & Output

Example 1 — Single Violation

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

› Output: true

💡 Note: We can modify nums[0] = 2 to get [2,2,3] which is non-decreasing, or nums[1] = 4 to get [4,4,3] but that creates another violation. The first option works.

Example 2 — Multiple Violations

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

› Output: false

💡 Note: We have violations at indices 0->1 (4>2) and 1->2 (2>1). Since we can only modify one element, we cannot fix both violations.

Example 3 — Already Sorted

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

› Output: true

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

Constraints

2 ≤ nums.length ≤ 10⁴
-10⁵ ≤ nums[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 M Microsoft 8

The key insight is that we can only have at most one violation to fix. The optimized approach counts violations in a single pass and applies smart context-aware fixing logic. Best approach uses Smart Violation Handling with Time: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force	O(n²)	O(1)	Try modifying each element and check if array becomes non-decreasing
Smart Violation Handling	O(n)	O(1)	Count violations and apply smart fixing rules based on context

Brute Force — Algorithm Steps

Step 1: For each index i, try modifying nums[i]
Step 2: Set nums[i] to appropriate value based on neighbors
Step 3: Check if modified array is non-decreasing

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Violations

Identify where nums[i] > nums[i+1]

Try Each Position

For each index, try two modifications

Check Full Array

Validate entire array after each change

Code -

solution.c — C

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

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

bool solution(int* nums, int size) {
    if (isNonDecreasing(nums, size)) {
        return true;
    }
    
    for (int i = 0; i < size; i++) {
        int original = nums[i];
        
        // Try modifying nums[i] to match left neighbor
        if (i > 0) {
            nums[i] = nums[i - 1];
            if (isNonDecreasing(nums, size)) {
                nums[i] = original;
                return true;
            }
        }
        
        // Try modifying nums[i] to match right neighbor
        if (i < size - 1) {
            nums[i] = nums[i + 1];
            if (isNonDecreasing(nums, size)) {
                nums[i] = original;
                return true;
            }
        }
        
        nums[i] = original;
    }
    
    return false;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int size = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        if (strlen(token) > 0) {
            nums[size++] = atoi(token);
        }
        token = strtok(NULL, "[],\n");
    }
    
    bool result = solution(nums, size);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n positions, we check entire array (n operations)

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables, no extra data structures

✓ Linear Space

180.0K Views

Medium Frequency

~25 min Avg. Time

3.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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler