Length of smallest subarray required to be removed to make remaining elements consecutive

import java.util.Arrays;

public class ShortestSubarray {
    
    // Function to check if the elements in a subarray from index i to j
    // form a consecutive sequence or not
    static boolean isConsecutive(int[] arr, int i, int j) {
        // Sort the elements in the subarray
        Arrays.sort(arr, i, j + 1);
        
        for (int k = i + 1; k <= j; k++) {
            // Check if the elements in the sorted subarray are consecutive
            if (arr[k] != arr[k - 1] + 1) {
                return false;
            }
        }
        return true;
    }
    
    // Function to find the length of the smallest subarray required to be
    // removed to make the remaining array elements consecutive
    static int shortestSubarray(int[] arr) {
        int n = arr.length;
        
        // Initialize the minimum length to the size of the input array
        int minLen = n;
        
        for (int i = 0; i < n; i++) {
            // Generate all possible subarrays of the input array
            for (int j = i; j < n; j++) {
                // Create a temporary array to store the remaining elements
                // after removing a subarray
                int[] temp = new int[n];
                int k = 0;
                
                for (int l = 0; l < n; l++) {
                    // Copy the elements from the input array to the temporary
                    // array, except those in the current subarray
                    if (l < i || l > j) {
                        temp[k++] = arr[l];
                    }
                }
                
                // Check if the remaining elements in the temporary array form
                // a consecutive sequence
                if (isConsecutive(temp, 0, k - 1)) {
                    // Update the minimum length of the subarray removed so far
                    // that satisfies the condition
                    minLen = Math.min(minLen, j - i + 1);
                }
            }
        }
        
        // Return the minimum length of the subarray removed
        return minLen;
    }
    
    // Driver code
    public static void main(String[] args) {
        int[] arr = { 1, 2, 3, 7, 5, 4, 5 };
        System.out.println(shortestSubarray(arr));
    }
}

// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;

class GFG{

// Function to find the length of the
// smallest subarray to be removed to
// make remaining array elements consecutive
static void shortestSubarray(int A[], int N)
{
    int i;

    // Store the ending index of the
    // longest prefix consecutive array
    int left_index;

    // Traverse the array to find the
    // longest prefix consecutive sequence
    for(i = 0; i < N - 1; i++) 
    {
        if (A[i] + 1 != A[i + 1])
            break;
    }

    // A[0...left_index] is the
    // prefix consecutive sequence
    left_index = i;

    // Store the starting index of the
    // longest suffix consecutive sequence
    int right_index;

    // Traverse the array to find the
    // longest suffix consecutive sequence
    for(i = N - 1; i >= 1; i--) 
    {
        if (A[i] != A[i - 1] + 1)
            break;
    }

    // A[right_index...N-1] is
    // the consecutive sequence
    right_index = i;

    int updated_right;

    // Store the smallest subarray
    // required to be removed
    int minLength = Math.min(N - left_index - 1,
                             right_index);

    // Check if subarray from the
    // middle can be removed
    if (A[right_index] <= A[left_index] + 1) 
    {
        
        // Update the right index s.t.
        // A[0, N-1] is consecutive
        updated_right = right_index + A[left_index] - 
                     A[right_index] + 1;

        // If updated_right < N, then
        // update the minimumLength
        if (updated_right < N)
            minLength = Math.min(minLength,
                                 updated_right - 
                                 left_index - 1);
    }

    // Print the required result
    System.out.println(minLength);
}

// Driver Code
public static void main(String[] args)
{
    int arr[] = { 1, 2, 3, 7, 4, 3, 5 };
    int N = arr.length;
    
    shortestSubarray(arr, N);
}
}

// This code is contributed by Kingash