 GeeksforGeeks App
Open App Browser
Continue

# K-th lexicographical string of given length

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