Related Articles

# Longest subarray having count of 1s one more than count of 0s

• Difficulty Level : Hard
• Last Updated : 20 May, 2021

Given an array of size n containing 0’s and 1’s only. The problem is to find the length of the longest subarray having count of 1’s one more than count of 0’s.
Examples:

```Input : arr = {0, 1, 1, 0, 0, 1}
Output : 5
From index 1 to 5.

Input : arr[] = {1, 0, 0, 1, 0}
Output : 1```

Approach: Following are the steps:

1. Consider all the 0’s in the array as ‘-1’.
2. Initialize sum = 0 and maxLen = 0.
3. Create a hash table having (sum, index) tuples.
4. For i = 0 to n-1, perform the following steps:
1. If arr[i] is ‘0’ accumulate ‘-1’ to sum else accumulate ‘1’ to sum.
2. If sum == 1, update maxLen = i+1.
3. Else check whether sum is present in the hash table or not. If not present, then add it to the hash table as (sum, i) pair.
4. Check if (sum-1) is present in the hash table or not. if present, then obtain index of (sum-1) from the hash table as index. Now check if maxLen is less than (i-index), then update maxLen = (i-index).
5. Return maxLen.

## C++

 `// C++ implementation to find the length of``// longest subarray having count of 1's one``// more than count of 0's``#include ``using` `namespace` `std;` `// function to find the length of longest``// subarray having count of 1's one more``// than count of 0's``int` `lenOfLongSubarr(``int` `arr[], ``int` `n)``{``    ``// unordered_map 'um' implemented as``    ``// hash table``    ``unordered_map<``int``, ``int``> um;``    ``int` `sum = 0, maxLen = 0;` `    ``// traverse the given array``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// consider '0' as '-1'``        ``sum += arr[i] == 0 ? -1 : 1;` `        ``// when subarray starts form index '0'``        ``if` `(sum == 1)``            ``maxLen = i + 1;` `        ``// make an entry for 'sum' if it is``        ``// not present in 'um'``        ``else` `if` `(um.find(sum) == um.end())``            ``um[sum] = i;` `        ``// check if 'sum-1' is present in 'um'``        ``// or not``        ``if` `(um.find(sum - 1) != um.end()) {` `            ``// update maxLength``            ``if` `(maxLen < (i - um[sum - 1]))``                ``maxLen = i - um[sum - 1];``        ``}``    ``}` `    ``// required maximum length``    ``return` `maxLen;``}` `// Driver program to test above``int` `main()``{``    ``int` `arr[] = { 0, 1, 1, 0, 0, 1 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``cout << ``"Length = "``         ``<< lenOfLongSubarr(arr, n);``    ``return` `0;``}`

## Java

 `// Java implementation to find the length of``// longest subarray having count of 1's one``// more than count of 0's``import` `java.util.*;` `class` `GFG``{` `// function to find the length of longest``// subarray having count of 1's one more``// than count of 0's``static` `int` `lenOfLongSubarr(``int` `arr[], ``int` `n)``{``    ``// unordered_map 'um' implemented as``    ``// hash table``    ``HashMap um = ``new` `HashMap();``    ``int` `sum = ``0``, maxLen = ``0``;` `    ``// traverse the given array``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{` `        ``// consider '0' as '-1'``        ``sum += arr[i] == ``0` `? -``1` `: ``1``;` `        ``// when subarray starts form index '0'``        ``if` `(sum == ``1``)``            ``maxLen = i + ``1``;` `        ``// make an entry for 'sum' if it is``        ``// not present in 'um'``        ``else` `if` `(!um.containsKey(sum))``            ``um. put(sum, i);` `        ``// check if 'sum-1' is present in 'um'``        ``// or not``        ``if` `(um.containsKey(sum - ``1``))``        ``{` `            ``// update maxLength``            ``if` `(maxLen < (i - um.get(sum - ``1``)))``                ``maxLen = i - um.get(sum - ``1``);``        ``}``    ``}` `    ``// required maximum length``    ``return` `maxLen;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``0``, ``1``, ``1``, ``0``, ``0``, ``1` `};``    ``int` `n = arr.length;``    ``System.out.println(``"Length = "` `+``               ``lenOfLongSubarr(arr, n));``}``}` `// This code is contributed by Princi Singh`

