# Print all possible combinations of the string by replacing ‘\$’ with any other digit from the string

• Difficulty Level : Easy
• Last Updated : 17 Jun, 2022

Given a number as a string where some of the digits are replaced by a ‘\$’, the task is to generate all possible number by replacing the ‘\$’ with any of the digits from the given string.
Examples:

Input: str = “23\$\$”
Output:
2322
2323
2332
2333
Input: str = “\$45”
Output:
445
545

Approach:

• Find all the combinations of the string by replacing the character \$ with any of the digits of the string, for this check if the current character is a digit if yes then store this character into an array pre[] then recursively find all of its combinations else if current character is a ‘\$’ then replace it with the digits stored in the array and recursively find all the combinations.
• To find the all possible numbers initialize array set[] that stores all the possible numbers, to generate numbers take two nested loop outer loop is for input string and inner loop is for array set[] that stores all the possible combinations of the numbers. Initialize the boolean flag to check if character of the input string is already present in set[] or not if character of the input string is already present in set[] then set flag = false else if flag is true then move the current character of the input string to set[] and recursively find all the combinations of the input string and store it in the array set[]. Finally print each number from the array set[]

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;``#define MAX 20``#define DIGITS 10` `// Array to store all the``// possible numbers``string st(DIGITS,``'0'``);` `// Index to st[] element``int` `ed;` `// Function to find all the combinations``// of the string by replacing '\$' with``// the other digits of the string``void` `combinations(string& num, string& pre, ``int` `curr, ``int` `lvl)``{` `    ``// Check if current length is less than``    ``// the length of the input string``    ``if` `(curr < (``int``)num.length()) {` `        ``// If current character is a digit``        ``// then store digit into pre[] and``        ``// recursively find all the combinations``        ``if` `(num[curr] >= ``'0'` `&& num[curr] <= ``'9'``) {``            ``pre[lvl] = num[curr];``            ``combinations(num, pre, curr + 1, lvl + 1);``        ``}` `        ``// If current character is a '\$' then replace``        ``// it with the other digits of the string and``        ``// recursively find all the combinations``        ``// Else go to the next character and``        ``// recursively find all the combinations``        ``else` `if` `(num[curr] == ``'\$'``)``            ``for` `(``int` `i = 0; i < ed; i++) {``                ``pre[lvl] = st[i];``                ``combinations(num, pre, curr + 1, lvl + 1);``            ``}``        ``else``            ``combinations(num, pre, curr + 1, lvl);``    ``}` `    ``// Print the array pre[]``    ``else` `{``        ``pre[lvl] = ``'\0'``;``        ``cout << pre << ``'\n'``;``    ``}``}` `// Function to find all the numbers formed``// from the input string by replacing '\$' with``// all the digits of the input string``int` `findNumUtil(string& num)``{``    ``// Array that stores the digits before``    ``// the character \$ in the input string``    ``string pre((``int``)num.length(),``'0'``);` `    ``ed = 0;` `    ``// Traverse the input string and check if``    ``// the current character is a digit``    ``// if it is then set flag to true``    ``for` `(``int` `i = 0; i < num.length(); i++)``        ``if` `(num[i] >= ``'0'` `&& num[i] <= ``'9'``) {``            ``bool` `flag = ``true``;` `            ``// Check if current character of the input``            ``// string is already present in the array set[]``            ``// then set flag to false``            ``for` `(``int` `j = 0; j < ed; j++)``                ``if` `(st[j] == num[i])``                    ``flag = ``false``;` `            ``// Flag is true then store the character``            ``// into st[] and recursively find all``            ``// the combinations of numbers and store``            ``// it in the st[] array` `            ``if` `(flag == ``true``)``                ``st[ed++] = num[i];``        ``}` `    ``combinations(num, pre, 0, 0);` `    ``return` `0;``}` `// Function to print all the combinations``// of the numbers by replacing '\$' with``// the other digits of the input string``int` `findNum(string& num, vector<``int``>& result_count)``{``    ``int` `i;``    ``if` `(num[i]) {``        ``result_count[i] = findNumUtil(num);``        ``return` `(result_count[i]);``    ``}``    ``return` `0;``}` `// Driver code``int` `main()``{``    ``string num;``      ``num = ``"23\$\$"``;``    ``vector<``int``> result_count(MAX);` `    ``findNum(num, result_count);` `    ``return` `0;``}`

