# 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<``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; 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<``int``> 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``[``10005``];`   `    ``// 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``[10005];`   `    ``// 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 ``=` `[``0``]``*``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 :