Maximum length sub-array which satisfies the given conditions

Given a binary array arr[], the task is to find the length of the longest sub-array of the given array such that if the sub-array is divided into two equal-sized sub-arrays then both the sub-arrays either contain all 0s or all 1s. For example, the two sub-arrays must be of the form {0, 0, 0, 0} and {1, 1, 1, 1} or {1, 1, 1} and {0, 0, 0} and not {0, 0, 0} and {0, 0, 0}

Examples:

Input: arr[] = {1, 1, 1, 0, 0, 1, 1}
Output: 4
{1, 1, 0, 0} and {0, 0, 1, 1} are the maximum length valid sub-arrays.

Input: arr[] = {1, 1, 0, 0, 0, 1, 1, 1, 1}
Output: 6
{0, 0, 0, 1, 1, 1} is the only valid sub-array with maximum length.

Approach: For every two consecutive elements of the array say arr[i] and arr[j] where j = i + 1, treat them as the middle two elements of the required sub-array. In order for this sub-array to be a valid sub-array arr[i] must not be equal to arr[j]. If it can be a valid sub-array then its size is 2. Now, try to extend this sub-array to a bigger size by decrementing i and incrementing j at the same time and all the elements before index i and after index j must be equal to arr[i] and arr[j] respectively. Print the size of the longest such sub-array found so far.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to return the maximum length
// of the required sub-array
int maxLength(int arr[], int n)
{
    int maxLen = 0;
  
    // For the first consecutive
    // pair of elements
    int i = 0;
    int j = i + 1;
  
    // While a consecutive pair
    // can be selected
    while (j < n) {
  
        // If current pair forms a
        // valid sub-array
        if (arr[i] != arr[j]) {
  
            // 2 is the length of the
            // current sub-array
            maxLen = max(maxLen, 2);
  
            // To extend the sub-array both ways
            int l = i - 1;
            int r = j + 1;
  
            // While elements at indices l and r
            // are part of a valid sub-array
            while (l >= 0 && r < n && arr[l] == arr[i]
                   && arr[r] == arr[j]) {
                l--;
                r++;
            }
  
            // Update the maximum length so far
            maxLen = max(maxLen, 2 * (r - j));
        }
  
        // Select the next consecutive pair
        i++;
        j = i + 1;
    }
  
    // Return the maximum length
    return maxLen;
}
  
// Driver code
int main()
{
    int arr[] = { 1, 1, 1, 0, 0, 1, 1 };
    int n = sizeof(arr) / sizeof(arr[0]);
  
    cout << maxLength(arr, n);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach
class GFG {
  
    // Function to return the maximum length
    // of the required sub-array
    static int maxLength(int arr[], int n)
    {
        int maxLen = 0;
  
        // For the first consecutive
        // pair of elements
        int i = 0;
        int j = i + 1;
  
        // While a consecutive pair
        // can be selected
        while (j < n) {
  
            // If current pair forms a
            // valid sub-array
            if (arr[i] != arr[j]) {
  
                // 2 is the length of the
                // current sub-array
                maxLen = Math.max(maxLen, 2);
  
                // To extend the sub-array both ways
                int l = i - 1;
                int r = j + 1;
  
                // While elements at indices l and r
                // are part of a valid sub-array
                while (l >= 0 && r < n && arr[l] == arr[i] && arr[r] == arr[j]) {
                    l--;
                    r++;
                }
  
                // Update the maximum length so far
                maxLen = Math.max(maxLen, 2 * (r - j));
            }
  
            // Select the next consecutive pair
            i++;
            j = i + 1;
        }
  
        // Return the maximum length
        return maxLen;
    }
  
    // Driver code
    public static void main(String[] args)
    {
        int arr[] = { 1, 1, 1, 0, 0, 1, 1 };
        int n = arr.length;
  
        System.out.println(maxLength(arr, n));
    }
}
  
// This code is contributed by AnkitRai01

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of the approach
  
# Function to return the maximum length
# of the required sub-array
def maxLength(arr, n):
    maxLen = 0
  
    # For the first consecutive
    # pair of elements
    i = 0
    j = i + 1
  
    # While a consecutive pair
    # can be selected
    while (j < n):
  
        # If current pair forms a
        # valid sub-array
        if (arr[i] != arr[j]):
  
            # 2 is the length of the
            # current sub-array
            maxLen = max(maxLen, 2)
  
            # To extend the sub-array both ways
            l = i - 1
            r = j + 1
  
            # While elements at indices l and r
            # are part of a valid sub-array
            while (l >= 0 and r < n and arr[l] == arr[i]
                and arr[r] == arr[j]):
                l-= 1
                r+= 1
  
            # Update the maximum length so far
            maxLen = max(maxLen, 2 * (r - j))
  
        # Select the next consecutive pair
        i+= 1
        j = i + 1
  
    # Return the maximum length
    return maxLen
  
# Driver code
  
arr =[1, 1, 1, 0, 0, 1, 1]
n = len(arr)
  
print(maxLength(arr, n))
  
# This code is contributed by mohit kumar 29

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the approach
using System;
  
class GFG {
  
    // Function to return the maximum length
    // of the required sub-array
    static int maxLength(int[] arr, int n)
    {
        int maxLen = 0;
  
        // For the first consecutive
        // pair of elements
        int i = 0;
        int j = i + 1;
  
        // While a consecutive pair
        // can be selected
        while (j < n) {
  
            // If current pair forms a
            // valid sub-array
            if (arr[i] != arr[j]) {
  
                // 2 is the length of the
                // current sub-array
                maxLen = Math.Max(maxLen, 2);
  
                // To extend the sub-array both ways
                int l = i - 1;
                int r = j + 1;
  
                // While elements at indices l and r
                // are part of a valid sub-array
                while (l >= 0 && r < n && arr[l] == arr[i] && arr[r] == arr[j]) {
                    l--;
                    r++;
                }
  
                // Update the maximum length so far
                maxLen = Math.Max(maxLen, 2 * (r - j));
            }
  
            // Select the next consecutive pair
            i++;
            j = i + 1;
        }
  
        // Return the maximum length
        return maxLen;
    }
  
    // Driver code
    public static void Main(String[] args)
    {
        int[] arr = { 1, 1, 1, 0, 0, 1, 1 };
        int n = arr.Length;
  
        Console.WriteLine(maxLength(arr, n));
    }
}
  
// This code is contributed by 29AjayKumar

chevron_right