Maximum length sub-array which satisfies the given conditions
Last Updated :
07 Dec, 2022
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++
#include <bits/stdc++.h>
using namespace std;
int maxLength(int arr[], int n)
{
int maxLen = 0;
int i = 0;
int j = i + 1;
while (j < n) {
if (arr[i] != arr[j]) {
maxLen = max(maxLen, 2);
int l = i - 1;
int r = j + 1;
while (l >= 0 && r < n && arr[l] == arr[i]
&& arr[r] == arr[j]) {
l--;
r++;
}
maxLen = max(maxLen, 2 * (r - j));
}
i++;
j = i + 1;
}
return maxLen;
}
int main()
{
int arr[] = { 1, 1, 1, 0, 0, 1, 1 };
int n = sizeof(arr) / sizeof(arr[0]);
cout << maxLength(arr, n);
return 0;
}
|
Java
class GFG {
static int maxLength(int arr[], int n)
{
int maxLen = 0;
int i = 0;
int j = i + 1;
while (j < n) {
if (arr[i] != arr[j]) {
maxLen = Math.max(maxLen, 2);
int l = i - 1;
int r = j + 1;
while (l >= 0 && r < n && arr[l] == arr[i] && arr[r] == arr[j]) {
l--;
r++;
}
maxLen = Math.max(maxLen, 2 * (r - j));
}
i++;
j = i + 1;
}
return maxLen;
}
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));
}
}
|
Python3
def maxLength(arr, n):
maxLen = 0
i = 0
j = i + 1
while (j < n):
if (arr[i] != arr[j]):
maxLen = max(maxLen, 2)
l = i - 1
r = j + 1
while (l >= 0 and r < n and arr[l] == arr[i]
and arr[r] == arr[j]):
l-= 1
r+= 1
maxLen = max(maxLen, 2 * (r - j))
i+= 1
j = i + 1
return maxLen
arr =[1, 1, 1, 0, 0, 1, 1]
n = len(arr)
print(maxLength(arr, n))
|
C#
using System;
class GFG {
static int maxLength(int[] arr, int n)
{
int maxLen = 0;
int i = 0;
int j = i + 1;
while (j < n) {
if (arr[i] != arr[j]) {
maxLen = Math.Max(maxLen, 2);
int l = i - 1;
int r = j + 1;
while (l >= 0 && r < n && arr[l] == arr[i] && arr[r] == arr[j]) {
l--;
r++;
}
maxLen = Math.Max(maxLen, 2 * (r - j));
}
i++;
j = i + 1;
}
return maxLen;
}
public static void Main(String[] args)
{
int[] arr = { 1, 1, 1, 0, 0, 1, 1 };
int n = arr.Length;
Console.WriteLine(maxLength(arr, n));
}
}
|
Javascript
<script>
function maxLength(arr, n)
{
let maxLen = 0;
let i = 0;
let j = i + 1;
while (j < n) {
if (arr[i] != arr[j]) {
maxLen = Math.max(maxLen, 2);
let l = i - 1;
let r = j + 1;
while (l >= 0 && r < n && arr[l] == arr[i]
&& arr[r] == arr[j]) {
l--;
r++;
}
maxLen = Math.max(maxLen, 2 * (r - j));
}
i++;
j = i + 1;
}
return maxLen;
}
let arr = [ 1, 1, 1, 0, 0, 1, 1 ];
let n = arr.length;
document.write(maxLength(arr, n));
</script>
|
Time Complexity: O(n2), where n is the length of the given array.
Auxiliary Space: O(1)
Alternate approach: We can maintain the max length of previous similar elements and try to form subarray with the next different contiguous element and maximize the subarray length.
Below is the implementation of the above approach:
C++
#include <iostream>
using namespace std;
int maxLength(int a[], int n)
{
int maxLen = 0;
int prev_cnt = 0, curr_cnt = 1;
for (int i = 1; i < n; i++) {
if (a[i] == a[i - 1])
curr_cnt++;
else {
prev_cnt = curr_cnt;
curr_cnt = 1;
}
maxLen = max(maxLen, min(prev_cnt, curr_cnt));
}
return (2 * maxLen);
}
int main()
{
int arr[] = { 1, 1, 1, 0, 0, 1, 1 };
int n = sizeof(arr) / sizeof(arr[0]);
cout << maxLength(arr, n);
return 0;
}
|
Java
class GFG
{
static int maxLength(int a[], int n)
{
int maxLen = 0;
int prev_cnt = 0, curr_cnt = 1;
for (int i = 1; i < n; i++)
{
if (a[i] == a[i - 1])
curr_cnt++;
else
{
prev_cnt = curr_cnt;
curr_cnt = 1;
}
maxLen = Math.max(maxLen,
Math.min(prev_cnt, curr_cnt));
}
return (2 * maxLen);
}
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));
}
}
|
Python3
def maxLength(a, n):
maxLen = 0;
prev_cnt = 0; curr_cnt = 1;
for i in range(1, n):
if (a[i] == a[i - 1]):
curr_cnt += 1;
else:
prev_cnt = curr_cnt;
curr_cnt = 1;
maxLen = max(maxLen, min(prev_cnt,
curr_cnt));
return (2 * maxLen);
arr = [ 1, 1, 1, 0, 0, 1, 1 ];
n = len(arr);
print(maxLength(arr, n));
|
C#
using System;
class GFG
{
static int maxLength(int[] a, int n)
{
int maxLen = 0;
int prev_cnt = 0, curr_cnt = 1;
for (int i = 1; i < n; i++)
{
if (a[i] == a[i - 1])
curr_cnt++;
else
{
prev_cnt = curr_cnt;
curr_cnt = 1;
}
maxLen = Math.Max(maxLen,
Math.Min(prev_cnt, curr_cnt));
}
return (2 * maxLen);
}
public static void Main()
{
int[] arr = { 1, 1, 1, 0, 0, 1, 1 };
int n = arr.Length;
Console.WriteLine(maxLength(arr, n));
}
}
|
Javascript
<script>
function maxLength(a, n)
{
let maxLen = 0;
let prev_cnt = 0, curr_cnt = 1;
for (let i = 1; i < n; i++) {
if (a[i] == a[i - 1])
curr_cnt++;
else {
prev_cnt = curr_cnt;
curr_cnt = 1;
}
maxLen = Math.max(maxLen, Math.min(prev_cnt, curr_cnt));
}
return (2 * maxLen);
}
let arr = [ 1, 1, 1, 0, 0, 1, 1 ];
let n = arr.length;
document.write(maxLength(arr, n));
</script>
|
Time Complexity: O(n), where n is the length of the given array.
Auxiliary Space: O(1)
Similar Reads
Maximum size of sub-array that satisfies the given condition
Given an array arr[] of integers. The task is to return the length of the maximum size sub-array such that either one of the condition is satisfied: arr[k] > arr[k + 1] when k is odd and arr[k] < arr[k + 1] when k is even.arr[k] > arr[k + 1] when k is even and arr[k] < arr[k + 1] when k
6 min read
Maximum length of same indexed subarrays from two given arrays satisfying the given condition
Given two arrays arr[] and brr[] and an integer C, the task is to find the maximum possible length, say K, of the same indexed subarrays such that the sum of the maximum element in the K-length subarray in brr[] with the product between K and sum of the K-length subarray in arr[] does not exceed C.
15+ min read
Find maximum value of Indices of Array that satisfy the given conditions
Given an integer N (N ? 5) Then assume you have two infinite arrays X and Y where X[] is an array of element N and each element of Y[] is 2i where i is the index of the array, the task is to find two indices let's say A and B which are the maximum value of the index at which the prefix sum in X[] is
9 min read
Longest sub-sequence that satisfies the given conditions
Given an array arr[] of N integers, the task is to find the longest sub-sequence in the given array such that for all pairs from the sub-sequence (arr[i], arr[j]) where i != j either arr[i] divides arr[j] or vice versa. If no such sub-sequence exists then print -1.Examples: Input: arr[] = {2, 4, 6,
7 min read
Count subsequences which contains both the maximum and minimum array element
Given an array arr[] consisting of N integers, the task is to find the number of subsequences which contain the maximum as well as the minimum element present in the given array. Example : Input: arr[] = {1, 2, 3, 4}Output: 4Explanation: There are 4 subsequence {1, 4}, {1, 2, 4}, {1, 3, 4}, {1, 2, 3
6 min read
Maximum score of Array using increasing subsequence and subarray with given conditions
Given an array arr[]. The task is to find the maximum score that can be achieved from arr[] for i=[1, N-2]. The conditions for scoring are given below. If arr[0...j] < arr[i] < arr[i+1...N-1], then score = 2.If arr[i-1] < arr[i] < arr[i+1] and previous condition is not satisfied, then sc
6 min read
Queries to find maximum sum contiguous subarrays of given length in a rotating array
Given an array arr[] of N integers and Q queries of the form {X, Y} of the following two types: If X = 1, rotate the given array to the left by Y positions.If X = 2, print the maximum sum subarray of length Y in the current state of the array. Examples: Input: N = 5, arr[] = {1, 2, 3, 4, 5}, Q = 2,
13 min read
Find the maximum subarray XOR in a given array
Given an array of integers. The task is to find the maximum subarray XOR value in the given array. Examples: Input: arr[] = {1, 2, 3, 4}Output: 7Explanation: The subarray {3, 4} has maximum XOR value Input: arr[] = {8, 1, 2, 12, 7, 6}Output: 15Explanation: The subarray {1, 2, 12} has maximum XOR val
15+ min read
Maximum length of subarray with same sum at corresponding indices from two Arrays
Given two arrays A[] and B[] both consisting of N integers, the task is to find the maximum length of subarray [i, j] such that the sum of A[i... j] is equal to B[i... j]. Examples: Input: A[] = {1, 1, 0, 1}, B[] = {0, 1, 1, 0}Output: 3Explanation: For (i, j) = (0, 2), sum of A[0... 2] = sum of B[0.
6 min read
Maximum in array which is at-least twice of other elements
Given an array of integers of length n. Our task is to return the index of the max element if the it is at least twice as much as every other number in the array. If the max element does not satisfy the condition return -1. Examples: Input : arr = {3, 6, 1, 0} Output : 1 Here, 6 is the largest integ
7 min read