K-th lexicographical string of given length

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.

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)