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:
- Remove the subarray from the left i.e left suffix.
- Remove the subarray from the right ie, prefix.
- Remove the subarray from the middle and merge the left and right part of the array.
- 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.
- If left == N – 1, this array is already sorted, so return 0.
- 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.
- Now initialize a variable mincount and take the minimum of N-left-1 and right.
- Now calculate the minimum length of subarray to be removed from the middle of the array as well:
- 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].
- If arr[j] >= arr[i], try to update the answer using j – i – 1 and increment i to tighten the window.
- If arr[j] < arr[i], elements cannot be deleted in between, so increment j to loosen the window.
- Traverse the loop until i > left or j == N. And update the answer.
- Return the mincount.
Below is the implementation of the above approach:
C++
#include<bits/stdc++.h>
using namespace std;
int findLengthOfShortestSubarray(int arr[], int N)
{
int minlength = INT_MAX;
int left = 0;
int right = N - 1;
while (left < right &&
arr[left + 1] >= arr[left])
{
left++;
}
if (left == N - 1)
return 0;
while (right > left &&
arr[right - 1] <= arr[right])
{
right--;
}
minlength = min(N - left - 1, right);
int j = right;
for(int i = 0; i < left + 1; i++)
{
if (arr[i] <= arr[j])
{
minlength = min(minlength, j - i - 1);
}
else if (j < N - 1)
{
j++;
}
else
{
break;
}
}
return minlength;
}
int main()
{
int arr[] = { 6, 3, 10, 11, 15,
20, 13, 3, 18, 12 };
int N = sizeof(arr) / sizeof(arr[0]);
cout << (findLengthOfShortestSubarray(arr, N));
}
|
Java
import java.util.*;
class GFG {
static int findLengthOfShortestSubarray(int arr[],
int N)
{
int minlength = Integer.MAX_VALUE;
int left = 0;
int right = N - 1;
while (left < right &&
arr[left + 1] >= arr[left])
{
left++;
}
if (left == N - 1)
return 0;
while (right > left &&
arr[right - 1] <= arr[right])
{
right--;
}
minlength = Math.min(N - left - 1,
right);
int j = right;
for (int i = 0; i < left + 1; i++)
{
if (arr[i] <= arr[j])
{
minlength = Math.min(minlength,
j - i - 1);
}
else if (j < N - 1)
{
j++;
}
else
{
break;
}
}
return minlength;
}
public static void main(String[] args)
{
int arr[] = {6, 3, 10, 11, 15,
20, 13, 3, 18, 12};
int N = arr.length;
System.out.print(
(findLengthOfShortestSubarray(arr, N)));
}
}
|
Python3
import sys
def findLengthOfShortestSubarray(arr):
minlength = sys.maxsize
left = 0
right = len(arr) - 1
while left < right and arr[left + 1] >= arr[left]:
left += 1
if left == len(arr) - 1:
return 0
while right > left and arr[right-1] <= arr[right]:
right -= 1
minlength = min(len(arr) - left - 1, right)
j = right
for i in range(left + 1):
if arr[i] <= arr[j]:
minlength = min(minlength, j - i - 1)
elif j < len(arr) - 1:
j += 1
else:
break
return minlength
arr = [6, 3, 10, 11, 15, 20, 13, 3, 18, 12]
print(findLengthOfShortestSubarray(arr))
|
C#
using System;
class GFG {
static int findLengthOfShortestSubarray(int []arr,
int N)
{
int minlength = int.MaxValue;
int left = 0;
int right = N - 1;
while (left < right &&
arr[left + 1] >= arr[left])
{
left++;
}
if (left == N - 1)
return 0;
while (right > left &&
arr[right - 1] <= arr[right])
{
right--;
}
minlength = Math.Min(N - left - 1,
right);
int j = right;
for(int i = 0; i < left + 1; i++)
{
if (arr[i] <= arr[j])
{
minlength = Math.Min(minlength,
j - i - 1);
}
else if (j < N - 1)
{
j++;
}
else
{
break;
}
}
return minlength;
}
public static void Main(String[] args)
{
int []arr = { 6, 3, 10, 11, 15,
20, 13, 3, 18, 12 };
int N = arr.Length;
Console.Write(findLengthOfShortestSubarray(
arr, N));
}
}
|
Javascript
<script>
function findLengthOfShortestSubarray(arr, N)
{
let minlength = Number.MAX_VALUE;
let left = 0;
let right = N - 1;
while (left < right &&
arr[left + 1] >= arr[left])
{
left++;
}
if (left == N - 1)
return 0;
while (right > left &&
arr[right - 1] <= arr[right])
{
right--;
}
minlength = Math.min(N - left - 1,
right);
let j = right;
for(let i = 0; i < left + 1; i++)
{
if (arr[i] <= arr[j])
{
minlength = Math.min(minlength,
j - i - 1);
}
else if (j < N - 1)
{
j++;
}
else
{
break;
}
}
return minlength;
}
let arr = [ 6, 3, 10, 11, 15,
20, 13, 3, 18, 12];
let N = arr.length;
document.write(
(findLengthOfShortestSubarray(arr, N)));
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(1)
Related Topic: Subarrays, Subsequences, and Subsets in Array