Skip to content
Related Articles

Related Articles

Improve Article
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 <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




My Personal Notes arrow_drop_up
Recommended Articles
Page :