# Generate all binary strings with 1 and 0 of size N

Here given code implementation process.

``````// Include header file
#include <iostream>
using namespace std;
/*
C++ Program for
Generate all binary strings with 1 and 0 of size N
*/
class Combination
{
public: void display(string output, int n, int one, int zero)
{
if (zero == n && one == n)
{
// Display calculated result
cout << output << endl;
return;
}
if (zero > n || one > n)
{
return;
}
if (zero <= n)
{
// Find the next combination by recursively
this->display(output  +  "0", n, one, zero + 1);
this->display(output  +  "1", n, one + 1, zero);
}
}
void binaryCombination(int n)
{
if (n <= 0)
{
return;
}
cout << "\nGiven n : " << n << endl;
// Print permutation
this->display("", n, 0, 0);
}
};
int main()
{
// Test A
// n = 2
// Test B
// n = 3
return 0;
}``````

#### Output

``````Given n : 2
0011
0101
0110
1001
1010
1100

Given n : 3
000111
001011
001101
001110
010011
010101
010110
011001
011010
011100
100011
100101
100110
101001
101010
101100
110001
110010
110100
111000``````
``````/*
Java Program for
Generate all binary strings with 1 and 0 of size N
*/
public class Combination
{
public void display(String output, int n, int one, int zero)
{
if (zero == n && one == n)
{
// Display calculated result
System.out.println(output);
return;
}
if (zero > n || one > n)
{
return;
}
if (zero <= n)
{
// Find the next combination by recursively
display(output + "0", n, one, zero + 1);
display(output + "1", n, one + 1, zero);
}
}
public void binaryCombination(int n)
{
if (n <= 0)
{
return;
}
System.out.println("\nGiven n : " + n);
// Print permutation
display("", n, 0, 0);
}
public static void main(String[] args)
{
// Test A
// n = 2
// Test B
// n = 3
}
}``````

#### Output

``````Given n : 2
0011
0101
0110
1001
1010
1100

Given n : 3
000111
001011
001101
001110
010011
010101
010110
011001
011010
011100
100011
100101
100110
101001
101010
101100
110001
110010
110100
111000``````
``````// Include namespace system
using System;
/*
Csharp Program for
Generate all binary strings with 1 and 0 of size N
*/
public class Combination
{
public void display(String output, int n, int one, int zero)
{
if (zero == n && one == n)
{
// Display calculated result
Console.WriteLine(output);
return;
}
if (zero > n || one > n)
{
return;
}
if (zero <= n)
{
// Find the next combination by recursively
this.display(output + "0", n, one, zero + 1);
this.display(output + "1", n, one + 1, zero);
}
}
public void binaryCombination(int n)
{
if (n <= 0)
{
return;
}
Console.WriteLine("\nGiven n : " + n);
// Print permutation
this.display("", n, 0, 0);
}
public static void Main(String[] args)
{
// Test A
// n = 2
// Test B
// n = 3
}
}``````

#### Output

``````Given n : 2
0011
0101
0110
1001
1010
1100

Given n : 3
000111
001011
001101
001110
010011
010101
010110
011001
011010
011100
100011
100101
100110
101001
101010
101100
110001
110010
110100
111000``````
``````<?php
/*
Php Program for
Generate all binary strings with 1 and 0 of size N
*/
class Combination
{
public	function display(\$output, \$n, \$one, \$zero)
{
if (\$zero == \$n && \$one == \$n)
{
// Display calculated result
echo(\$output."\n");
return;
}
if (\$zero > \$n || \$one > \$n)
{
return;
}
if (\$zero <= \$n)
{
// Find the next combination by recursively
\$this->display(\$output."0",
\$n, \$one, \$zero + 1);
\$this->display(\$output."1",
\$n, \$one + 1, \$zero);
}
}
public	function binaryCombination(\$n)
{
if (\$n <= 0)
{
return;
}
echo("\nGiven n : ".\$n."\n");
// Print permutation
\$this->display("", \$n, 0, 0);
}
}

function main()
{
// Test A
// n = 2
// Test B
// n = 3
}
main();``````

#### Output

``````Given n : 2
0011
0101
0110
1001
1010
1100

Given n : 3
000111
001011
001101
001110
010011
010101
010110
011001
011010
011100
100011
100101
100110
101001
101010
101100
110001
110010
110100
111000``````
``````/*
Node JS Program for
Generate all binary strings with 1 and 0 of size N
*/
class Combination
{
display(output, n, one, zero)
{
if (zero == n && one == n)
{
// Display calculated result
console.log(output);
return;
}
if (zero > n || one > n)
{
return;
}
if (zero <= n)
{
// Find the next combination by recursively
this.display(output + "0",
n, one, zero + 1);
this.display(output + "1",
n, one + 1, zero);
}
}
binaryCombination(n)
{
if (n <= 0)
{
return;
}
console.log("\nGiven n : " + n);
// Print permutation
this.display("", n, 0, 0);
}
}

function main()
{
// Test A
// n = 2
// Test B
// n = 3
}
main();``````

#### Output

``````Given n : 2
0011
0101
0110
1001
1010
1100

Given n : 3
000111
001011
001101
001110
010011
010101
010110
011001
011010
011100
100011
100101
100110
101001
101010
101100
110001
110010
110100
111000``````
``````#    Python 3 Program for
#    Generate all binary strings with 1 and 0 of size N
class Combination :
def display(self, output, n, one, zero) :
if (zero == n and one == n) :
#  Display calculated result
print(output)
return

if (zero > n or one > n) :
return

if (zero <= n) :
#  Find the next combination by recursively
self.display(output + "0", n, one, zero + 1)
self.display(output + "1", n, one + 1, zero)

