Get the best out of our app
GeeksforGeeks App
Open App
Browser
Continue

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

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 ``#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;``}`

## 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;``}`

## 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)`

## Java

 `/*package whatever //do not write package name here */`` ``import` `java.util.*;``import` `java.io.*;` `class` `GFG {``    ``public` `static` `void` `main(String args[]) {``      ``String s = ``"23\$\$"``;``      ``// converting string to char array``      ``char``[] arr = s.toCharArray();``      ``//store the digits of string in store which is a set, to use it for replacing '\$'``         ``Set store=``new` `HashSet<>();``      ``for``(``int` `i=``0``; i store){``      ``//if the current index is greater than the char array length print the current string and return``        ``if``(idx>=arr.length){``            ``String ans = String.valueOf(arr);``            ``System.out.println(ans);``            ``return``;``        ``}``      ``//if the char at current index is '\$' replace it with digits in store``      ``//using for loop we can replace current '\$' with all possible digits``        ``if``(arr[idx]==``'\$'``){` `            ``for``(``char` `c:store){``             ``// replace the character having '\$' with one of the digit from the string``              ``//and recur in the combination function``                ``arr[idx] = c;``                ``combinations(idx+``1``, arr,store);``              ` `                ``arr[idx] = ``'\$'``;``            ``}` `        ``}``else``{``           ``combinations(idx+``1``, arr,store);``        ``}``    ``}``}`

## Javascript

 `const MAX = 20;``const DIGITS = 10;` `// Array to store all the possible numbers``const st = Array(DIGITS).fill(``'0'``);``let pre = [];` `// Index to st[] element``let ed = 0;` `// Function to find all the combinations of``// the string by replacing '\$' with the``// other digits of the string``function` `combinations(curr, lvl)``{` `  ``// Check if current length is``  ``// less than the length of the input string``  ``if` `(curr < 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(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` `(let i = 0; i < ed; i++) {``        ``pre[lvl] = st[i];``        ``combinations(curr + 1, lvl + 1);``      ``}``    ``} ``else` `{``      ``combinations(curr + 1, lvl);``    ``}``  ``}``  ``// Print array pre[]``  ``else` `{``    ``console.log(pre.join(``''``));``  ``}``}` `// Function to find all the numbers``// formed from the input string by``// replacing '\$' with all the digits of the input string``function` `findNumUtil() {` `  ``// Array that stores the digits``  ``// before the character \$ in the input string``  ``pre = Array(num.length).fill(``'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` `(let i = 0; i < num.length; i++) {``    ``if` `(num[i] >= ``'0'` `&& num[i] <= ``'9'``) {``      ``let flag = ``true``;` `      ``// Check if current character of``      ``/ the input string is already present``      ``// in the array set[] then set flag to False``      ``for` `(let 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) {``        ``st[ed] = num[i];``        ``ed++;``      ``}``    ``}``  ``}` `  ``combinations(0, 0);``  ``return` `0;``}` `// Function to print all the combinations of``// the numbers by replacing '\$' with the``// other digits of the input string``function` `findNum(result_count) {``  ``let i = 0;``  ``if` `(num[i]) {``    ``result_count[i] = findNumUtil();``    ``return` `result_count[i];``  ``}``  ``return` `0;``}` `// Driver code``let num = ``"23\$\$"``;``let result_count = Array(MAX).fill(0);` `findNum(result_count);`

## C#

 `// c# code for the above approach``using` `System;` `public` `class` `GFG {``    ``const` `int` `MAX = 20;``    ``const` `int` `DIGITS = 10;` `    ``// Array to store all the possible numbers``    ``static` `char``[] ``set` `= ``new` `char``[DIGITS];` `    ``// Index to set[] element``    ``static` `int` `end;` `    ``// Function to find all the combinations of the string``    ``// by replacing '\$' with the other digits of the string``    ``static` `void` `Combinations(``string` `num, ``char``[] pre,``                             ``int` `curr, ``int` `lvl)``    ``{``        ``// Check if current length is less than the length``        ``// of the input string``        ``if` `(curr < num.Length) {``            ``// If current character is a digit then store``            ``// digit into pre[] and recursively find all the``            ``// combinations``            ``if` `(Char.IsDigit(num[curr])) {``                ``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'``;``            ``Console.WriteLine(``new` `string``(pre));``        ``}``    ``}` `    ``// Function to find all the numbers formed from the``    ``// input string by replacing '\$' with all the digits of``    ``// the input string``    ``static` `int` `FindNumUtil(``string` `num)``    ``{``        ``// Array that stores the digits before the character``        ``// \$ in the input string``        ``char``[] pre = ``new` `char``[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 < num.Length; i++) {``            ``if` `(Char.IsDigit(num[i])) {``                ``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``;``                        ``break``;``                    ``}``                ``}``                ``// 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) {``                    ``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``    ``static` `int` `FindNum(``string` `num, ``int``[] result_count)``    ``{``        ``if` `(!String.IsNullOrEmpty(num)) {``            ``result_count[0] = FindNumUtil(num);``            ``return` `result_count[0];``        ``}``        ``return` `0;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``string` `num = ``"23\$\$"``;``        ``int``[] result_count = ``new` `int``[MAX];``        ``FindNum(num, 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

 ``

## C#

 `using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG``{``    ``// stores all possible non-repetitive combinations``    ``// of string by replacing ‘\$’ with any``    ``// other digit from the string``    ``static` `HashSet<``string``> possible_comb = ``new` `HashSet<``string``>();` `    ``static` `void` `Combinations(``string` `s, ``int` `k, ``int` `n)``    ``{``        ``if` `(k == n)``        ``{``            ``return``;``        ``}` `        ``// to check whether a string is``        ``// valid combination``        ``bool` `is_combination = ``true``;``        ``for` `(``int` `i = 0; i < s.Length; i++)``        ``{``            ``if` `(s[i] == ``'\$'``)``            ``{``                ``is_combination = ``false``;``                ``break``;``            ``}``        ``}` `        ``if` `(is_combination && !possible_comb.Contains(s))``        ``{``            ``possible_comb.Add(s);``            ``return``;``        ``}` `        ``for` `(``int` `i = 0; i < n; i++)``        ``{``            ``if` `(s[i] == ``'\$'``)``            ``{``                ``for` `(``int` `j = 0; j < n; j++)``                ``{``                    ``if` `(s[j] != ``'\$'``)``                    ``{``                        ``// replace the character having '\$'``                        ``// with one of the digit from the``                        ``// string and recur in the combination``                        ``// function``                        ``s = s.Substring(0, i) + s[j] + s.Substring(i + 1);``                        ``Combinations(s, j, n);``                        ``s = s.Substring(0, i) + ``'\$'` `+ s.Substring(i + 1);``                    ``}``                ``}``            ``}``        ``}``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{``        ``string` `s = ``"23\$\$"``;``        ``int` `len = s.Length;``        ``Combinations(s, 0, len);``        ``foreach` `(``string` `x ``in` `possible_comb)``        ``{``            ``Console.WriteLine(x);``        ``}``    ``}``}`

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