# Longest subsequence having equal numbers of 0 and 1

Given a binary array, the task is 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
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 ` `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); ` `    ``cout << ``"largest Subsequences having "` `            ``"equal number of 0 & 1 is "` `         ``<< generateSubsequences(arr, n); ` `    ``return` `0; ` `} `

## Java

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

## Python3

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

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

 ` `

Output :

```largest Subsequences having equal number of 0 & 1 is 6
```

Time Complexity: (n*2^n)

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 larges 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 above idea

## C++

 `// Efficient CPP program to find  ` `// length of the longest subsequence  ` `// with equal number of 0s and 1s. ` `#include ` `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); ` `    ``cout << ``"largest Subsequences having "` `         ``<< ``"equal number of 0 & 1 is "` `         ``<< largestSubsequences(arr, n); ` `    ``return` `0; ` `} `

## Java

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

## Python3

 `# Efficient Pyhton 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" `

## C#

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

 ` `

Output :

```largest Subsequences having equal number of 0 & 1 is 6
```

Time Complexity : O(n)

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes arrow_drop_up 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.

Improved By : vt_m

Article Tags :
Practice Tags :

1

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.