Skip to content
Related Articles
K-th lexicographical string of given length
• Last Updated : 16 Jun, 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)

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up