Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Generate all the binary strings of N bits

  • Difficulty Level : Easy
  • Last Updated : 12 Jul, 2021

Given a positive integer number N. The task is to generate all the binary strings of N bits. These binary strings should be in ascending order.
Examples: 
 

Input: 2
Output:
0 0
0 1
1 0
1 1

Input: 3
Output:
0 0 0
0 0 1
0 1 0
0 1 1
1 0 0
1 0 1
1 1 0
1 1 1

 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Approach: The idea is to try every permutation. For every position, there are 2 options, either ‘0’ or ‘1’. Backtracking is used in this approach to try every possibility/permutation. 
Below is the implementation of the above approach:
 



C++




// C++ implementation of the above approach:
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to print the output
void printTheArray(int arr[], int n)
{
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
}
 
// Function to generate all binary strings
void generateAllBinaryStrings(int n, int arr[], int i)
{
    if (i == n) {
        printTheArray(arr, n);
        return;
    }
 
    // First assign "0" at ith position
    // and try for all other permutations
    // for remaining positions
    arr[i] = 0;
    generateAllBinaryStrings(n, arr, i + 1);
 
    // And then assign "1" at ith position
    // and try for all other permutations
    // for remaining positions
    arr[i] = 1;
    generateAllBinaryStrings(n, arr, i + 1);
}
 
// Driver Code
int main()
{
    int n = 4;
 
    int arr[n];
 
    // Print all binary strings
    generateAllBinaryStrings(n, arr, 0);
 
    return 0;
}
Java



// Java implementation of the above approach:
import java.util.*;
 
class GFG
{
 
// Function to print the output
static void printTheArray(int arr[], int n)
{
    for (int i = 0; i < n; i++)
    {
        System.out.print(arr[i]+" ");
    }
    System.out.println();
}
 
// Function to generate all binary strings
static void generateAllBinaryStrings(int n,
                            int arr[], int i)
{
    if (i == n)
    {
        printTheArray(arr, n);
        return;
    }
 
    // First assign "0" at ith position
    // and try for all other permutations
    // for remaining positions
    arr[i] = 0;
    generateAllBinaryStrings(n, arr, i + 1);
 
    // And then assign "1" at ith position
    // and try for all other permutations
    // for remaining positions
    arr[i] = 1;
    generateAllBinaryStrings(n, arr, i + 1);
}
 
// Driver Code
public static void main(String args[])
{
    int n = 4;
 
    int[] arr = new int[n];
 
    // Print all binary strings
    generateAllBinaryStrings(n, arr, 0);
}
}
 
// This code is contributed by
// Surendra_Gangwar
Python3



# Python3 implementation of the
# above approach
 
# Function to print the output
def printTheArray(arr, n):
 
    for i in range(0, n):
        print(arr[i], end = " ")
     
    print()
 
# Function to generate all binary strings
def generateAllBinaryStrings(n, arr, i):
 
    if i == n:
        printTheArray(arr, n)
        return
     
    # First assign "0" at ith position
    # and try for all other permutations
    # for remaining positions
    arr[i] = 0
    generateAllBinaryStrings(n, arr, i + 1)
 
    # And then assign "1" at ith position
    # and try for all other permutations
    # for remaining positions
    arr[i] = 1
    generateAllBinaryStrings(n, arr, i + 1)
 
# Driver Code
if __name__ == "__main__":
 
    n = 4
    arr = [None] * n
 
    # Print all binary strings
    generateAllBinaryStrings(n, arr, 0)
 
# This code is contributed
# by Rituraj Jain
C#



// C# implementation of the above approach:
using System;
 
class GFG
{
 
// Function to print the output
static void printTheArray(int []arr, int n)
{
    for (int i = 0; i < n; i++)
    {
        Console.Write(arr[i]+" ");
    }
    Console.WriteLine();
}
 
// Function to generate all binary strings
static void generateAllBinaryStrings(int n,
                            int []arr, int i)
{
    if (i == n)
    {
        printTheArray(arr, n);
        return;
    }
 
    // First assign "0" at ith position
    // and try for all other permutations
    // for remaining positions
    arr[i] = 0;
    generateAllBinaryStrings(n, arr, i + 1);
 
    // And then assign "1" at ith position
    // and try for all other permutations
    // for remaining positions
    arr[i] = 1;
    generateAllBinaryStrings(n, arr, i + 1);
}
 
// Driver Code
public static void Main(String []args)
{
    int n = 4;
 
    int[] arr = new int[n];
 
    // Print all binary strings
    generateAllBinaryStrings(n, arr, 0);
}
}
 
// This code has been contributed by 29AjayKumar
PHP



<?php
// PHP implementation of the above approach
 
// Function to print the output
function printTheArray($arr, $n)
{
    for ($i = 0; $i < $n; $i++)
    {
        echo $arr[$i], " ";
    }
    echo "\n";
}
 
// Function to generate all binary strings
function generateAllBinaryStrings($n, $arr, $i)
{
    if ($i == $n)
    {
        printTheArray($arr, $n);
        return;
    }
 
    // First assign "0" at ith position
    // and try for all other permutations
    // for remaining positions
    $arr[$i] = 0;
    generateAllBinaryStrings($n, $arr, $i + 1);
 
    // And then assign "1" at ith position
    // and try for all other permutations
    // for remaining positions
    $arr[$i] = 1;
    generateAllBinaryStrings($n, $arr, $i + 1);
}
 
// Driver Code
$n = 4;
 
$arr = array_fill(0, $n, 0);
 
// Print all binary strings
generateAllBinaryStrings($n, $arr, 0);
 
// This code is contributed by Ryuga
?>
Javascript



<script>
    // Javascript implementation of the above approach:
     
    // Function to print the output
    function printTheArray(arr, n)
    {
        for (let i = 0; i < n; i++)
        {
            document.write(arr[i]+" ");
        }
        document.write("</br>");
    }
 
    // Function to generate all binary strings
    function generateAllBinaryStrings(n, arr, i)
    {
        if (i == n)
        {
            printTheArray(arr, n);
            return;
        }
 
        // First assign "0" at ith position
        // and try for all other permutations
        // for remaining positions
        arr[i] = 0;
        generateAllBinaryStrings(n, arr, i + 1);
 
        // And then assign "1" at ith position
        // and try for all other permutations
        // for remaining positions
        arr[i] = 1;
        generateAllBinaryStrings(n, arr, i + 1);
    }
     
    let n = 4;
   
    let arr = new Array(n);
    arr.fill(0);
   
    // Print all binary strings
    generateAllBinaryStrings(n, arr, 0);
 
// This code is contributed by divyeshrabadiya07.
</script>
Output: 
0 0 0 0 
0 0 0 1 
0 0 1 0 
0 0 1 1 
0 1 0 0 
0 1 0 1 
0 1 1 0 
0 1 1 1 
1 0 0 0 
1 0 0 1 
1 0 1 0 
1 0 1 1 
1 1 0 0 
1 1 0 1 
1 1 1 0 
1 1 1 1
 
Time complexity – O(2n)
Space complexity – O(n)
Related Article: Generate all the binary number from 0 to n
 



My Personal Notes
arrow_drop_up
Next

Generate all binary strings from given pattern
Recommended Articles
Page :
Minimize cost of swapping set bits with unset bits in a given Binary string
18, Aug 21
Generate all binary strings from given pattern
15, Jun 16
Generate all binary strings without consecutive 1's
16, Jan 17
Generate all binary strings of length n with sub-string "01" appearing exactly twice
02, Apr 19
Check if all bits can be made same by flipping two consecutive bits
09, Jan 20
Generate Binary Strings of length N using Branch and Bound
20, Nov 19
Count binary strings with k times appearing adjacent two set bits
20, Feb 17
Number of Binary Strings of length N with K adjacent Set Bits
11, Dec 18
Minimum number of flipping adjacent bits required to make given Binary Strings equal
12, Jul 21
Generate all binary permutations such that there are more or equal 1's than 0's before every point in all permutations
17, Aug 14
Generate all possible strings such that char at index i is either str1[i] or str2[i]
11, Jul 19
Generate all possible strings formed by replacing letters with given respective symbols
19, Jul 21
Find all even length binary sequences with same sum of first and second half bits
02, Aug 16
Minimum flips required to form given binary string where every flip changes all bits to its right as well
14, Jun 20
Generate string with Hamming Distance as half of the hamming distance between strings A and B
30, Mar 20
Generate an array representing GCD of nodes of each vertical level of a Binary Tree
13, May 21
Generate a random Binary String of length N
25, Mar 21
Maximum number of set bits count in a K-size substring of a Binary String
09, Jun 20
Maximize count of set bits in a root to leaf path in a binary tree
17, Jul 20
Different ways to Invert the Binary bits in Python
16, Aug 20
Maximize sum of assigned weights by flipping at most K bits in given Binary String
29, Oct 20
Minimize hamming distance in Binary String by setting only one K size substring bits
02, Jul 21
Lexicographically smallest binary string formed by flipping bits at indices not divisible K1 or K2 such that count of 1s is always greater than 0s from left
03, Sep 21
Queries to count distinct Binary Strings of all lengths from N to M satisfying given properties
30, Jul 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
shashipk11
@shashipk11
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!