## C

 `// C implementation of the approach``#include ``#include ``#include ``#define MAX 20``#define DIGITS 10` `// Array to store all the``// possible numbers``char` `set[DIGITS];` `// Index to set[] element``int` `end;` `// Function to find all the combinations``// of the string by replacing '\$' with``// the other digits of the string``void` `combinations(``char``* num, ``char``* pre, ``int` `curr, ``int` `lvl)``{` `    ``// Check if current length is less than``    ``// the length of the input string``    ``if` `(curr < ``strlen``(num)) {` `        ``// If current character is a digit``        ``// then store digit into pre[] and``        ``// recursively find all the combinations``        ``if` `(num[curr] >= ``'0'` `&& num[curr] <= ``'9'``) {``            ``pre[lvl] = num[curr];``            ``combinations(num, pre, curr + 1, lvl + 1);``        ``}` `        ``// If current character is a '\$' then replace``        ``// it with the other digits of the string and``        ``// recursively find all the combinations``        ``// Else go to the next character and``        ``// recursively find all the combinations``        ``else` `if` `(num[curr] == ``'\$'``)``            ``for` `(``int` `i = 0; i < end; i++) {``                ``pre[lvl] = set[i];``                ``combinations(num, pre, curr + 1, lvl + 1);``            ``}``        ``else``            ``combinations(num, pre, curr + 1, lvl);``    ``}` `    ``// Print the array pre[]``    ``else` `{``        ``pre[lvl] = ``'\0'``;``        ``printf``(``"%s\n"``, pre);``    ``}``}` `// Function to find all the numbers formed``// from the input string by replacing '\$' with``// all the digits of the input string``int` `findNumUtil(``char` `num[])``{``    ``// Array that stores the digits before``    ``// the character \$ in the input string``    ``char` `pre[MAX];` `    ``end = 0;` `    ``// Traverse the input string and check if``    ``// the current character is a digit``    ``// if it is then set flag to true``    ``for` `(``int` `i = 0; i < ``strlen``(num); i++)``        ``if` `(num[i] >= ``'0'` `&& num[i] <= ``'9'``) {``            ``bool` `flag = ``true``;` `            ``// Check if current character of the input``            ``// string is already present in the array set[]``            ``// then set flag to false``            ``for` `(``int` `j = 0; j < end; j++)``                ``if` `(set[j] == num[i])``                    ``flag = ``false``;` `            ``// Flag is true then store the character``            ``// into set[] and recursively find all``            ``// the combinations of numbers and store``            ``// it in the set[] array` `            ``if` `(flag == ``true``)``                ``set[end++] = num[i];``        ``}` `    ``combinations(num, pre, 0, 0);` `    ``return` `0;``}` `// Function to print all the combinations``// of the numbers by replacing '\$' with``// the other digits of the input string``int` `findNum(``char``* num, ``int``* result_count)``{``    ``int` `i;``    ``if` `(num[i]) {``        ``result_count[i] = findNumUtil(num);``        ``return` `(result_count[i]);``    ``}``    ``return` `0;``}` `// Driver code``int` `main()``{``    ``char` `num[MAX] = ``"23\$\$"``;``    ``int` `result_count[MAX];` `    ``findNum(num, result_count);` `    ``return` `0;``}`

