Skip to content
Related Articles

Related Articles

K-th lexicographical string of given length

View Discussion
Improve Article
Save Article
Like Article
  • Difficulty Level : Medium
  • Last Updated : 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++




// 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 contributed by mukesh07.
</script>

Output: 

aaj

 

Time Complexity: O(N)
Auxiliary Space: O(N)


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!