Skip to content
Related Articles
Open in App
Not now

Related Articles

Lexicographically n-th permutation of a string

Improve Article
Save Article
  • Difficulty Level : Easy
  • Last Updated : 12 Jan, 2023
Improve Article
Save Article

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 log n) sort function takes n log n time to execute so the algorithm takes n log n time to complete.
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

This article is contributed by Aarti_Rathi and Shivam Pradhan (anuj_charm). 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. 


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!