def binaryCombination(self, n) :
if (n <= 0) :
return

print("\nGiven n : ", n)
#  Print permutation
self.display("", n, 0, 0)

def main() :
#  Test A
#  n = 2
#  Test B
#  n = 3

if __name__ == "__main__": main()``````

#### Output

``````Given n :  2
0011
0101
0110
1001
1010
1100

Given n :  3
000111
001011
001101
001110
010011
010101
010110
011001
011010
011100
100011
100101
100110
101001
101010
101100
110001
110010
110100
111000``````
``````#    Ruby Program for
#    Generate all binary strings with 1 and 0 of size N
class Combination
def display(output, n, one, zero)
if (zero == n && one == n)
#  Display calculated result
print(output, "\n")
return
end

if (zero > n || one > n)
return
end

if (zero <= n)
#  Find the next combination by recursively
self.display(output + "0", n, one, zero + 1)
self.display(output + "1", n, one + 1, zero)
end

end

def binaryCombination(n)
if (n <= 0)
return
end

print("\nGiven n : ", n, "\n")
#  Print permutation
self.display("", n, 0, 0)
end

end

def main()
#  Test A
#  n = 2
#  Test B
#  n = 3
end

main()``````

#### Output

``````Given n : 2
0011
0101
0110
1001
1010
1100

Given n : 3
000111
001011
001101
001110
010011
010101
010110
011001
011010
011100
100011
100101
100110
101001
101010
101100
110001
110010
110100
111000
``````
``````/*
Scala Program for
Generate all binary strings with 1 and 0 of size N
*/
class Combination()
{
def display(output: String, n: Int,
one: Int, zero: Int): Unit = {
if (zero == n && one == n)
{
// Display calculated result
println(output);
return;
}
if (zero > n || one > n)
{
return;
}
if (zero <= n)
{
// Find the next combination by recursively
display(output + "0", n, one, zero + 1);
display(output + "1", n, one + 1, zero);
}
}
def binaryCombination(n: Int): Unit = {
if (n <= 0)
{
return;
}
println("\nGiven n : " + n);
// Print permutation
display("", n, 0, 0);
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: Combination = new Combination();
// Test A
// n = 2
// Test B
// n = 3
}
}``````

#### Output

``````Given n : 2
0011
0101
0110
1001
1010
1100

Given n : 3
000111
001011
001101
001110
010011
010101
010110
011001
011010
011100
100011
100101
100110
101001
101010
101100
110001
110010
110100
111000``````
``````/*
Swift 4 Program for
Generate all binary strings with 1 and 0 of size N
*/
class Combination
{
func display(_ output: String, _ n: Int,
_ one: Int, _ zero: Int)
{
if (zero == n && one == n)
{
// Display calculated result
print(output);
return;
}
if (zero > n || one > n)
{
return;
}
if (zero <= n)
{
// Find the next combination by recursively
self.display(output + "0",
n, one, zero + 1);
self.display(output + "1",
n, one + 1, zero);
}
}
func binaryCombination(_ n: Int)
{
if (n <= 0)
{
return;
}
print("\nGiven n : ", n);
// Print permutation
self.display("", n, 0, 0);
}
}
func main()
{
// Test A
// n = 2
// Test B
// n = 3
}
main();``````

#### Output

``````Given n :  2
0011
0101
0110
1001
1010
1100

Given n :  3
000111
001011
001101
001110
010011
010101
010110
011001
011010
011100
100011
100101
100110
101001
101010
101100
110001
110010
110100
111000``````
``````/*
Kotlin Program for
Generate all binary strings with 1 and 0 of size N
*/
class Combination
{
fun display(output: String, n: Int, one: Int, zero: Int): Unit
{
if (zero == n && one == n)
{
// Display calculated result
println(output);
return;
}
if (zero > n || one > n)
{
return;
}
if (zero <= n)
{
// Find the next combination by recursively
this.display(output + "0", n, one, zero + 1);
this.display(output + "1", n, one + 1, zero);
}
}
fun binaryCombination(n: Int): Unit
{
if (n <= 0)
{
return;
}
println("\nGiven n : " + n);
// Print permutation
this.display("", n, 0, 0);
}
}
fun main(args: Array < String > ): Unit
{
// Test A
// n = 2
// Test B
// n = 3
}``````

#### Output

``````Given n : 2
0011
0101
0110
1001
1010
1100

Given n : 3
000111
001011
001101
001110
010011
010101
010110
011001
011010
011100
100011
100101
100110
101001
101010
101100
110001
110010
110100
111000``````
``````package main
import "fmt"
/*
Go Program for
Generate all binary strings with 1 and 0 of size N
*/
type Combination struct {}
func getCombination() * Combination {
var me *Combination = &Combination {}
return me
}
func(this Combination) display(output string,
n int,
one int,
zero int) {
if zero == n && one == n {
// Display calculated result
fmt.Println(output)
return
}
if zero > n || one > n {
return
}
if zero <= n {
// Find the next combination by recursively
this.display(output + "0", n, one, zero + 1)
this.display(output + "1", n, one + 1, zero)
}
}
func(this Combination) binaryCombination(n int) {
if n <= 0 {
return
}
fmt.Println("\nGiven n : ", n)
// Print permutation
this.display("", n, 0, 0)
}
func main() {
var task * Combination = getCombination()
// Test A
// n = 2
// Test B
// n = 3
}``````

#### Output

``````Given n : 2
0011
0101
0110
1001
1010
1100

Given n : 3
000111
001011
001101
001110
010011
010101
010110
011001
011010
011100
100011
100101
100110
101001
101010
101100
110001
110010
110100
111000``````

## Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.