# Lexicographically n-th permutation of a string

• Difficulty Level : Easy
• Last Updated : 12 Jan, 2023

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