Length of smallest subarray to be removed such that the remaining array is sorted

Given an array arr[] consisting of N integers, the task is to print the length of the smallest subarray to be removed from arr[] such that the remaining array is sorted.

Examples:

Input: arr[] = {1, 2, 3, 10, 4, 2, 3, 5}
Output: 3
Explanation:
The smallest subarray to be remove is {10, 4, 2} of length 3. The remaining array is {1, 2, 3, 3, 5} which are sorted.
Another correct solution is to remove the subarray [3, 10, 4].

Input: arr[] = {5, 4, 3, 2, 1}
Output: 4
Explanation:
Since the array is strictly decreasing, only a single element need to be kept in the array.
Therefore, required answer is 4.

Approach: The problem can be solved based on the following three ways to remove a subarray:



  1. Remove the subarray from the left i.e left suffix.
  2. Remove the subarray from the right ie, prefix.
  3. Remove the subarray from the middle and merge the left and right part of the array.
  1. Iterate over the arr[] from left to right, find the first index left that arr[left] > arr[left + 1]. So the subarray length to be removed to make the array sorted is N-left-1.
  2. If left == N – 1, this array is already sorted, so return 0.
  3. Iterate over the arr[] from right to left, find the first index right that arr[right] < arr[right – 1]. So the subarray length to be removed to make the array sorted is right.
  4. Now initialize a variable mincount and take the minimum of N-left-1 and right.
  5. Now calculate the minimum length of subarray to be removed from the middle of the array as well:
    1. Let i = 0, j = right. And examine if elements in between, i and j (exclusive) can be deleted by comparing arr[i] and arr[j].
    2. If arr[j] >= arr[i], try to update the answer using j – i – 1 and increment i to tighten the window.
    3. If arr[j] < arr[i], elements cannot be deleted in between, so increment j to loosen the window.
    4. Traverse the loop until i > left or j == N. And update the answer.
  6. Return the mincount.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for the above approach
#include<bits/stdc++.h>
using namespace std;
 
// Find the length of the shortest subarray
int findLengthOfShortestSubarray(int arr[], int N)
{
     
    // To store the result
    int minlength = INT_MAX;
 
    int left = 0;
    int right = N - 1;
 
    // Calculate the possible length of
    // the sorted subarray from left
    while (left < right &&
       arr[left + 1] >= arr[left])
    {
        left++;
    }
 
    // Array is sorted
    if (left == N - 1)
        return 0;
 
    // Calculate the possible length of
    // the sorted subarray from left
    while (right > left &&
       arr[right - 1] <= arr[right])
    {
        right--;
    }
 
    // Update the result
    minlength = min(N - left - 1, right);
 
    // Calculate the possible length
    // in the middle we can delete
    // and update the result
    int j = right;
    for(int i = 0; i < left + 1; i++)
    {
        if (arr[i] <= arr[j])
        {
             
            // Update the result
            minlength = min(minlength, j - i - 1);
        }
        else if (j < N - 1)
        {
            j++;
        }
        else
        {
            break;
        }
    }
 
    // Return the result
    return minlength;
}
 
// Driver Code
int main()
{
    int arr[] = { 6, 3, 10, 11, 15,
                  20, 13, 3, 18, 12 };
    int N = sizeof(arr) / sizeof(arr[0]);
     
    // Function call
    cout << (findLengthOfShortestSubarray(arr, N));
}
 
