K-th lexicographical string of given length

• Difficulty Level : Medium
• Last Updated : 05 Aug, 2021

Given two integers N and K, the task is to find lexicographically Kth string of length N. If the number of possible strings of length N is less than K, print -1.
Examples:

Input: N = 3, K = 10
Output: “aaj”
Explanation: The 10th string in the lexicographical order starting from “aaa” is “aaj”.
Input: N = 2, K = 1000
Output: -1
Explanation: A total of 26*26 = 676 strings of length 2 are possible. So the output will be -1.

Approach:

• Let us assume a string of length N as an integer of base 26.

• For example, if N = 3, the first string will be s = “aaa” whose base 26 representation in integer will be 0 0 0, the second string will be s = “aab” and base 26 representation will be 0 0 1 and so on. Hence each digit can have a value within [0, 25].

• Starting from the last digit, we need to change it to all possible values followed by the penultimate digit and so on.

• So, the simplified problem is to find the representation of a decimal number K into a 26 base number. You can read this post to have a clear idea how to do this.

• After we find the answer in the form of an integer of base 26, we will convert each digit into its equivalent character, where 0 is ‘a’, 1 is ‘b’, …. 24 is ‘y’, 25 is ‘z’.

Below is the implementation of the above approach:

C++

 `// C++ program to find the K-th ` `// lexicographical string of length N` `#include ` `using` `namespace` `std;`   `string find_kth_String_of_n(``int` `n, ``int` `k) ` `{` `    `  `    ``// Initialize the array to store` `    ``// the base 26 representation of  ` `    ``// K with all zeroes, that is,  ` `    ``// the initial String consists` `    ``// of N a's` `    ``int` `d[n] = {0};`   `    ``// Start filling all the` `    ``// N slots for the base 26` `    ``// representation of K` `    ``for``(``int` `i = n - 1; i > -1; i--) ` `    ``{` `        `  `       ``// Store the remainder` `       ``d[i] = k % 26;` `       `  `       ``// Reduce K` `       ``k /= 26;` `    ``}` `    `  `    ``// If K is greater than the` `    ``// possible number of strings` `    ``// that can be represented by` `    ``// a string of length N` `    ``if` `(k > 0)` `        ``return` `"-1"``;`   `    ``string s = ``""``;` `    `  `    ``// Store the Kth lexicographical` `    ``// string` `    ``for``(``int` `i = 0; i < n; i++)` `       ``s += (d[i] + (``'a'``));`   `    ``return` `s;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `n = 3;` `    ``int` `k = 10;` `    `  `    ``// Reducing k value by 1 because` `    ``// our stored value starts from 0` `    ``k -= 1;` `    `  `    ``cout << find_kth_String_of_n(n, k);` `    ``return` `0;` `}`   `// This code is contributed by 29AjayKumar`

Java

 `// Java program to find the` `// K-th lexicographical String` `// of length N` `class` `GFG{` `    `  `static` `String find_kth_String_of_n(``int` `n, ``int` `k) ` `{` `    ``// Initialize the array to` `    ``// store the base 26` `    ``// representation of K` `    ``// with all zeroes, that is,` `    ``// the initial String consists` `    ``// of N a's` `    ``int``[] d = ``new` `int``[n];`   `    ``// Start filling all the` `    ``// N slots for the base 26` `    ``// representation of K` `    ``for` `(``int` `i = n - ``1``; i > -``1``; i--) ` `    ``{`   `        ``// Store the remainder` `        ``d[i] = k % ``26``;`   `        ``// Reduce K` `        ``k /= ``26``;` `    ``}` `    `  `    ``// If K is greater than the` `    ``// possible number of Strings` `    ``// that can be represented by` `    ``// a String of length N` `    ``if` `(k > ``0``)` `        ``return` `"-1"``;`   `    ``String s = ``""``;` `    ``// Store the Kth lexicographical` `    ``// String` `    ``for` `(``int` `i = ``0``; i < n; i++)` `        ``s += (``char``)(d[i] + (``'a'``));`   `    ``return` `s;` `}`   `public` `static` `void` `main(String[] args) ` `{` `    ``int` `n = ``3``;` `    ``int` `k = ``10``;` `    `  `    ``// Reducing k value by 1 because` `    ``// our stored value starts from 0` `    ``k -= ``1``;` `    ``System.out.println(find_kth_String_of_n(n, k));` `}` `}`   `// This code is contributed by PrinciRaj1992`

Python3

 `# Python program to find the` `# K-th lexicographical string` `# of length N` `def` `find_kth_string_of_n(n, k):` `    ``# Initialize the array to` `    ``# store the base 26 ` `    ``# representation of K` `    ``# with all zeroes, that is,` `    ``# the initial string consists ` `    ``# of N a's` `    ``d ``=``[``0` `for` `i ``in` `range``(n)]`   `    ``# Start filling all the ` `    ``# N slots for the base 26` `    ``# representation of K` `    ``for` `i ``in` `range``(n ``-` `1``, ``-``1``, ``-``1``):`   `        ``# Store the remainder` `        ``d[i]``=` `k ``%` `26`   `        ``# Reduce K` `        ``k``/``/``=` `26`   `    ``# If K is greater than the` `    ``# possible number of strings` `    ``# that can be represented by ` `    ``# a string of length N` `    ``if` `k>``0``:` `        ``return` `-``1` `    `  `    `  `    ``s ``=``""` `    ``# Store the Kth lexicographical ` `    ``# string` `    ``for` `i ``in` `range``(n):` `        ``s``+``=` `chr``(d[i]``+``ord``(``'a'``))` `    `  `    ``return` `s     ` `n ``=` `3` `k ``=` `10` `# Reducing k value by 1 because ` `# our stored value starts from 0` `k``-``=` `1` `print``(find_kth_string_of_n(n, k))`

C#

 `// C# program to find the` `// K-th lexicographical String` `// of length N` `using` `System;` `class` `GFG{` `    `  `static` `String find_kth_String_of_n(``int` `n, ``int` `k) ` `{` `    ``// Initialize the array to` `    ``// store the base 26` `    ``// representation of K` `    ``// with all zeroes, that is,` `    ``// the initial String consists` `    ``// of N a's` `    ``int``[] d = ``new` `int``[n];`   `    ``// Start filling all the` `    ``// N slots for the base 26` `    ``// representation of K` `    ``for` `(``int` `i = n - 1; i > -1; i--) ` `    ``{`   `        ``// Store the remainder` `        ``d[i] = k % 26;`   `        ``// Reduce K` `        ``k /= 26;` `    ``}` `    `  `    ``// If K is greater than the` `    ``// possible number of Strings` `    ``// that can be represented by` `    ``// a String of length N` `    ``if` `(k > 0)` `        ``return` `"-1"``;`   `    ``string` `s = ``""``;` `    `  `    ``// Store the Kth lexicographical` `    ``// String` `    ``for` `(``int` `i = 0; i < n; i++)` `        ``s += (``char``)(d[i] + (``'a'``));`   `    ``return` `s;` `}`   `// Driver Code` `public` `static` `void` `Main() ` `{` `    ``int` `n = 3;` `    ``int` `k = 10;` `    `  `    ``// Reducing k value by 1 because` `    ``// our stored value starts from 0` `    ``k -= 1;` `    ``Console.Write(find_kth_String_of_n(n, k));` `}` `}`   `// This code is contributed by Code_Mech`

Javascript

 ``

Output:

`aaj`

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up
Recommended Articles
Page :