K-th lexicographical string of given length

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++
Java
Python3
C#
Javascript
// 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 Codeint 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 program to find the// K-th lexicographical String// of length Nclass 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
# Python program to find the# K-th lexicographical string# of length Ndef 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 = 3k = 10# Reducing k value by 1 because# our stored value starts from 0k-= 1print(find_kth_string_of_n(n, k))
// C# program to find the// K-th lexicographical String// of length Nusing 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 Codepublic 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
<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 contributed by mukesh07.</script>
aaj
 
Time Complexity: O(N)Auxiliary Space: O(N)
princiraj1992
Code_Mech
29AjayKumar
mukesh07
simmytarika5
pankajsharmagfg
lexicographic-ordering
Algorithms
Mathematical
Strings
Strings
Mathematical
Algorithms
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
DSA Sheet by Love Babbar
SDE SHEET - A Complete Guide for SDE Preparation
What is Hashing | A Complete Tutorial
Understanding Time Complexity with Simple Examples
CPU Scheduling in Operating Systems
Program for Fibonacci numbers
Set in C++ Standard Template Library (STL)
Write a program to print all permutations of a given string
C++ Data Types
Merge two sorted arrays