// This code is contributed by divyeshrabadiya07

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for the
// above approach
import java.util.*;
class GFG {
 
// Find the length of the shortest subarray
static int findLengthOfShortestSubarray(int arr[],
                                        int N)
{
  // To store the result
  int minlength = Integer.MAX_VALUE;
 
  int left = 0;
  int right = N - 1;
 
  // Calculate the possible length of
  // the sorted subarray from left
  while (left < right &&
         arr[left + 1] >= arr[left])
  {
    left++;
  }
 
  // Array is sorted
  if (left == N - 1)
    return 0;
 
  // Calculate the possible length of
  // the sorted subarray from left
  while (right > left &&
         arr[right - 1] <= arr[right])
  {
    right--;
  }
 
  // Update the result
  minlength = Math.min(N - left - 1,
                       right);
 
  // Calculate the possible length
  // in the middle we can delete
  // and update the result
  int j = right;
   
  for (int i = 0; i < left + 1; i++)
  {
    if (arr[i] <= arr[j])
    {
      // Update the result
      minlength = Math.min(minlength,
                           j - i - 1);
    }
    else if (j < N - 1)
    {
      j++;
    }
    else
    {
      break;
    }
  }
 
  // Return the result
  return minlength;
}
 
// Driver Code
public static void main(String[] args)
{
  int arr[] = {6, 3, 10, 11, 15,
               20, 13, 3, 18, 12};
  int N = arr.length;
 
  // Function call
  System.out.print(
         (findLengthOfShortestSubarray(arr, N)));
}
}
 
// This code is contributed by Chitranayal

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program for the above approach
import sys
 
# Find the length of the shortest subarray
def findLengthOfShortestSubarray(arr):
 
    # To store the result
    minlength = sys.maxsize
 
    left = 0
    right = len(arr) - 1
 
    # Calculate the possible length of
    # the sorted subarray from left
    while left < right and arr[left + 1] >= arr[left]:
        left += 1
 
    # Array is sorted
    if left == len(arr) - 1:
        return 0
 
    # Calculate the possible length of
    # the sorted subarray from left
    while right > left and arr[right-1] <= arr[right]:
        right -= 1
 
    # Update the result
    minlength = min(len(arr) - left - 1, right)
 
    # Calculate the possible length
    # in the middle we can delete
    # and update the result
    j = right
    for i in range(left + 1):
 
        if arr[i] <= arr[j]:
 
            # Update the result
            minlength = min(minlength, j - i - 1)
 
        elif j < len(arr) - 1:
 
            j += 1
 
        else:
 
            break
 
    # Return the result
    return minlength
 
 
# Driver Code
arr = [6, 3, 10, 11, 15, 20, 13, 3, 18, 12]
 
# Function Call
print(findLengthOfShortestSubarray(arr))

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for the
// above approach
using System;
 
class GFG {
 
// Find the length of the shortest subarray
static int findLengthOfShortestSubarray(int []arr,
                                        int N)
{
   
  // To store the result
  int minlength = int.MaxValue;
 
  int left = 0;
  int right = N - 1;
 
  // Calculate the possible length of
  // the sorted subarray from left
  while (left < right &&
         arr[left + 1] >= arr[left])
  {
    left++;
  }
 
  // Array is sorted
  if (left == N - 1)
    return 0;
 
  // Calculate the possible length of
  // the sorted subarray from left
  while (right > left &&
         arr[right - 1] <= arr[right])
  {
    right--;
  }
 
  // Update the result
  minlength = Math.Min(N - left - 1,
                       right);
 
  // Calculate the possible length
  // in the middle we can delete
  // and update the result
  int j = right;
   
  for(int i = 0; i < left + 1; i++)
  {
    if (arr[i] <= arr[j])
    {
       
      // Update the result
      minlength = Math.Min(minlength,
                           j - i - 1);
    }
    else if (j < N - 1)
    {
      j++;
    }
    else
    {
      break;
    }
  }
 
  // Return the result
  return minlength;
}
 
// Driver Code
public static void Main(String[] args)
{
  int []arr = { 6, 3, 10, 11, 15,
                20, 13, 3, 18, 12 };
  int N = arr.Length;
 
  // Function call
  Console.Write(findLengthOfShortestSubarray(
                 arr, N));
}
}
 
// This code is contributed by Amit Katiyar

chevron_right


Output: 

8








 

Time Complexity: O(N)
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up

Recommended Posts:


Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.