Related Articles
K-th lexicographical string of given length
• Last Updated : 05 Jun, 2020

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.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 `

Output:

```aaj
```

Time Complexity: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up
Recommended Articles
Page :