# Generate all Binary Strings of length N with equal count of 0s and 1s

• Difficulty Level : Easy
• Last Updated : 29 Dec, 2021

Given an integer N, the task is to generate all the binary strings with equal 0s and 1s. If no strings are possible, print -1

Examples:

Input: N = 2
Output: “01”, “10”
Explanation: All possible binary strings of length 2 are: 01, 10, 11, 00. Out of these, only 2 have equal number of 0s and 1s

Input: 4
Output:  “0011”, “0101”, “0110”, “1100”, “1010”, “1001”

Approach: The task can be solved by using recursion. If N is odd, then the answer is -1, else, we can use recursion to generate all the binary strings with equal 0s and 1s. Follow the below steps to solve the problem:

• Variable ones keep track of the number of 1’s and variable zeros keeps a track of the number of 0’s in the string.
• Both ones and zeros should have frequency N/2.
• Base condition: The string s stores the output string. So, when the length of s reaches N we stop recursive calls and print the output string s.
• If the frequency of 1’s is less than N/2 then add 1 to the string and increment ones.
• If the frequency of 0’s is less than N/2 then add 0 to the string and increment zeros.

Below is the implementation of the above code:

## C++

 `// C++ code for the above approach``#include ``using` `namespace` `std;` `// Recursive function that prints``// all strings of N length with equal 1's and 0's``void` `binaryNum(``int` `n, string s, ``int` `ones,``               ``int` `zeros)``{``  ` `    ``// String s contains the output to be printed``    ``// ones stores the frequency of 1's``    ``// zeros stores the frequency of 0's``    ``// Base Condition: When the length of string s``    ``// becomes N``    ``if` `(s.length() == n)``    ``{``        ``cout << (s) << endl;``        ``return``;``    ``}` `    ``// If frequency of 1's is less than N/2 then``    ``// add 1 to the string and increment ones``    ``if` `(ones < n / 2)``        ``binaryNum(n, s + ``"1"``, ones + 1, zeros);` `    ``// If frequency of 0's is less than N/2 then``    ``// add 0 to the string and increment zeros``    ``if` `(zeros < n / 2)``        ``binaryNum(n, s + ``"0"``, ones, zeros + 1);``}` `// Driver Code``int` `main()``{` `    ``string s = ``""``;``    ``binaryNum(4, s, 0, 0);``    ``return` `0;``}` `// This code is contributed by Potta Lokesh`

## Java

 `// Java program for the above approach``import` `java.io.*;` `class` `GFG {` `    ``// Recursive function that prints``    ``// all strings of N length with equal 1's and 0's``    ``static` `void` `binaryNum(``int` `n, String s, ``int` `ones,``                          ``int` `zeros)``    ``{``        ``// String s contains the output to be printed``        ``// ones stores the frequency of 1's``        ``// zeros stores the frequency of 0's``        ``// Base Condition: When the length of string s``        ``// becomes N``        ``if` `(s.length() == n) {``            ``System.out.println(s);``            ``return``;``        ``}` `        ``// If frequency of 1's is less than N/2 then``        ``// add 1 to the string and increment ones``        ``if` `(ones < n / ``2``)``            ``binaryNum(n, s + ``"1"``, ones + ``1``, zeros);` `        ``// If frequency of 0's is less than N/2 then``        ``// add 0 to the string and increment zeros``        ``if` `(zeros < n / ``2``)``            ``binaryNum(n, s + ``"0"``, ones, zeros + ``1``);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``String s = ``""``;``        ``binaryNum(``4``, s, ``0``, ``0``);``    ``}``}`

## Python3

 `# python code for the above approach` `# Recursive function that prints``# all strings of N length with equal 1's and 0's``def` `binaryNum(n, s, ones, zeros):` `    ``# String s contains the output to be printed``    ``# ones stores the frequency of 1's``    ``# zeros stores the frequency of 0's``    ``# Base Condition: When the length of string s``    ``# becomes N``    ``if` `(``len``(s) ``=``=` `n):` `        ``print``(s)``        ``return` `    ``# If frequency of 1's is less than N/2 then``    ``# add 1 to the string and increment ones``    ``if` `(ones < n ``/` `2``):``        ``binaryNum(n, s ``+` `"1"``, ones ``+` `1``, zeros)` `    ``# If frequency of 0's is less than N/2 then``    ``# add 0 to the string and increment zeros``    ``if` `(zeros < n ``/` `2``):``        ``binaryNum(n, s ``+` `"0"``, ones, zeros ``+` `1``)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``s ``=` `""``    ``binaryNum(``4``, s, ``0``, ``0``)` `# This code is contributed by rakeshsahni`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG {` `    ``// Recursive function that prints``    ``// all strings of N length with equal 1's and 0's``    ``static` `void` `binaryNum(``int` `n, ``string` `s, ``int` `ones,``                          ``int` `zeros)``    ``{``        ``// String s contains the output to be printed``        ``// ones stores the frequency of 1's``        ``// zeros stores the frequency of 0's``        ``// Base Condition: When the length of string s``        ``// becomes N``        ``if` `(s.Length == n) {``            ``Console.WriteLine(s);``            ``return``;``        ``}` `        ``// If frequency of 1's is less than N/2 then``        ``// add 1 to the string and increment ones``        ``if` `(ones < n / 2)``            ``binaryNum(n, s + ``"1"``, ones + 1, zeros);` `        ``// If frequency of 0's is less than N/2 then``        ``// add 0 to the string and increment zeros``        ``if` `(zeros < n / 2)``            ``binaryNum(n, s + ``"0"``, ones, zeros + 1);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``string` `s = ``""``;``        ``binaryNum(4, s, 0, 0);``    ``}``}` `// This code is contributed by ukasp.`

## Javascript

 ``
Output
```1100
1010
1001
0110
0101
0011```

Time Complexity: O(2N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up