Find Kth lexicographical ordered numeric string of length N with distinct products of each substring

• Difficulty Level : Expert
• Last Updated : 20 Sep, 2021

Given two integers N and K,  the task is to find the Kth lexicographical ordered string of length N, which has distinct products of each of the substrings, return -1 if such a string does not exist.

Example:

Input: N = 3, K = 4
Output: 238
Explanation: The valid strings series is “234”, “235”, “237”, “238”. The 4th string in the series is “238” and the product of all its substrings {2, 3, 8, 6, 24, 48} is distinct.

Input: N = 1, K = 11
Output: -1
Explanation: There are only 10 valid strings of length 1: “0”, “1”, “2”, “3”, “4”, “5”, “6”, “7”, “8”, “9”.

Approach: The problem can be solved using recursion. Recursively check all possible numeric strings of length N and find Kth valid numeric string with distinct products of each substring.

Follow the steps to solve the problem:

• Notice when any two characters repeat in the string, it will not be a valid string as two substrings of length 1 will same product.
• All strings with length N > 10 will have no answer because at least one character will be repeated.
• For strings of length > 1, strings that will have ‘1’ or ‘0’ in them will not be valid as any number multiplied with these characters will be the same or converted to 0.
• Maintain a recursive function to calculate the total possible strings with the character ‘0’ -> ‘1’.
• Keep track of all the products till now and if the product is repeated then exit the function immediately.
• Start from 0->9 one by one and if a valid string is obtained then decrease K. For, any string S if K becomes 0, this string will be the final answer.

Below is the implementation of the above approach:

C++

 // C++ program for the above approach #include using namespace std;   // Function to find the required string void getString(int curlen, string& ans,                string& s, int N,                int& K, vector& prod) {     // If the current length is     // equal to n exit from here only     if (curlen == N) {         K--;         if (K == 0)             ans = s;         return;     }       char ch;     int ok, t, i;       // Iterate for all the characters     for (ch = '2'; ch <= '9'; ch++) {         s += ch;         ok = 1;         t = 1;         for (i = curlen; i >= 0; i--) {             t *= s[i] - 48;               // Check if the product             // is present before             if (prod[t])                 ok = 0;             prod[t]++;         }           // If the current string is good         // then recurse for         // the next character         if (ok)             getString(curlen + 1, ans,                       s, N, K, prod);         t = 1;           // Decrease all the products back         // to their original state         for (i = curlen; i >= 0; i--) {             t *= s[i] - 48;             prod[t]--;         }           // Erase the last character         s.erase(s.length() - 1);     } }   // Function to calculate // kth ordered valid string string kthValidString(int N, int K) {     // Check for the base cases     if (N > 10) {         return "-1";     }     if (N == 1) {         // There are atmost 10         // valid strings for n = 1         if (K > 10) {             return "-1";         }         string s = "";         K--;         s += (K + '0');         return s;     }       string ans = "-1";     string s = "";       // Vector to keep a check on     // number of occurences of products     vector prod(10005, 0);       // Recursively construct the strings     getString(0, ans, s, N, K, prod);     return ans; }   // Driver Code int main() {     int N = 3, K = 4;     cout << kthValidString(N, K); }

Java

 // Java program for the above approach   import java.util.*;   class GFG{     static String ans,s;     static int  K; // Function to find the required String static void getString(int curlen, int N, int[] prod) {     // If the current length is     // equal to n exit from here only     if (curlen == N) {         K--;         if (K == 0)             ans = s;         return;     }       char ch;     int ok, t, i;       // Iterate for all the characters     for (ch = '2'; ch <= '9'; ch++) {         s += ch;         ok = 1;         t = 1;         for (i = curlen ; i >= 0 && s.length()>i; i--) {             t *= s.charAt(i) - 48;               // Check if the product             // is present before             if (prod[t]!=0)                 ok = 0;             prod[t]++;         }           // If the current String is good         // then recurse for         // the next character         if (ok!=0)             getString(curlen + 1, N, prod);         t = 1;           // Decrease all the products back         // to their original state         for (i = curlen; i >= 0&& s.length()>i; i--) {             t *= s.charAt(i) - 48;             prod[t]--;         }           // Erase the last character         if(s.length()>0)         s=s.substring(0,s.length() - 1);     } }   // Function to calculate // kth ordered valid String static String kthValidString(int N) {     // Check for the base cases     if (N > 10) {         return "-1";     }     if (N == 1) {         // There are atmost 10         // valid Strings for n = 1         if (K > 10) {             return "-1";         }         String s = "";         K--;         s += (K + '0');         return s;     }       ans = "-1";     s = "";       // Vector to keep a check on     // number of occurences of products     int []prod = new int;       // Recursively construct the Strings     getString(0, N, prod);     return ans; }   // Driver Code public static void main(String[] args) {     int N = 3;     K = 4;     System.out.print(kthValidString(N)); } } // This code contributed by shikhasingrajput

C#

 // C# program for the above approach using System;   class GFG{       static String ans,s; static int  K;   // Function to find the required String static void getString(int curlen, int N, int[] prod) {           // If the current length is     // equal to n exit from here only     if (curlen == N)     {         K--;                   if (K == 0)             ans = s;                       return;     }       char ch;     int ok, t, i;       // Iterate for all the characters     for(ch = '2'; ch <= '9'; ch++)     {         s += ch;         ok = 1;         t = 1;                   for(i = curlen ; i >= 0 && s.Length>i; i--)         {             t *= s[i] - 48;               // Check if the product             // is present before             if (prod[t] != 0)                 ok = 0;                               prod[t]++;         }           // If the current String is good         // then recurse for         // the next character         if (ok != 0)             getString(curlen + 1, N, prod);                       t = 1;           // Decrease all the products back         // to their original state         for(i = curlen; i >= 0 && s.Length>i; i--)         {             t *= s[i] - 48;             prod[t]--;         }           // Erase the last character         if (s.Length > 0)             s = s.Substring(0,s.Length - 1);     } }   // Function to calculate // kth ordered valid String static String kthValidString(int N) {     String s = "";           // Check for the base cases     if (N > 10)     {         return "-1";     }     if (N == 1)     {                   // There are atmost 10         // valid Strings for n = 1         if (K > 10)         {             return "-1";         }         s = "";         K--;         s += (K + '0');         return s;     }       ans = "-1";     s = "";       // List to keep a check on     // number of occurences of products     int []prod = new int;       // Recursively construct the Strings     getString(0, N, prod);     return ans; }   // Driver Code public static void Main(String[] args) {     int N = 3;     K = 4;           Console.Write(kthValidString(N)); } }   // This code is contributed by 29AjayKumar

Python3

 # Java program for the above approach s = '' K = 0   # Function to find the required String def getString(curlen, N, prod):     global s, K     # If the current length is     # equal to n exit from here only     if (curlen == N):         K -= 1         if (K == 0):             ans = s         return             # Iterate for all the characters     ch = '2'     while(ch <= '9'):         s = chr(ord(s)+ ord(ch))         ok = 1         t = 1         i = curlen         ch = chr(ord(ch) + 1)         while(i >= 0 and len(s)) :             t *= ord(s[i]) - 48               # Check if the product             # is present before             if (prod[t] != 0):                 ok = 0             prod[t] += 1             i -= 1                   # If the current String is good         # then recurse for         # the next character         if (ok != 0):             getString(curlen + 1, N, prod)         t = 1           # Decrease all the products back         # to their original state         i = curlen         while(i >= 0 and len(s)>i):             i-=1             t *= ord(s[i]) - 48             prod[t] -= 1                   # Erase the last character         if(len(s)>0):             s = s[0: len(s) - 1]       # Function to calculate # kth ordered valid String def kthValidString(N):       # Check for the base cases     if (N > 10):         return "-1"           if (N == 1):         # There are atmost 10         # valid Strings for n = 1         if (K > 10):             return "-1"                   s = ""         K-=1         s += (K + '0')         return s           ans = "-1"     s = ""       # Vector to keep a check on     # number of occurences of products     prod = *10005       # Recursively construct the Strings     getString(0, N, prod)     return ans   # Driver Code N = 3 K = 4 print(kthValidString(N))   # This code is contributed by shikhasingrajput

Javascript



Output

238

Time Complexity: Auxiliary Space: My Personal Notes arrow_drop_up
Recommended Articles
Page :