Remove One Element to Make the Array Strictly Increasing

Remove One Element to Make the Array Strictly Increasing - Problem

Array Easy

Imagine you have an array of integers that's almost perfect - it would be strictly increasing if you could just remove exactly one element! Your task is to determine whether this transformation is possible.

Given a 0-indexed integer array nums, return true if it can be made strictly increasing after removing exactly one element, or false otherwise.

Special case: If the array is already strictly increasing, you should return true (you can remove any element and still maintain the property).

Definition: An array is strictly increasing if nums[i-1] < nums[i] for each valid index i where 1 ≤ i < nums.length.

Examples:

[1, 2, 10, 5, 7] → true (remove 10 to get [1, 2, 5, 7])
[2, 3, 1, 2] → false (no single removal works)
[1, 2, 3] → true (already strictly increasing)

Input & Output

example_1.py — Python

$ Input: [1,2,10,5,7]

› Output: true

💡 Note: We can remove the element at index 2 (value 10) to get [1,2,5,7], which is strictly increasing.

example_2.py — Python

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

› Output: false

💡 Note: No single element removal can make this array strictly increasing. Removing any element still leaves violations.

example_3.py — Python

$ Input: [1,2,3]

› Output: true

💡 Note: The array is already strictly increasing, so we can remove any element and it will still work.

Visualization

Tap to expand

Understanding the Visualization

Scan for Violations

Walk through the staircase and mark every place where a step is not higher than the previous one

Analyze Violation Pattern

If there are no violations, the staircase is perfect. If there are too many violations (>2), it's unfixable

Test Smart Candidates

For each violation point, test removing either the violating step or the step before it

Verify Solution

Check if any of these targeted removals creates a perfect ascending staircase

Key Takeaway

🎯 Key Insight: Instead of testing all n possible removals, we only need to test at most 4 candidates around violation points, reducing time complexity from O(n²) to O(n).

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through array, each taking O(n) time

✓ Linear Growth

Space Complexity

O(n)

Storage for violation positions in worst case

⚡ Linearithmic Space

Constraints

2 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 1000
Must remove exactly one element
Resulting array must be strictly increasing (no equal elements allowed)

Asked in

G Google 25 a Amazon 18 Apple 15 ⊞ Microsoft 12

The optimal approach uses pattern detection to identify violation points where the strictly increasing property breaks, then intelligently tests only the relevant removal candidates around those violations. This reduces the search space from O(n) candidates to at most 4 positions, achieving O(n) time complexity with a single pass for violation detection and constant-time candidate testing.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Pattern Detection	O(n)	O(n)	First pass finds violation positions, second pass determines if one removal fixes all issues
Brute Force - Try Every Removal	O(n²)	O(n)	Try removing each element and check if the resulting array is strictly increasing

Two-Pass Pattern Detection — Algorithm Steps

First pass: scan array and record all violation positions where nums[i] <= nums[i-1]
If no violations found, return true (already strictly increasing)
If more than 2 violations, return false (can't fix with one removal)
Second pass: for each potential removal position, check if it resolves all violations
Return true if any single removal works, false otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Violations

Scan array [1,3,2,4] and find violations at position 2

Generate Candidates

Try removing elements around violation: positions 1 and 2

Test Candidates

Check if removing position 1 creates [1,2,4] - success!

Result

Return true - found valid removal

Code -

solution.c — C

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

bool isValidRemoval(int* nums, int n, int skipIndex) {
    long long prev = LLONG_MIN;
    for (int i = 0; i < n; i++) {
        if (i == skipIndex) continue;
        if (nums[i] <= prev) return false;
        prev = nums[i];
    }
    return true;
}

bool canBeIncreasing(int* nums, int n) {
    int violations[1000];
    int violationCount = 0;
    
    // First pass: find violations
    for (int i = 1; i < n; i++) {
        if (nums[i] <= nums[i-1]) {
            violations[violationCount++] = i;
        }
    }
    
    if (violationCount == 0) return true;
    if (violationCount > 2) return false;
    
    // Second pass: try candidates
    int candidates[10];
    int candidateCount = 0;
    
    for (int i = 0; i < violationCount; i++) {
        candidates[candidateCount++] = violations[i];
        candidates[candidateCount++] = violations[i] - 1;
    }
    
    for (int i = 0; i < candidateCount; i++) {
        if (isValidRemoval(nums, n, candidates[i])) {
            return true;
        }
    }
    
    return false;
}

int main() {
    int nums[1000];
    int n = 0;
    char c;
    
    scanf("%c", &c);
    while (scanf("%d", &nums[n]) == 1) {
        n++;
        scanf("%c", &c);
        if (c == ']') break;
    }
    
    printf("%s\n", canBeIncreasing(nums, n) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through array, each taking O(n) time

✓ Linear Growth

Space Complexity

O(n)

Storage for violation positions in worst case

⚡ Linearithmic Space

Constraints

2 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 1000
Must remove exactly one element
Resulting array must be strictly increasing (no equal elements allowed)

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two-Pass Pattern Detection — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler