 Open in App
Not now

# Generate all binary strings from given pattern

• Difficulty Level : Medium
• Last Updated : 20 Oct, 2022

Given a string containing of ‘0’, ‘1’ and ‘?’ wildcard characters, generate all binary strings that can be formed by replacing each wildcard character by ‘0’ or ‘1’.
Example :

Input: str = “1??0?101”
Output:
10000101
10001101
10100101
10101101
11000101
11001101
11100101
11101101

Recommended Practice

Method 1 (Using Recursion)
We pass index of next character to the recursive function. If the current character is a wildcard character ‘?’, we replace it with ‘0’ or ‘1’ and do the same for all remaining characters. We print the string if we reach at its end.

Algorithm:
Step 1: Initialize the string first with some wildcard characters in it.
Step 2: Check if index position is equals to the size of string, If it is return.
Step 3: If wildcard character is present at index location, replace it by 0 or 1 accordingly.
Step 4: Print the output

Below is the implementation of the above approach:

## C++

 `// Recursive C++ program to generate all binary strings``// formed by replacing each wildcard character by 0 or 1``#include ``using` `namespace` `std;` `// Recursive function to generate all binary strings``// formed by replacing each wildcard character by 0 or 1``void` `print(string str, ``int` `index)``{``    ``if` `(index == str.size())``    ``{``        ``cout << str << endl;``        ``return``;``    ``}` `    ``if` `(str[index] == ``'?'``)``    ``{``        ``// replace '?' by '0' and recurse``        ``str[index] = ``'0'``;``        ``print(str, index + 1);` `        ``// replace '?' by '1' and recurse``        ``str[index] = ``'1'``;``        ``print(str, index + 1);` `        ``// No need to backtrack as string is passed``        ``// by value to the function``    ``}``    ``else``        ``print(str, index + 1);``}` `// Driver code to test above function``int` `main()``{``    ``string str = ``"1??0?101"``;` `    ``print(str, 0);` `    ``return` `0;``}`

## Java

 `// Recursive Java program to generate all``// binary strings formed by replacing``// each wildcard character by 0 or 1``import` `java.util.*;``import` `java.lang.*;``import` `java.io.*;` `class` `binStr``{  ``    ``// Recursive function to generate all binary``    ``// strings formed by replacing each wildcard``    ``// character by 0 or 1``    ``public` `static` `void` `print(``char` `str[], ``int` `index)``    ``{``        ``if` `(index == str.length)``        ``{``            ``System.out.println(str);``            ``return``;``        ``}` `        ``if` `(str[index] == ``'?'``)``        ``{``            ``// replace '?' by '0' and recurse``            ``str[index] = ``'0'``;``            ``print(str, index + ``1``);``            ` `            ``// replace '?' by '1' and recurse``            ``str[index] = ``'1'``;``            ``print(str, index + ``1``);``            ` `            ``// NOTE: Need to backtrack as string``            ``// is passed by reference to the``            ``// function``            ``str[index] = ``'?'``;``        ``}``        ``else``            ``print(str, index + ``1``);``    ``}` `    ``// driver code``    ``public` `static` `void` `main (String[] args)``    ``{``        ``String input = ``"1??0?101"``;``        ``char``[] str = input.toCharArray();``        ``print(str, ``0``);``    ``}``}` `// This code is contributed by Chhavi`

## Python3

 `# Recursive Python program to generate all``# binary strings formed by replacing``# each wildcard character by 0 or 1` `# Recursive function to generate all binary``# strings formed by replacing each wildcard``# character by 0 or 1``def` `_print(string, index):``    ``if` `index ``=``=` `len``(string):``        ``print``(''.join(string))``        ``return` `    ``if` `string[index] ``=``=` `"?"``:` `        ``# replace '?' by '0' and recurse``        ``string[index] ``=` `'0'``        ``_print(string, index ``+` `1``)` `        ``# replace '?' by '1' and recurse``        ``string[index] ``=` `'1'``        ``_print(string, index ``+` `1``)` `        ``# NOTE: Need to backtrack as string``        ``# is passed by reference to the``        ``# function``        ``string[index] ``=` `'?'``    ``else``:``        ``_print(string, index ``+` `1``)` `# Driver code``if` `__name__ ``=``=` `"__main__"``:` `    ``string ``=` `"1??0?101"``    ``string ``=` `list``(string)``    ``_print(string, ``0``)` `    ``# This code is contributed by``    ``# sanjeev2552` `# Note: function name _print is used because``# print is already a predefined function in Python`

## C#

 `// Recursive C# program to generate all``// binary strings formed by replacing``// each wildcard character by 0 or 1``using` `System;` `class` `GFG``{``    ``// Recursive function to generate``    ``// all binary strings formed by``    ``// replacing each wildcard character``    ``// by 0 or 1``    ``public` `static` `void` `print(``char` `[]str,``                             ``int` `index)``    ``{``        ``if` `(index == str.Length)``        ``{``            ``Console.WriteLine(str);``            ``return``;``        ``}` `        ``if` `(str[index] == ``'?'``)``        ``{``            ``// replace '?' by``            ``// '0' and recurse``            ``str[index] = ``'0'``;``            ``print(str, index + 1);``            ` `            ``// replace '?' by``            ``// '1' and recurse``            ``str[index] = ``'1'``;``            ``print(str, index + 1);``            ` `            ``// NOTE: Need to backtrack``            ``// as string is passed by``            ``// reference to the function``            ``str[index] = ``'?'``;``        ``}``        ``else``            ``print(str, index + 1);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main ()``    ``{``        ``string` `input = ``"1??0?101"``;``        ``char` `[]str = input.ToCharArray();``        ``print(str, 0);``    ``}``}` `// This code is contributed by nitin mittal.`

## PHP

 ``

## Javascript

 ``

Output:

```10000101
10001101
10100101
10101101
11000101
11001101
11100101
11101101```

Time Complexity: O(2N), where N is the length of the given string and there are 2 possibilities.
Auxiliary Space: O(N2), as a copy of the string is created in every recursive call.

Method 2 (Using Queue)
We can also achieve this by using iteration. The idea is to use queue, We find position of first occurrence of wildcard character in the input string and replace it by ‘0’ , then ‘1’ and push both strings into the queue. Then we pop next string from the queue, and repeat the process till queue is empty. If no wildcard characters are left, we simply print the string.
Iterative C++ implementation using queue.

## C++

 `// Iterative C++ program to generate all binary``// strings formed by replacing each wildcard``// character by 0 or 1``#include ``#include ``using` `namespace` `std;` `// Iterative function to generate all binary strings``// formed by replacing each wildcard character by 0``// or 1``void` `print(string str)``{``    ``queue q;``    ``q.push(str);` `    ``while` `(!q.empty())``    ``{``        ``string str = q.front();` `        ``// find position of first occurrence of wildcard``        ``size_t` `index = str.find(``'?'``);` `        ``// If no matches were found,``        ``// find returns string::npos``        ``if``(index != string::npos)``        ``{``            ``// replace '?' by '0' and push string into queue``            ``str[index] = ``'0'``;``            ``q.push(str);` `            ``// replace '?' by '1' and push string into queue``            ``str[index] = ``'1'``;``            ``q.push(str);``        ``}` `        ``else``            ``// If no wildcard characters are left,``            ``// print the string.``            ``cout << str << endl;` `        ``q.pop();``    ``}``}` `// Driver code to test above function``int` `main()``{``    ``string str = ``"1??0?101"``;` `    ``print(str);` `    ``return` `0;``}`

## Java

 `/*package whatever //do not write package name here */``import` `java.io.*;``import` `java.util.*;` `class` `GFG {``    ``// Iterative Java program to generate all binary``// strings formed by replacing each wildcard``// character by 0 or 1` `// Iterative function to generate all binary strings``// formed by replacing each wildcard character by 0``// or 1``static` `void` `print(String str)``{``    ``Queue q = ``new` `LinkedList<>();``    ``q.add(str);` `    ``while` `(!q.isEmpty())``    ``{``        ``str = q.remove();` `        ``// find position of first occurrence of wildcard``        ``int` `index = str.indexOf(``'?'``);` `        ``// If no matches were found,``        ``// find returns string::npos``        ``if``(index != -``1``)``        ``{``            ``// replace '?' by '0' and add string into queue``            ``str = str.substring(``0``,index) + ``'0'` `+ str.substring(index+``1``);``            ``q.add(str);` `            ``// replace '?' by '1' and add string into queue``            ``str = str.substring(``0``,index) + ``'1'` `+ str.substring(index+``1``);``            ``q.add(str);``        ``}` `        ``else``            ``// If no wildcard characters are left,``            ``// print the string.``            ``System.out.println(str);` `    ``}``}``    ` `// Driver Code``public` `static` `void` `main(String args[])``{``    ``String str = ``"1??0?101"``;``    ``print(str);` `}``}` `// This code is contributed by shinjanpatra`

## Python3

 `# Iterative Python program to generate all binary``# strings formed by replacing each wildcard``# character by 0 or 1`` ` `# Iterative function to generate all binary strings``# formed by replacing each wildcard character by 0``# or 1``def` `Print``(``Str``):``    ``q ``=` `[]``    ``q.append(``Str``)``    ``while``(``len``(q) > ``0``):``        ``Str` `=` `q[``0``]``        ` `        ``# find position of first occurrence of wildcard``        ``try``:``            ``index ``=` `Str``.index(``'?'``)``        ``except` `ValueError:``            ``index ``=` `-``1``            ` `        ``# If no matches were found,``        ``# find returns -1``        ``if``(index !``=` `-``1``):``           ` `            ``# replace '?' by '0' and push string into queue``            ``s1``=``Str``.replace(``'?'``,``'0'``,``1``)``            ``q.append(s1)``            ` `            ``# replace '?' by '1' and push string into queue``            ``s2``=``Str``.replace(``'?'``,``'1'``,``1``)``            ``q.append(s2)``        ``else``:``            ``# If no wildcard characters are left,``            ``# print the string.``            ``print``(``Str``)``        ``q.pop(``0``)``            ` `# Driver code``Str` `=` `"1??0?101"``Print``(``Str``)` `# This code is contributed by Pushpesh Raj`

## C#

 `// C# program to implement the approach``using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG``{` `  ``// Iterative C# program to generate all binary``  ``// strings formed by replacing each wildcard``  ``// character by 0 or 1` `  ``// Iterative function to generate all binary strings``  ``// formed by replacing each wildcard character by 0``  ``// or 1``  ``static` `void` `print(``string` `Str)``  ``{` `    ``var` `q = ``new` `List<``string``>();``    ``q.Add(Str);``    ``while` `(q.Count > 0) {``      ``Str = q;` `      ``// find position of first occurrence of wildcard``      ``int` `index = Str.IndexOf(``'?'``);` `      ``// If no matches were found,``      ``// find returns -1``      ``if` `(index != -1) {` `        ``// replace '?' by '0' and push string into``        ``// queue``        ``Str = Str.Substring(0, index) + ``'0'``          ``+ Str.Substring(index + 1);``        ``q.Add(Str);` `        ``// replace '?' by '1' and push string into``        ``// queue``        ``Str = Str.Substring(0, index) + ``'1'``          ``+ Str.Substring(index + 1);``        ``q.Add(Str);``      ``}` `      ``else` `{` `        ``// If no wildcard characters are left,``        ``// print the string.``        ``Console.WriteLine(Str);``      ``}` `      ``q.RemoveAt(0);``    ``}``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(``string``[] args)``  ``{``    ``string` `str = ``"1??0?101"``;``    ` `    ``// Function call``    ``print(str);``  ``}``}` `// This code is contributed by phasing17`

## Javascript

 ``

Output:

```10000101
10001101
10100101
10101101
11000101
11001101
11100101
11101101```

Time Complexity: O(N*2N),  where N is the size of the string.
Auxiliary Space: O(2N)

Method 3 (Using str and Recursion)

