Lexicographically n-th permutation of a string

Given a string of length m containing lowercase alphabets only. You have to find the n-th permutation of string lexicographically. 

Examples:

Input : str[] = "abc", n = 3
Output : Result = "bac"
Explanation : All possible permutation in
sorted order: abc, acb, bac, bca, cab, cba

Input : str[] = "aba", n = 2
Output : Result = "aba"
Explanation : All possible permutation
in sorted order: aab, aba, baa

Prerequisite : Permutations of a given string using STL Idea behind printing n-th permutation is quite simple we should use STL (explained in above link) for finding next permutation and do it till the nth permutation. After n-th iteration, we should break from the loop and then print the string which is our nth permutation.

    long int i = 1;
    do
    {
        // check for nth iteration
        if (i == n)
            break;
       i++; // keep incrementing the iteration
    } while (next_permutation(str.begin(), str.end()));

    // print string after nth iteration
   print str;

Implementation:

C++

// C++ program to print nth permutation with
// using next_permute()
#include <bits/stdc++.h>
using namespace std;

// Function to print nth permutation
// using next_permute()
void nPermute(string str, long int n)
{
    // Sort the string in lexicographically
    // ascending order
    sort(str.begin(), str.end());

    // Keep iterating until
    // we reach nth position
    long int i = 1;
    do {
        // check for nth iteration
        if (i == n)
            break;

        i++;
    } while (next_permutation(str.begin(), str.end()));

    // print string after nth iteration
    cout << str;
}

// Driver code
int main()
{
    string str = "GEEKSFORGEEKS";
    long int n = 100;
    nPermute(str, n);
    return 0;
}

Java

// Java program to print nth permutation with
// using next_permute()
import java.util.*;

class GFG
{

// Function to print nth permutation
// using next_permute()
static void nPermute(char[] str, int n)
{
    // Sort the string in lexicographically
    // ascending order
    Arrays.sort(str);

    // Keep iterating until
    // we reach nth position
    int i = 1;
    do {
        // check for nth iteration
        if (i == n)
            break;

        i++;
    } while (next_permutation(str));

    // print string after nth iteration
    System.out.println(String.valueOf(str));
}

static boolean next_permutation(char[] p)
{
    for (int a = p.length - 2; a >= 0; --a)
        if (p[a] < p[a + 1])
        for (int b = p.length - 1;; --b)
            if (p[b] > p[a])
            {
                char t = p[a];
                p[a] = p[b];
                p[b] = t;
                for (++a, b = p.length - 1; a < b; ++a, --b)
                {
                    t = p[a];
                    p[a] = p[b];
                    p[b] = t;
                }
                return true;
            }
    return false;
}

// Driver code
public static void main(String[] args)
{
    String str = "GEEKSFORGEEKS";
    int n = 100;
    nPermute(str.toCharArray(), n);
}
}

// This code contributed by Rajput-Ji

Python3

# Python3 program to print nth permutation
# with using next_permute()

# next_permutation method implementation
def next_permutation(L):
    n = len(L)
    i = n - 2
    while i >= 0 and L[i] >= L[i + 1]:
        i -= 1

    if i == -1:
        return False

    j = i + 1
    while j < n and L[j] > L[i]:
        j += 1
    j -= 1

    L[i], L[j] = L[j], L[i]

    left = i + 1
    right = n - 1

    while left < right:
        L[left], L[right] = L[right], L[left]
        left += 1
        right -= 1

    return True

# Function to print nth permutation
# using next_permute()
def nPermute(string, n):
    string = list(string)
    new_string = []

    # Sort the string in lexicographically
    # ascending order
    string.sort()
    j = 2

    # Keep iterating until
    # we reach nth position
    while next_permutation(string):
        new_string = string

        # check for nth iteration
        if j == n:
            break
        j += 1

    # print string after nth iteration
    print(''.join(new_string))

# Driver Code
if __name__ == "__main__":
    string = "GEEKSFORGEEKS"
    n = 100
    nPermute(string, n)

# This code is contributed by
# sanjeev2552

C#

// C# program to print nth permutation with
// using next_permute()
using System;

class GFG
{

// Function to print nth permutation
// using next_permute()
static void nPermute(char[] str, int n)
{
    // Sort the string in lexicographically
    // ascending order
    Array.Sort(str);

    // Keep iterating until
    // we reach nth position
    int i = 1;
    do
    {
        // check for nth iteration
        if (i == n)
            break;

        i++;
    } while (next_permutation(str));

    // print string after nth iteration
    Console.WriteLine(String.Join("",str));
}

static bool next_permutation(char[] p)
{
    for (int a = p.Length - 2; a >= 0; --a)
        if (p[a] < p[a + 1])
        for (int b = p.Length - 1;; --b)
            if (p[b] > p[a])
            {
                char t = p[a];
                p[a] = p[b];
                p[b] = t;
                for (++a, b = p.Length - 1; a < b; ++a, --b)
                {
                    t = p[a];
                    p[a] = p[b];
                    p[b] = t;
                }
                return true;
            }
    return false;
}

// Driver code
public static void Main()
{
    String str = "GEEKSFORGEEKS";
    int n = 100;
    nPermute(str.ToCharArray(), n);
}
}

/* This code contributed by PrinciRaj1992 */

Javascript

// next_permutation method implementation
function nextPermutation(L) {
  let n = L.length;
  let i = n - 2;
  while (i >= 0 && L[i] >= L[i + 1]) {
    i--;
  }

  if (i === -1) {
    return false;
  }

  let j = i + 1;
  while (j < n && L[j] > L[i]) {
    j++;
  }
  j--;

  [L[i], L[j]] = [L[j], L[i]];

  let left = i + 1;
  let right = n - 1;

  while (left < right) {
    [L[left], L[right]] = [L[right], L[left]];
    left++;
    right--;
  }

  return true;
}

// Function to print nth permutation
// using next_permute()
function nPermute(string, n) {
  let newString = [];

  // Sort the string in lexicographically
  // ascending order
  string = string.split("").sort().join("");
  let j = 2;

  // Keep iterating until
  // we reach nth position
  while (nextPermutation(string.split(""))) {
    newString = string.split("");

    // check for nth iteration
    if (j === n) {
      break;
    }
    j++;
  }

  // print string after nth iteration
  console.log(newString.join(""));
}

// Driver Code
let string = "GEEKSFORGEEKS";
let n = 100;
nPermute(string, n);
// This code is contributed by Shivam Tiwari

Output

EEEEFGGRKSOSK

Time Complexity: O(n + |S| log |S|) Sorting S is log-linear time. `next_permutation` has constant time amortized complexity, however n is independent of |S|, so it is still necessary to include it in the final time complexity notation to properly reflect growth of running time.
Auxiliary Space: O(1) since no extra array is used space occupied by the algorithm is constant

Find n-th lexicographically permutation of a string | Set 2

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