K-th lexicographical string of given length

Last Updated : 05 Jun, 2020

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 = 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.

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 

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.

My Personal Notes

Related Articles

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

C++

Java

Python3

C#