## C++

 `// C++ program to implement the approach``#include ` `using` `namespace` `std;` `/* we store processed strings in all (array)``we see if string as "?", if so, replace it with 0 and 1``and send it back to recursive func until base case is``reached which is no wildcard left */` `vector res;` `void` `genBin(string s)``{``    ``auto` `pos = s.find(``'?'``);``    ``if` `(pos != string::npos) {``        ``// copying s to s1``        ``string s1 = s;``        ``// replacing first occurrence of ?``        ``// with 0``        ``s1.replace(pos, 1, ``"0"``);``        ``// copying s to s2``        ``string s2 = s;``        ``// replacing first occurrence of ?``        ``// with 1``        ``s2.replace(pos, 1, ``"1"``);``        ``genBin(s1);``        ``genBin(s2);``    ``}``    ``else` `{``        ``res.push_back(s);``    ``}``}` `// Driver code``int` `main()``{``    ``genBin(``"1??0?101"``);``    ``for` `(string x : res) {``        ``cout << x << ``" "``;``    ``}``}` `// This code is contributed by phasing17`

## Java

 `import` `java.io.*;``import` `java.util.*;` `class` `GFG``{` `  ``// we store processed strings in all (array)``  ``// we see if string as "?", if so, replace it with 0 and 1``  ``// and send it back to recursive func until base case is reached``  ``// which is no wildcard left``  ``static` `ArrayListres = ``new` `ArrayList();``  ``static` `void` `genBin(String s) {``    ``if` `(s.indexOf(``'?'``) != -``1``) {``      ``String s1 = s.replaceFirst(``"\\?"``, ``"0"``); ``// only replace once``      ``String s2 = s.replaceFirst(``"\\?"``, ``"1"``); ``// only replace once``      ``genBin(s1);``      ``genBin(s2);``    ``}``    ``else` `res.add(s);``  ``}` `  ``public` `static` `void` `main(String[] args) {``    ``genBin(``"1??0?101"``);``    ``System.out.println(res);``  ``}``}`

## Python3

 `#we store processed strings in all (array)``#we see if string as "?", if so, replace it with 0 and 1``#and send it back to recursive func until base case is reached``#which is no wildcard left` `res ``=` `[]``def` `genBin(s):``    ``if` `'?'` `in` `s:``        ``s1 ``=` `s.replace(``'?'``,``'0'``,``1``) ``#only replace once``        ``s2 ``=` `s.replace(``'?'``,``'1'``,``1``) ``#only replace once``        ``genBin(s1)``        ``genBin(s2)``    ``else``: res.append(s)` `# Driver code``genBin(``"1??0?101"``)``print``(res)` `# This code is contributed by``# divay pandey`

## C#

 `// C# code to implement the approach` `using` `System;``using` `System.Collections.Generic;` `class` `GFG {` `    ``// we store processed strings in all (array)``    ``// we see if string as "?", if so, replace it with 0 and``    ``// 1 and send it back to recursive func until base case``    ``// is reached which is no wildcard left``    ``static` `List<``string``> res = ``new` `List<``string``>();``    ``static` `void` `genBin(``string` `s)``    ``{``        ``int` `ind = s.IndexOf(``"?"``);``        ``if` `(ind != -1) {``            ``string` `s1 = s.Remove(ind, 1).Insert(``                ``ind, ``"0"``); ``// only replace once``            ``string` `s2 = s.Remove(ind, 1).Insert(``                ``ind, ``"1"``); ``// only replace once``            ``genBin(s1);``            ``genBin(s2);``        ``}``        ``else``            ``res.Add(s);``    ``}``    ` `  ` `      ``// Driver code``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``genBin(``"1??0?101"``);``        ``foreach``(``var` `ele ``in` `res) Console.Write(ele + ``" "``);``    ``}``}`  `// This code is contributed by phasing17`

## Javascript

 ``

Output:

`['10000101', '10001101', '10100101', '10101101', '11000101', '11001101', '11100101', '11101101']`

Time Complexity: O(N*2N),  where N is the size of the string.
Auxiliary Space: O(2N)