Shortest Subarray to be Removed to Make Array Sorted

Shortest Subarray to be Removed to Make Array Sorted - Problem

Given an integer array arr, remove a subarray (can be empty) from arr such that the remaining elements in arr are non-decreasing.

Return the length of the shortest subarray to remove.

A subarray is a contiguous subsequence of the array.

Input & Output

Example 1 — Middle Elements Out of Order

$ Input: arr = [1,2,3,10,4,2,3,5]

› Output: 3

💡 Note: Remove subarray [10,4,2] to get [1,2,3,3,5] which is non-decreasing. Minimum length is 3.

Example 2 — Remove Prefix

$ Input: arr = [5,4,3,2,1]

› Output: 4

💡 Note: Remove [5,4,3,2] to keep [1], or remove [4,3,2,1] to keep [5]. Both give length 4.

Example 3 — Already Sorted

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

› Output: 0

💡 Note: Array is already non-decreasing, so no elements need to be removed.

Constraints

1 ≤ arr.length ≤ 10⁵
0 ≤ arr[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

F Facebook 35 a Amazon 28 G Google 22 M Microsoft 18

The key insight is to find the longest sorted prefix and suffix, then optimally connect them. The best approach uses two pointers to achieve O(n) time complexity by identifying three removal options: remove suffix, remove prefix, or remove middle section. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force - Try All Subarrays

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

For each possible starting and ending position, remove the subarray and check if the remaining elements form a non-decreasing sequence. Track the minimum length of removed subarray that makes the array sorted.

Optimized Two Pointers - Linear Time

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

Find the longest sorted prefix and suffix in one pass, then use two pointers to efficiently find the optimal connection point between them without trying all combinations.

Two Pointers - Find Prefix and Suffix

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

Find the longest non-decreasing sequence from the start and the longest from the end. Then try to connect parts of the prefix with parts of the suffix to minimize the removal length.

Brute Force - Try All Subarrays — Algorithm Steps

Iterate through all possible start positions
For each start, try all possible end positions
Remove subarray and check if remaining array is sorted
Track minimum length that works

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Subarray [0,0]

Remove first element, check if remaining is sorted

Try Subarray [0,1]

Remove first two elements, check if remaining is sorted

Continue All Combinations

Find minimum length that works

Code -

solution.c — C

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

int isSortedAfterRemoval(int* arr, int n, int start, int end) {
    int prev = INT_MIN;
    for (int i = 0; i < n; i++) {
        if (i >= start && i <= end && start != -1) continue;
        if (arr[i] < prev) return 0;
        prev = arr[i];
    }
    return 1;
}

int solution(int* arr, int n) {
    // First check if array is already sorted (empty removal)
    if (isSortedAfterRemoval(arr, n, -1, -1)) {
        return 0;
    }
    
    int minLength = n;
    
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            if (isSortedAfterRemoval(arr, n, i, j)) {
                int length = j - i + 1;
                if (length < minLength) {
                    minLength = length;
                }
            }
        }
    }
    
    return minLength;
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    static int arr[100000];
    int n = 0;
    
    char* p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        arr[n++] = (int)strtol(p, &p, 10);
    }
    
    int result = solution(arr, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Two nested loops for subarray positions O(n²), plus O(n) to check if remaining array is sorted

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables for tracking positions and minimum length

✓ Linear Space

32.4K Views

Medium-High Frequency

~25 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Subarrays — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler