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

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

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

    chevron_right

    
    

    Java

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

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

    chevron_right

    
    

    Python3

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    # 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))

    chevron_right

    
    

    C#

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

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

    chevron_right

    
    

    Output:

    aaj
    

    Time Complexity: O(N)

    Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.




    My Personal Notes arrow_drop_up

    Check out this Author's contributed articles.

    If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

    Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.