# Length of the longest substring with equal 1s and 0s

• Difficulty Level : Medium
• Last Updated : 20 Jul, 2022

Given a binary string. We need to find the length of the longest balanced substring. A substring is balanced if it contains an equal number of 0 and 1.

Examples:

```Input : input = 110101010
Output : Length of longest balanced
sub string = 8

Input : input = 0000
Output : Length of longest balanced
sub string = 0```

A simple solution is to use two nested loops to generate every substring. And a third loop to count number of 0s and 1s in current substring. Time complexity of this would be O(n3)

Below is the implementation of the above approach:

## C++

 `// C++ program to find the length of``// the longest balanced substring``#include``using` `namespace` `std;` `// Function to check if a string contains``// equal number of one and zeros or not``bool` `isValid(string p)``{``    ``int` `n = p.length();``    ``int` `c1 = 0, c0 = 0;``    ` `    ``for``(``int` `i =0; i < n; i++)``    ``{``        ``if``(p[i] == ``'0'``)``            ``c0++;``        ``if``(p[i] == ``'1'``)``            ``c1++;``    ``}``    ` `    ``return` `(c0 == c1) ? ``true` `: ``false``;``}` `// Function to find the length of``// the longest balanced substring``int` `longestSub(string s)``{``    ``int` `max_len = 0;``    ``int` `n = s.length();``    ` `    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ``for``(``int` `j = i; j < n; j++)``        ``{``            ``if``(isValid(s.substr(i, j - i + 1)) && max_len < j - i + 1)``                ``max_len = j - i + 1;``        ``}``        ` `    ``}``    ``return` `max_len;``    ` `}` `// Driver code``int` `main()``{``    ``string s = ``"101001000"``;``    ` `    ``// Function call``    ``cout << longestSub(s);``    ` `    ``return` `0;``}`

## Java

 `// Java program to find the length of ``// the longest balanced substring``import` `java.io.*;``import` `java.util.*;``class` `GFG``{` `  ``// Function to check if a string contains``  ``// equal number of one and zeros or not``  ``public` `static` `boolean` `isValid(String p)``  ``{``    ``int` `n = p.length();``    ``int` `c1 = ``0``, c0 = ``0``;``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{``      ``if``(p.charAt(i) == ``'0'``)``      ``{``        ``c0++;``      ``}``      ``if``(p.charAt(i) == ``'1'``)``      ``{``        ``c1++;``      ``}``    ``}``    ``if``(c0 == c1)``    ``{``      ``return` `true``;``    ``}``    ``else``    ``{``      ``return` `false``;``    ``}``  ``}``  ``// Function to find the length of ``  ``// the longest balanced substring``  ``public` `static` `int` `longestSub(String s)``  ``{``    ``int` `max_len = ``0``;``    ``int` `n = s.length();``    ``for``(``int` `i = ``0``; i < n; i++)``    ``{``      ``for``(``int` `j = i; j < n; j++)``      ``{``        ``if``(isValid(s.substring(i, j + ``1``)) && max_len < j - i + ``1``)``        ``{``          ``max_len = j - i + ``1``;``        ``}``      ``}``    ``}``    ``return` `max_len;``  ``}` `  ``// Driver code``  ``public` `static` `void` `main (String[] args)``  ``{``    ``String s = ``"101001000"``;` `    ``// Function call``    ``System.out.println(longestSub(s));``  ``}``}` `//  This code is contributed by avanitrachhadiya2155`

## Python3

 `# Python3 program to find the length of``# the longest balanced substring` `# Function to check if a contains``# equal number of one and zeros or not``def` `isValid(p):` `    ``n ``=` `len``(p)``    ``c1 ``=` `0``    ``c0 ``=` `0` `    ``for` `i ``in` `range``(n):``        ``if` `(p[i] ``=``=` `'0'``):``            ``c0 ``+``=` `1``        ``if` `(p[i] ``=``=` `'1'``):``            ``c1 ``+``=` `1` `    ``if` `(c0 ``=``=` `c1):``        ``return` `True``    ``else``:``        ``return` `False` `# Function to find the length of``# the longest balanced substring``def` `longestSub(s):``    ` `    ``max_len ``=` `0``    ``n ``=` `len``(s)` `    ``for` `i ``in` `range``(n):``        ``for` `j ``in` `range``(i, n):``            ``if` `(isValid(s[i : j ``-` `i ``+` `1``]) ``and``                    ``max_len < j ``-` `i ``+` `1``):``                ``max_len ``=` `j ``-` `i ``+` `1` `    ``return` `max_len` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``s ``=` `"101001000"` `    ``# Function call``    ``print``(longestSub(s))` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program to find the length of ``// the longest balanced substring``using` `System;` `class` `GFG{``    ` `// Function to check if a string contains``// equal number of one and zeros or not``static` `bool` `isValid(``string` `p)``{``    ``int` `n = p.Length;``    ``int` `c1 = 0, c0 = 0;``    ` `    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ``if` `(p[i] == ``'0'``)``        ``{``            ``c0++;``        ``}``        ``if` `(p[i] == ``'1'``)``        ``{``            ``c1++;``        ``}``    ``}``    ``if` `(c0 == c1)``    ``{``        ``return` `true``;``    ``}``    ``else``    ``{``        ``return` `false``;``    ``}``}` `// Function to find the length of ``// the longest balanced substring``public` `static` `int` `longestSub(``string` `s)``{``    ``int` `max_len = 0;``    ``int` `n = s.Length;``    ` `    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ``for``(``int` `j = i; j < n; j++)``        ``{``            ``if` `(isValid(s.Substring(i, j - i + 1)) &&``                             ``max_len < j - i + 1)``            ``{``                ``max_len = j - i + 1;``            ``}``        ``}``    ``}``    ``return` `max_len;``}` `// Driver code``static` `public` `void` `Main()``{``    ``string` `s = ``"101001000"``;``    ` `    ``// Function call``    ``Console.WriteLine(longestSub(s));``}``}` `// This code is contributed by rag2127`