## Python3

 `# Python 3 implementation to find the length of``# longest subarray having count of 1's one``# more than count of 0's` `# function to find the length of longest``# subarray having count of 1's one more``# than count of 0's``def` `lenOfLongSubarr(arr, n):``    ` `    ``# unordered_map 'um' implemented as``    ``# hash table``    ``um ``=` `{i:``0` `for` `i ``in` `range``(``10``)}``    ``sum` `=` `0``    ``maxLen ``=` `0` `    ``# traverse the given array``    ``for` `i ``in` `range``(n):``        ` `        ``# consider '0' as '-1'``        ``if` `arr[i] ``=``=` `0``:``            ``sum` `+``=` `-``1``        ``else``:``            ``sum` `+``=` `1` `        ``# when subarray starts form index '0'``        ``if` `(``sum` `=``=` `1``):``            ``maxLen ``=` `i ``+` `1` `        ``# make an entry for 'sum' if it is``        ``# not present in 'um'``        ``elif` `(``sum` `not` `in` `um):``            ``um[``sum``] ``=` `i` `        ``# check if 'sum-1' is present in 'um'``        ``# or not``        ``if` `((``sum` `-` `1``) ``in` `um):``            ``# update maxLength``            ``if` `(maxLen < (i ``-` `um[``sum` `-` `1``])):``                ``maxLen ``=` `i ``-` `um[``sum` `-` `1``]` `    ``# required maximum length``    ``return` `maxLen` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``0``, ``1``, ``1``, ``0``, ``0``, ``1``]``    ``n ``=` `len``(arr)``    ``print``(``"Length ="``,lenOfLongSubarr(arr, n))``    ` `# This code is contributed by``# Surendra_Gangwar`

## C#

 `// C# implementation to find the length of``// longest subarray having count of 1's one``// more than count of 0's``using` `System;``using` `System.Collections.Generic;``    ` `class` `GFG``{` `// function to find the length of longest``// subarray having count of 1's one more``// than count of 0's``static` `int` `lenOfLongSubarr(``int` `[]arr, ``int` `n)``{``    ``// unordered_map 'um' implemented as``    ``// hash table``    ``Dictionary<``int``,``               ``int``> um = ``new` `Dictionary<``int``,``                                        ``int``>();``    ``int` `sum = 0, maxLen = 0;` `    ``// traverse the given array``    ``for` `(``int` `i = 0; i < n; i++)``    ``{` `        ``// consider '0' as '-1'``        ``sum += arr[i] == 0 ? -1 : 1;` `        ``// when subarray starts form index '0'``        ``if` `(sum == 1)``            ``maxLen = i + 1;` `        ``// make an entry for 'sum' if it is``        ``// not present in 'um'``        ``else` `if` `(!um.ContainsKey(sum))``            ``um.Add(sum, i);` `        ``// check if 'sum-1' is present in 'um'``        ``// or not``        ``if` `(um.ContainsKey(sum - 1))``        ``{` `            ``// update maxLength``            ``if` `(maxLen < (i - um[sum - 1]))``                ``maxLen = i - um[sum - 1];``        ``}``    ``}` `    ``// required maximum length``    ``return` `maxLen;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr = { 0, 1, 1, 0, 0, 1 };``    ``int` `n = arr.Length;``    ``Console.WriteLine(``"Length = "` `+``            ``lenOfLongSubarr(arr, n));``}``}` `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output:

`Length = 5`

Time Complexity: O(n)
Auxiliary Space: O(n)
This article is contributed by Ayush Jauhari. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.