## Python3

 `# Python3 implementation of the approach`  `MAX``=``20``DIGITS``=``10` `# Array to store all the``# possible numbers``st``=``[``'0'``]``*``DIGITS``pre``=``[]` `# Index to st[] element``ed``=``0` `# Function to find all the combinations``# of the string by replacing '\$' with``# the other digits of the string``def` `combinations(curr, lvl):``    ``global` `num,pre` `    ``# Check if current length is less than``    ``# the length of the input string``    ``if` `(curr < ``len``(num)):` `        ``# If current character is a digit``        ``# then store digit into pre[] and``        ``# recursively find all the combinations``        ``if` `(num[curr] >``=` `'0'` `and` `num[curr] <``=` `'9'``):``            ``pre[lvl] ``=` `num[curr]``            ``combinations(curr ``+` `1``, lvl ``+` `1``)` `        ``# If current character is a '\$' then replace``        ``# it with the other digits of the string and``        ``# recursively find all the combinations``        ``# Else go to the next character and``        ``# recursively find all the combinations``        ``elif` `(num[curr] ``=``=` `'\$'``):``            ``for` `i ``in` `range``(ed):``                ``pre[lvl] ``=` `st[i]``                ``combinations(curr ``+` `1``, lvl ``+` `1``)``        ``else``:``            ``combinations(curr ``+` `1``, lvl)` `    ``# Print array pre[]``    ``else``:``        ``print``(''.join(pre))` `# Function to find all the numbers formed``# from the input string by replacing '\$' with``# all the digits of the input string``def` `findNumUtil():``    ``# Array that stores the digits before``    ``# the character \$ in the input string``    ``global` `pre,ed``    ``pre``=``[``'0'``]``*``len``(num)` `    ``ed ``=` `0` `    ``# Traverse the input string and check if``    ``# the current character is a digit``    ``# if it is then set flag to True``    ``for` `i ``in` `range``(``len``(num)):``        ``if` `(num[i] >``=` `'0'` `and` `num[i] <``=` `'9'``):``            ``flag ``=` `True` `            ``# Check if current character of the input``            ``# string is already present in the array set[]``            ``# then set flag to False``            ``for` `j ``in` `range``(ed):``                ``if` `(st[j] ``=``=` `num[i]):``                    ``flag ``=` `False` `            ``# Flag is True then store the character``            ``# into st[] and recursively find all``            ``# the combinations of numbers and store``            ``# it in the st[] array` `            ``if` `flag:``                ``st[ed] ``=` `num[i]``                ``ed``+``=``1` `    ``combinations(``0``, ``0``)` `    ``return` `0` `# Function to print all the combinations``# of the numbers by replacing '\$' with``# the other digits of the input string``def` `findNum(result_count):``    ``i``=``0``    ``if` `(num[i]):``        ``result_count[i] ``=` `findNumUtil()``        ``return` `(result_count[i])``    ``return` `0` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``num ``=` `"23\$\$"``    ``result_count``=``[``0``]``*``MAX` `    ``findNum(result_count)`

Output

```2322
2323
2332
2333```

in-built library/dataset based approach:-

## C++

 `#include ``using` `namespace` `std;` `// stores all possible non-repetitive combinations``// of string by replacing ‘\$’ with any``//    other digit from the string``unordered_set possible_comb;` `void` `combinations(string s,``int` `i,``int` `n)``{``  ` `    ``if``(i==n)``        ``return``;``      ``// to check whether a string is``      ``// valid combination``    ``bool` `is_combination = ``true``;``    ``for``(``int` `i=0;i<(``int``)s.length();i++)``    ``{``        ``if``(s[i]==``'\$'``)``        ``{``            ``is_combination = ``false``;``            ``break``;``        ``}``    ``}``    ` `    ``if``(is_combination &&  possible_comb.find(s)==possible_comb.end())``    ``{``        ``possible_comb.insert(s);``        ``return``;``    ``}``    ` `    ``for``(``int` `i=0;i

## Java

 `/*package whatever //do not write package name here */``import` `java.io.*;``import` `java.util.*;` `class` `GFG``{``  ` `  ``// stores all possible non-repetitive combinations``  ``// of string by replacing ‘\$’ with any``  ``// other digit from the string``  ``static` `HashSet possible_comb = ``new` `HashSet<>();` `  ``static` `void` `combinations(String s,``int` `k,``int` `n)``  ``{` `    ``if``(k==n)``      ``return``;``    ``// to check whether a string is``    ``// valid combination``    ``boolean` `is_combination = ``true``;``    ``for``(``int` `i=``0``;i< s.length();i++)``    ``{``      ``if``(s.charAt(i)==``'\$'``)``      ``{``        ``is_combination = ``false``;``        ``break``;``      ``}``    ``}` `    ``if``(is_combination && possible_comb.contains(s)== ``false``)``    ``{``      ``possible_comb.add(s);``      ``return``;``    ``}` `    ``for``(``int` `i=``0``;i

## Python3

 `# stores all possible non-repetitive combinations``# of string by replacing ‘\$’ with any``#    other digit from the string``possible_comb``=``set``()` `def` `combinations(s,i,n):``    ``list_s``=``list``(s)``    ``if``(i``=``=``n):``        ``return``    ``# to check whether a string is``    ``# valid combination``    ``is_combination ``=` `True``    ``for` `i ``in` `range``(``len``(s)):``        ``if``(s[i]``=``=``'\$'``):``            ``is_combination ``=` `False``            ``break``        ` `    ` `    ` `    ``if``(is_combination ``and` `s ``not` `in` `possible_comb):``        ``possible_comb.add(s)``        ``return``    ` `    ` `    ``for` `i ``in` `range``(n):``        ``if``(s[i]``=``=``'\$'``):``            ``for` `j ``in` `range``(n):``                ``if``(s[j]!``=``'\$'``):``                      ``# replace the character having '\$'``                      ``#    with one of the digit from the``                      ``# string  and recur in the combination``                      ``# function``                    ``list_s[i] ``=` `list_s[j]``                    ``combinations(''.join(list_s),j,n)``                    ``list_s[i] ``=` `'\$'``                ` `            ` `        ` `    `   `if` `__name__ ``=``=` `'__main__'``:``    ``s ``=` `"23\$\$"``    ``combinations(s,``0``,``len``(s))``    ``for` `x ``in` `possible_comb:``        ``print``(x)`

## Javascript

 ``

Output

```2333
2332
2322
2323```

Time Complexity:- O(n^x) where x is the number of instances of \$ in the string and n is the length of string

Auxiliary Space:- O(1)

My Personal Notes arrow_drop_up