Given two integers **N** and **K**, the task is to find **lexicographically** **K ^{th}** string of length

**N**. If the number of possible strings of length

**N**is less than

**K**, print

**-1**.

**Examples:**

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

**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 <bits/stdc++.h>` `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

`<script>` ` ` `// Javascript program to find the` ` ` `// K-th lexicographical String` ` ` `// of length N` ` ` ` ` `function` `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` ` ` `let d = ` `new` `Array(n);` ` ` `d.fill(0);` ` ` `// Start filling all the` ` ` `// N slots for the base 26` ` ` `// representation of K` ` ` `for` `(let i = n - 1; i > -1; i--)` ` ` `{` ` ` `// Store the remainder` ` ` `d[i] = k % 26;` ` ` `// Reduce K` ` ` `k = parseInt(k / 26, 10);` ` ` `}` ` ` `// 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"` `;` ` ` `let s = ` `""` `;` ` ` `// Store the Kth lexicographical` ` ` `// String` ` ` `for` `(let i = 0; i < n; i++)` ` ` `s += String.fromCharCode(d[i] + ('a').charCodeAt());` ` ` `return` `s;` ` ` `}` ` ` ` ` `let n = 3;` ` ` `let k = 10;` ` ` ` ` `// Reducing k value by 1 because` ` ` `// our stored value starts from 0` ` ` `k -= 1;` ` ` `document.write(find_kth_String_of_n(n, k));` `// This code is cotributed by mukesh07.` `</script>` |

**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**