JavaScript Program to Generate all Binary Strings From Given Pattern

Last Updated : 06 Jun, 2024
Comments
Improve
Suggest changes
Like Article
Like
Report

In this article, we are going to learn about Generating all binary strings from a given pattern in JavaScript. Generating all binary strings from a given pattern involves creating a set of binary sequences that follow the pattern's structure, where specific positions in the sequences can be filled with '0' or '1' based on the pattern's placeholders or rules.

Table of Content

We will explore all the above methods along with their basic implementation with the help of examples.

Using Recursion

In this approach,

  • Recursion involves a function calling itself with modified parameters.
  • In this example, recursion generates binary strings based on the input pattern.
  • It branches at wildcard characters ('X') and preserves non-'X' characters, exploring all valid combinations.

Example: In this example, The BinaryStrings function generates binary strings by replacing 'X' in the input string 'X1X' with '0' and '1', recursively exploring all possibilities and printing the results.

JavaScript 
function BinaryStrings(str, index = '') {
    index.length === str.length
        ? console.log(index)
        : str[index.length] === 'X'
            ? (BinaryStrings(str, index + '0'),
                BinaryStrings(str, index + '1'))
            : BinaryStrings(str, index + str[index.length]);
}

const result = 'X1X';
BinaryStrings(result);

Output
010
011
110
111

Using Queue

In this approach,

  • We use a queue to iteratively generate binary strings from the 'X' pattern.
  • Expands the queue by appending '0' and '1' for 'X' characters or preserving non-'X' characters.
  • Prints valid binary strings when they reach the pattern's length.

Example: In this example, we are using the above-explained approach.

JavaScript 
function generateBinaryStrings(str) {
    const queue = [''];

    for (let i = 0; i < queue.length; i++) {
        const current = queue[i];

        if (current.length === str.length) {
            console.log(current);
        } else {
            const nextIndex = current.length;
            if (str[nextIndex] === 'X') {
                queue.push(current + '0');
                queue.push(current + '1');
            } else {
                queue.push(current + str[nextIndex]);
            }
        }
    }
}

const result = 'X1X';
generateBinaryStrings(result);

Output
010
011
110
111

Using bitwise operations

In this approach, we first count the number of wildcard characters ('X') in the pattern. Then, we iterate from 0 to 2^wildcardCount - 1, generating all possible binary numbers within that range. For each binary number, we replace the wildcard characters in the pattern with the corresponding binary digits and print the resulting binary string.

Example:

JavaScript 
function generateBinaryStrings(str) {
    // Convert the input pattern into an array for easier manipulation
    let pattern = str.split('');

    // Find the total number of wildcard characters ('X') in the pattern
    let wildcardCount = pattern.reduce((count, char) => char === 'X' 
    ? count + 1 : count, 0);

    // Generate all possible binary numbers from 0 to 2^wildcardCount - 1
    for (let i = 0; i < Math.pow(2, wildcardCount); i++) {
        // Convert the number to binary representation
        let binary = i.toString(2).padStart(wildcardCount, '0'); 

        // Replace wildcard characters ('X') with binary digits
        let result = pattern.map(char => char === 'X' 
        ? binary.charAt(0) : char).join('');

        // Print the generated binary string
        console.log(result);
    }
}


const pattern = 'X1X';
generateBinaryStrings(pattern);

Output
010
010
111
111



Next Article
JavaScript Program to Generate all Binary Strings From Given Pattern

P
parzival_op
Improve
Article Tags :

Similar Reads