Generar todas las strings binarias de N bits

Dado un número entero positivo N . La tarea es generar todas las strings binarias de N bits. Estas strings binarias deben estar en orden ascendente.
Ejemplos: 
 

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

Enfoque: La idea es probar cada permutación . Para cada posición, hay 2 opciones, ‘0’ o ‘1’. El retroceso se utiliza en este enfoque para probar todas las posibilidades/permutaciones. 
A continuación se muestra la implementación del enfoque anterior:
 

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>
Producción: 

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

 

Complejidad del tiempo – O(2 n )

Complejidad espacial – O(n)

Artículo Relacionado: Genera todos los números binarios del 0 al n
 

Publicación traducida automáticamente

Artículo escrito por shashipk11 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *