Remove One Element to Make the Array Strictly Increasing

Remove One Element to Make the Array Strictly Increasing - Problem

Array Easy

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

If the array is already strictly increasing, return true.

The array nums is strictly increasing if nums[i - 1] < nums[i] for each index (1 <= i < nums.length).

Input & Output

Example 1 — Can Remove One Element

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

› Output: true

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

Example 2 — Already Strictly Increasing

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

› Output: false

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

Example 3 — Already Strictly Increasing

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

› Output: true

💡 Note: Already strictly increasing: 1 < 2 < 3, so return true

Constraints

2 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 1000

Visualization

Tap to expand

Understanding the Visualization

Input Array

Given array [1,2,10,5,7] with violation at position 2

Find Violation

Element 10 breaks the increasing sequence

Remove Element

After removing 10, we get [1,2,5,7] which is strictly increasing

Key Takeaway

🎯 Key Insight: At most one element can be 'out of place' for the array to be fixable by removing exactly one element

Asked in

F Facebook 25 G Google 20

The key insight is that if we can make the array strictly increasing by removing exactly one element, there can be at most one violation point. The optimized approach scans once to count violations and validates if removal fixes the sequence. Time: O(n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Try Removing Each Element	O(n²)	O(n)	Try removing each element and check if remaining array is strictly increasing
Single Pass - Count Violations	O(n)	O(1)	Count violations while scanning and check if removing one element fixes all issues

Brute Force - Try Removing Each Element — Algorithm Steps

For each index i from 0 to n-1
Create new array without element at index i
Check if new array is strictly increasing
If any removal works, return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Array

Start with [2,3,1,2] - not strictly increasing

Try Removals

Remove each element and test remaining array

Found Solution

Removing index 2 gives [2,3,2] - still not working, but removing index 3 gives [2,3,1] - still not working, removing index 0 gives [3,1,2] - not working, removing index 1 gives [2,1,2] - not working. Actually removing index 2 gives [2,3,2] which is not strictly increasing either.

Code -

solution.c — C

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

bool isStrictlyIncreasing(int* arr, int len) {
    for (int i = 1; i < len; i++) {
        if (arr[i] <= arr[i-1]) {
            return false;
        }
    }
    return true;
}

bool solution(int* nums, int n) {
    // Try removing each element
    for (int i = 0; i < n; i++) {
        // Create array without element at index i
        int* temp = (int*)malloc((n-1) * sizeof(int));
        int idx = 0;
        for (int j = 0; j < n; j++) {
            if (j != i) {
                temp[idx++] = nums[j];
            }
        }
        
        if (isStrictlyIncreasing(temp, n-1)) {
            free(temp);
            return true;
        }
        free(temp);
    }
    
    return false;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Simple JSON array parsing
    int nums[1000];
    int n = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    bool result = solution(nums, n);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n elements, we check if remaining n-1 elements form increasing sequence

⚠ Quadratic Growth

Space Complexity

O(n)

Creating temporary arrays of size n-1 for each removal attempt

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~15 min Avg. Time

890 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 - Try Removing Each Element — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler