Longest subsequence having equal numbers of 0 and 1
Last Updated :
07 Nov, 2022
Given a binary array, the task is to find the size of the largest sub_sequence which having equal number of zeros and one.
Examples :
Input : arr[] = { 1, 0, 0, 1, 0, 0, 0, 1 }
Output: 6
Input : arr[] = { 0, 0, 1, 1, 1, 1, 1, 0, 0 }
Output : 8
simple solution is that we generate all possible sub_sequence and find which sub_sequence have equal number of zeros & one ( it's size should be maximum).
Below is the implementation of above idea
C++
#include <bits/stdc++.h>
using namespace std;
int generateSubsequences(int arr[],
int n)
{
// store the maximum length
// sub_sequence having equal
// number of zeros and ones
int result = 0;
// Number of subsequences is (2**n -1)
unsigned int opsize = pow(2, n);
// Run from counter 000..1 to 111..1
for (int counter = 1; counter < opsize;
counter++)
{
// store count of zeros and one
int countzero = 0;
int countone = 0, current_size = 0;
for (int j = 0; j < n; j++)
{
// Check if jth bit in the
// counter is set. If set
// then print jth element
// from arr[]
if (counter & (1 << j))
{
if (arr[j])
countone++;
else
countzero++;
current_size++;
}
}
// update maximum size
if (countzero == countone)
result = max(current_size,
result);
}
return result;
}
// Driver Code
int main()
{
int arr[] = { 1, 0, 0, 1,
0, 0, 0, 1 };
int n = sizeof(arr) / sizeof(arr[0]);
cout << "largest Subsequences having "
"equal number of 0 & 1 is "
<< generateSubsequences(arr, n);
return 0;
}
// Java program for Longest subsequence
// having equal numbers of 0 and 1
import java.io.*;
class GFG {
static int generateSubsequences(int arr[],
int n)
{
// store the maximum length
// sub_sequence having equal
// number of zeros and ones
int result = 0;
// Number of subsequences
// is (2**n -1)
long opsize = (long) Math.pow(2, n);
// Run from counter
// 000..1 to 111..1
for (int counter = 1; counter < opsize;
counter++)
{
// store count of zeros and one
int countzero = 0;
int countone = 0, current_size = 0;
for (int j = 0; j < n; j++)
{
// Check if jth bit in the
// counter is set. If set
// then print jth element
// from arr[]
if ((counter & (1 << j))>0)
{
if (arr[j]>0)
countone++;
else
countzero++;
current_size++;
}
}
// update maximum size
if (countzero == countone)
result = Math.max(current_size,
result);
}
return result;
}
// Driver Code
public static void main (String[] args)
{
int arr[] = { 1, 0, 0, 1,
0, 0, 0, 1 };
int n = arr.length;
System.out.println( "largest Subsequences having "+
"equal number of 0 & 1 is "+
generateSubsequences(arr, n));
}
}
// This code is contributed by anuj_67.
# Python code to find the
# length of longest subsequence
# having equal no of 1 and 0
def generateSubsequences(a, n):
result = 0
# Number of subsequences
# is (2**n -1)
opsize = 2**n
# Run from counter
# 000..1 to 111..1
for counter in range(opsize):
# store count of zeros and one
countzero, countone = 0, 0
current_size = 0
for j in range(n):
# Check if jth bit in the
# counter is set. If set then
# print jth element from arr[]
if counter & (1 << j):
if arr[j] == True:
countone += 1
else:
countzero += 1
current_size += 1
# update maximum size
if countzero == countone:
result = max(current_size,
result)
return result
# Driver code
arr = [ 1, 0, 0, 1, 0, 0, 0, 1 ]
n = len(arr)
print("largest Subsequences having" +
" equal number of 0 & 1 is ",
generateSubsequences(arr, n))
# This code is contributed
# by "Abhishek Sharma 44"
// C# program for Longest subsequence
// having equal numbers of 0 and 1
using System;
class GFG {
static int generateSubsequences(int []arr,
int n)
{
// store the maximum length
// sub_sequence having equal
// number of zeros and ones
int result = 0;
// Number of subsequences
// is (2**n -1)
uint opsize = (uint) Math.Pow(2, n);
// Run from counter
// 000..1 to 111..1
for (int counter = 1; counter < opsize;
counter++)
{
// store count of zeros and one
int countzero = 0;
int countone = 0, current_size = 0;
for (int j = 0; j < n; j++)
{
// Check if jth bit in the
// counter is set. If set
// then print jth element
// from arr[]
if ((counter & (1 << j))>0)
{
if (arr[j]>0)
countone++;
else
countzero++;
current_size++;
}
}
// update maximum size
if (countzero == countone)
result = Math.Max(current_size,
result);
}
return result;
}
// Driver Code
public static void Main ()
{
int []arr = { 1, 0, 0, 1,
0, 0, 0, 1 };
int n = arr.Length;
Console.WriteLine("largest Subsequences having "+
"equal number of 0 & 1 is "+
generateSubsequences(arr, n));
}
}
// This code is contributed by anuj_67.
<?php
// PHP code to find the length
// of longest subsequence have
// equal no of 1 and 0
function generateSubsequences($arr,
$n)
{
// store the maximum length
// sub_sequence having equal
// number of zeros and ones
$result = 0;
// Number of subsequences
// is (2**n -1)
$opsize = pow(2, $n);
// Run from counter 000..1
// to 111..1
for ($counter = 1; $counter < $opsize;
$counter++)
{
// store count of zeros and one
$countzero = 0;
$countone = 0; $current_size = 0;
for ($j = 0; $j < $n; $j++)
{
// Check if jth bit in
// the counter is set
// If set then print jth
// element from arr[]
if ($counter & (1 << $j))
{
if ($arr[$j])
$countone++;
else
$countzero++;
$current_size++;
}
}
// update maximum size
if ($countzero == $countone)
$result = max($current_size,
$result);
}
return $result;
}
// Driver Code
$arr = array(1, 0, 0, 1, 0, 0, 0, 1);
$n = count($arr);
echo "largest Subsequences having " ,
"equal number of 0 & 1 is " ,
generateSubsequences($arr, $n);
// This code is contributed by anuj_67.
?>
<script>
// JavaScript program for Longest subsequence
// having equal numbers of 0 and 1
function generateSubsequences(arr, n)
{
// store the maximum length
// sub_sequence having equal
// number of zeros and ones
var result = 0;
// Number of subsequences is (2**n -1)
var opsize = Math.pow(2, n);
// Run from counter 000..1 to 111..1
for (var counter = 1; counter < opsize;
counter++)
{
// store count of zeros and one
var countzero = 0;
var countone = 0, current_size = 0;
for (var j = 0; j < n; j++)
{
// Check if jth bit in the
// counter is set. If set
// then print jth element
// from arr[]
if (counter & (1 << j))
{
if (arr[j])
countone++;
else
countzero++;
current_size++;
}
}
// update maximum size
if (countzero == countone)
result = Math.max(current_size,
result);
}
return result;
}
// Driver Code
var arr = [ 1, 0, 0, 1,
0, 0, 0, 1 ];
var n = arr.length;
document.write( "largest Subsequences having "+
"equal number of 0 & 1 is "
+ generateSubsequences(arr, n));
</script>
Output:
largest Subsequences having equal number of 0 & 1 is 6
Time Complexity: (n*2^n)
Auxiliary Space: O(1)
Efficient solution is to count zeros & ones in a binary array and last return minimum between count of zeros & ones by multiplying it with 2.
arr[] = { 1, 0, 0, 1, 0, 0, 0, 1 }
output : 6
here largest sub_sequencer :
{ 1 0 0 1 0 1} or {1 0 1 0 0 1 }
If we observe carefully then we notice that
we just have to find minimum counts between
zeros & ones and multiplying it with 2
( because we always get even length sub_sequence)
Below is the implementation of the above idea:
C++
// Efficient CPP program to find
// length of the longest subsequence
// with equal number of 0s and 1s.
#include <bits/stdc++.h>
using namespace std;
int largestSubsequences(int arr[], int n)
{
// store count of zeros and one
int countzero = 0, countone = 0;
// traverse binary array and count
// zeros and ones
for (int i = 0; i < n; i++)
if (arr[i])
countone++;
else
countzero++;
return min(countone, countzero) * 2;
}
// Driver program
int main()
{
int arr[] = { 1, 0, 0, 1, 0, 0, 0, 1 };
int n = sizeof(arr) / sizeof(arr[0]);
cout << "largest Subsequences having "
<< "equal number of 0 & 1 is "
<< largestSubsequences(arr, n);
return 0;
}
// Efficient Java program to find
// length of the longest subsequence
// with equal number of 0s and 1s.
import java.io.*;
import java.math.*;
class GFG
{
static int largestSubsequences(int arr[],
int n)
{
// store count of zeros and one
int countzero = 0, countone = 0;
// traverse binary array and count
// zeros and ones
for (int i = 0; i < n; i++)
if (arr[i] == 1)
countone++;
else
countzero++;
return Math.min(countone, countzero) * 2;
}
// Driver Code
public static void main(String args[])
{
int arr[] = { 1, 0, 0, 1, 0, 0, 0, 1 };
int n = arr.length;
System.out.println("largest Subsequences having " +
"equal number of 0 & 1 is " +
largestSubsequences(arr, n));
}
}
// This code is contributed by Nikita Tiwari
# Efficient Python code to find
# length of the longest subsequence
# with equal number of 0s and 1s.
def largestSubsequence(arr,n):
# store count of zeros and one
countzero = 0
countone = 0
# traverse binary array and count
# zeros and ones
for i in range(n):
if arr[i]:
countone += 1
else:
countzero += 1
return min(countone, countzero) * 2
# Driver Code
arr = [ 1, 0, 0, 1, 0, 0, 0, 1 ]
n = len(arr)
print("largest Subsequences having" +
" equal number of 0 & 1 is ",
largestSubsequence(arr, n))
# This code is contributed
# by "Abhishek Sharma 44"
// Efficient C# program to find
// length of the longest subsequence
// with equal number of 0s and 1s.
using System;
class GFG
{
static int largestSubsequences(int[] arr,
int n)
{
// store count of zeros and one
int countzero = 0, countone = 0;
// traverse binary array and
// count zeros and ones
for (int i = 0; i < n; i++)
if (arr[i] != 0)
countone++;
else
countzero++;
return Math.Min(countone,
countzero) * 2;
}
// Driver Code
static void Main()
{
int[] arr = { 1, 0, 0, 1, 0, 0, 0, 1 };
int n = 8 ;
Console.Write("largest Subsequences having" +
" equal number of 0 & 1 is " +
largestSubsequences(arr, n));
}
}
// This code is contributed by Anuj_67
<?php
// Efficient PHP program to find
// length of the longest subsequence
// with equal number of 0s and 1s.
function largestSubsequences( $arr, $n)
{
// store count of zeros and one
$countzero = 0; $countone = 0;
// traverse binary array and
// count zeros and ones
for ( $i = 0; $i < $n; $i++)
if ($arr[$i])
$countone++;
else
$countzero++;
return min($countone, $countzero) * 2;
}
// Driver Code
$arr = array(1, 0, 0, 1,
0, 0, 0, 1);
$n = count($arr);
echo "largest Subsequences having " ,
"equal number of 0 & 1 is " ,
largestSubsequences($arr, $n);
// This code is contributed by Anuj_67.
?>
<script>
// Efficient Javascript program to find
// length of the longest subsequence
// with equal number of 0s and 1s.
function largestSubsequences(arr, n)
{
// store count of zeros and one
var countzero = 0, countone = 0;
// traverse binary array and count
// zeros and ones
for (var i = 0; i < n; i++)
if (arr[i])
countone++;
else
countzero++;
return Math.min(countone, countzero) * 2;
}
// Driver program
var arr = [1, 0, 0, 1, 0, 0, 0, 1 ];
var n = arr.length;
document.write( "largest Subsequences having "
+ "equal number of 0 & 1 is "
+ largestSubsequences(arr, n));
</script>
Outputlargest Subsequences having equal number of 0 & 1 is 6
Time Complexity : O(n)
Auxiliary Space: O(1)
Similar Reads
Longest subsequence of even numbers in an Array Given an array arr[] containing N integers, the task is to print the length of the longest subsequence of even numbers in the array. Examples: Input: arr[] = {3, 4, 11, 2, 9, 21} Output: 2 Explanation: The longest subsequence containing even numbers is {4, 2}. Hence, the answer is 2. Input: arr[] =
5 min read
Longest Subarray With Equal Number of 0s and 1s Given an array arr[] containing only 0s and 1s, find the longest subarray which contains equal no of 0s and 1s.Examples: Input: arr[] = [1, 0, 1, 1, 1, 0, 0]Output: 6Explanation: arr[1 ... 6] is the longest subarray with three 0s and three 1s.Input: arr[] = [0, 0, 1, 1, 0]Output: 4Explanation: arr[0
10 min read
Length of longest subsequence of Fibonacci Numbers in an Array Given an array arr containing non-negative integers, the task is to print the length of the longest subsequence of Fibonacci numbers in this array.Examples: Input: arr[] = { 3, 4, 11, 2, 9, 21 } Output: 3 Here, the subsequence is {3, 2, 21} and hence the answer is 3.Input: arr[] = { 6, 4, 10, 13, 9,
5 min read
Generate Binary String with equal number of 01 and 10 Subsequence Given an integer N (N > 2), the task is to generate a binary string of size N that consists of equal numbers of "10" & "01" subsequences and also the string should contain at least one '0' and one '1' Note: If multiple such strings exist, print any. Examples: Input: 4Output: 0110Explanation :
7 min read
Longest subsequence of a number having same left and right rotation Given a numeric string S, the task is to find the maximum length of a subsequence having its left rotation equal to its right rotation. Examples: Input: S = "100210601" Output: 4 Explanation: The subsequence "0000" satisfies the necessary condition. The subsequence "1010" generates the string "0101"
8 min read