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 <bits/stdc++.h>
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 <stdbool.h>
#include <stdio.h>
#include <string.h>
#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 <bits/stdc++.h>
using namespace std;

// stores all possible non-repetitive combinations
// of string by replacing ‘$’ with any
//    other digit from the string
unordered_set<string> 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<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[i] = s[j];
                    combinations(s,j,n);
                    s[i] = '$';
                }
            }
        }
    }
}

int main() {
    string s;
    s = "23$$";
      int len = (int)s.size();
    combinations(s,0,len);
    for(auto x:possible_comb)
    {
        cout << x << '\n';
    }
    return 0;
}

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<String> 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<n;i++)
    {
      if(s.charAt(i)=='$')
      {
        for(int j=0;j<n;j++)
        {
          if(s.charAt(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.charAt(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 args[])
  {
    String s = "23$$";
    int len = s.length();
    combinations(s,0,len);
    for(String x:possible_comb)
    {
      System.out.println(x);
    }
  }

}

// This code is contributed by shinjanpatra.

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

<script>
// stores all possible non-repetitive combinations
// of string by replacing ‘$’ with any
// other digit from the string
let possible_comb = new Set();
function combinations(s, i, n)
{

    if(i==n)
        return;
    // to check whether a string is
    // valid combination
    let is_combination = true;
    for(let i = 0; i < s.length; i++)
    {
        if(s[i] == '$')
        {
            is_combination = false;
            break;
        }
    }

    if(is_combination && possible_comb.has(s)==false)
    {
        possible_comb.add(s);
        return;
    }

    for(let i = 0; i < n; i++)
    {
        if(s[i] == '$')
        {
            for(let 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
                    let c = s[j];
                    s = s.substring(0,i) + c + s.substring(i+1)
                    combinations(s, j, n);
                    s = s.substring(0,i) + '$' + s.substring(i+1)
                }
            }
        }
    }
}

// driver code
let s;
s = "23$$";
let len = s.length;
combinations(s, 0, len);

for(let x of possible_comb)
{
    document.write(x,"</br>");
}

// This code is contributed by shinjanpatra.
</script>

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)