## Javascript

 ``

Output

`6`

An efficient solution is to use hashing.

1. Traverse string and keep track of counts of 1s and 0s as count_1 and count_0 respectively.
2. See if current difference between two counts has appeared before (We use hashing to store all differences and first index where a difference appears). If yes, then substring from previous appearance and current index has same number of 0s and 1s.

Below is the implementation of above approach.

## C++

 `// C++ for finding length of longest balanced``// substring``#include``using` `namespace` `std;` `// Returns length of the longest substring``// with equal number of zeros and ones.``int` `stringLen(string str)``{``    ``// Create a map to store differences``    ``// between counts of 1s and 0s.``    ``map<``int``, ``int``> m;``    ` `    ``// Initially difference is 0.``    ``m[0] = -1;  ``    ` `    ``int` `count_0 = 0, count_1 = 0;``    ``int` `res = 0;``    ``for` `(``int` `i=0; i

## Java

 `// Java Code for finding the length of``// the longest balanced substring` `import` `java.io.*;``import` `java.util.*;` `public` `class` `MAX_LEN_0_1 {``    ``public` `static` `void` `main(String args[])``throws` `IOException``    ``{``        ``String str = ``"101001000"``;``            ` `    ``// Create a map to store differences``    ``//between counts of 1s and 0s.``    ``HashMap map = ``new` `HashMap();``    ` `    ``// Initially difference is 0;``            ``map. put(``0``, -``1``);``            ``int` `res =``0``;``            ``int` `count_0 = ``0``, count_1 = ``0``;``            ``for``(``int` `i=``0``; i

## Python3

 `# Python3 code for finding length of``# longest balanced substring` `# Returns length of the longest substring``# with equal number of zeros and ones.``def` `stringLen( ``str` `):` `    ``# Create a python dictionary to store``    ``# differences between counts of 1s and 0s.``    ``m ``=` `dict``()``    ` `    ``# Initially difference is 0.``    ``m[``0``] ``=` `-``1``    ` `    ``count_0 ``=` `0``    ``count_1 ``=` `0``    ``res ``=` `0``    ``for` `i ``in` `range``(``len``(``str``)):``        ` `        ``# Keeping track of counts of``        ``# 0s and 1s.``        ``if` `str``[i] ``=``=` `'0'``:``            ``count_0 ``+``=` `1``        ``else``:``            ``count_1 ``+``=` `1``            ` `        ``# If difference between current``        ``# counts already exists, then``        ``# substring between previous and``        ``# current index has same no. of``        ``# 0s and 1s. Update result if``        ``# this substring is more than``        ``# current result.``        ``if` `m.get(count_1 ``-` `count_0)!``=``None``:``            ``res ``=` `max``(res, i ``-` `m[count_1 ``-` `count_0])``        ` `        ``# If current difference is``        ``# seen first time.``        ``else``:``            ``m[count_1 ``-` `count_0] ``=` `i``    ``return` `res` `# driver code``str` `=` `"101001000"``print``(``"Length of longest balanced"``     ``" sub string = "``,stringLen(``str``))` `# This code is contributed by "Sharad_Bhardwaj"`

## C#

 `// C# Code for finding the length of``// the longest balanced substring``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{``public` `static` `void` `Main(``string``[] args)``{``    ``string` `str = ``"101001000"``;` `    ``// Create a map to store differences``    ``//between counts of 1s and 0s.``    ``Dictionary<``int``,``               ``int``> map = ``new` `Dictionary<``int``,``                                         ``int``>();``    ` `    ``// Initially difference is 0;``    ``map[0] = -1;``    ``int` `res = 0;``    ``int` `count_0 = 0, count_1 = 0;``    ``for` `(``int` `i = 0; i < str.Length;i++)``    ``{``        ``// Keep track of count of 0s and 1s``        ``if` `(str[i] == ``'0'``)``        ``{``            ``count_0++;``        ``}``        ``else``        ``{``            ``count_1++;``        ``}` `        ``// If difference between current counts``        ``// already exists, then substring between``        ``// previous and current index has same``        ``// no. of 0s and 1s. Update result if this``        ``// substring is more than current result.``        ``if` `(map.ContainsKey(count_1 - count_0))``        ``{``            ``res = Math.Max(res, (i - map[count_1 -``                                         ``count_0]));``        ``}` `        ``// If the current difference is``        ``// seen first time.``        ``else``        ``{``            ``map[count_1 - count_0] = i;``        ``}` `    ``}` `    ``Console.WriteLine(``"Length of longest balanced"` `+``                            ``" sub string = "` `+ res);``}``}` `// This code is contributed by Shrikant13`

## Javascript

 ``

Output

`Length of longest balanced sub string = 6`

Time Complexity: O(n)

Extended Problem: Largest subarray with equal number of 0s and 1s

This article is contributed by Shivam Pradhan (anuj_charm) and ASIPU PAWAN KUMAR. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up