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 <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;
} |
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;
} |
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<Character> store= new HashSet<>();
for ( int i= 0 ; i<arr.length ;i++){
// if the current char is not '$' add it to the store set
if (arr[i] != '$' ) store.add(arr[i]);
}
//recursing everytime to get a possible combination of digits for '$'
combinations( 0 ,arr,store);
}
public static void combinations( int idx, char [] arr , Set<Character> 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 <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> |
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)