# 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.

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++ program for the above approach ` `#include` `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`

 `// 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`

 `# 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))`

 `// 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`

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.

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.

Article Tags :