Shortest Subarray to be Removed to Make Array Sorted

Shortest Subarray to be Removed to Make Array Sorted - Problem

Imagine you have an array of integers that's almost sorted, but has some elements out of place. Your goal is to remove the shortest possible contiguous subarray to make the remaining elements completely non-decreasing.

For example, given [1, 2, 3, 10, 4, 2, 3, 5], you could remove the subarray [10, 4, 2] to get [1, 2, 3, 3, 5], which is non-decreasing.

Key Points:

A subarray is a contiguous sequence of elements
You can remove an empty subarray (length 0) if the array is already sorted
The remaining elements must be in non-decreasing order (duplicates allowed)
Find the minimum length subarray to remove

Input & Output

example_1.py — Basic Case

$ Input: [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. This is the shortest possible removal.

example_2.py — Already Sorted

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

› Output: 0

💡 Note: Array is already non-decreasing, so no removal needed. Return 0.

example_3.py — Remove Entire Middle

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

› Output: 4

💡 Note: Keep only one element (any single element is sorted). Remove 4 elements to achieve this.

Constraints

1 ≤ arr.length ≤ 10⁵
0 ≤ arr[i] ≤ 10⁹
The array contains at least 1 element
Elements can be equal (non-decreasing allows duplicates)

Visualization

Tap to expand

Understanding the Visualization

Identify Sorted Prefix

Find the longest non-decreasing sequence from the start

Identify Sorted Suffix

Find the longest non-decreasing sequence from the end

Evaluate Options

Consider three removal strategies and pick the best

Apply Two Pointers

Use two pointers to find optimal connection between prefix and suffix

Key Takeaway

🎯 Key Insight: The optimal solution leverages the fact that we want to preserve as much of the already-sorted portions as possible. By identifying the longest sorted prefix and suffix, we can minimize the middle section that needs to be removed.

Asked in

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

The optimal approach uses the two pointers technique to identify the longest sorted prefix and suffix, then efficiently finds the minimum middle section to remove. Key insight: the answer is the minimum of three options - remove everything after the prefix, remove everything before the suffix, or connect prefix and suffix optimally. Time complexity: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Subarrays)	O(n³)	O(1)	Try removing every possible subarray and check if the result is sorted
Two Pointers (Optimal)	O(n)	O(1)	Find longest sorted prefix and suffix, then connect them optimally

Brute Force (Try All Subarrays) — Algorithm Steps

Try all possible starting positions i (0 to n)
For each i, try all possible ending positions j (i to n)
Remove subarray from i to j and check if remaining array is sorted
Keep track of the minimum removal length that creates a sorted array

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with length 0

Check if array is already sorted

Try length 1 removals

Remove each single element and check

Increase length gradually

Continue until a valid removal is found

Code -

solution.c — C

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

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

int findLengthOfShortestSubarray(int* arr, int n) {
    for (int length = 0; length <= n; length++) {
        for (int start = 0; start <= n - length; start++) {
            if (isSorted(arr, n, start, start + length)) {
                return length;
            }
        }
    }
    return n;
}

int main() {
    int arr[1000];
    int n = 0;
    int num;
    
    while (scanf("%d", &num) == 1) {
        arr[n++] = num;
        char c = getchar();
        if (c == '\n') break;
    }
    
    printf("%d\n", findLengthOfShortestSubarray(arr, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) pairs of start/end positions, O(n) to check if remaining array is sorted

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

42.0K Views

Medium Frequency

~25 min Avg. Time

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