# Lexicographically n-th permutation of a string

Last Updated : 03 May, 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 + |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

Previous
Next