Find the N-th lexicographic permutation of string using Factoradic method

Given a string str with unique characters and a number N, the task is to find the N-th lexicographic permutation of the string using Factoradic method.

Examples:

Input: str = “abc”, N = 3
Output: bac
Explanation:
All possible permutations in sorted order: abc, acb, bac, bca, cab, cba
3rd permutation is bac

Input: str = “aba”, N = 2
Output: aba
Explanation:
All possible permutations in sorted order: aab, aba, baa
2nd permutation is aba

Approach: The idea is to use the concept of factoradic representation. The main concept of factoradic method is to calculate the sequence of a number. The following are the steps to find the N-th lexicographic permutation using factoradic method:



  1. Decrement N by 1 because this method considers sorted order as the 0th permutation.
  2. Divide N with 1 to the length of the string and each time store the remainder in a stack while updating the value of N as N/i.
  3. The calculated remainder in every step is the factoradic number. So, after calculating the final factoradic representation, start appending the element in the result string which is present on the position.
  4. Remove the element from the stack on each iteration.
  5. Repeat the above three steps until the stack becomes empty.

Lets understand this method with an example. Let the string str be “abcde” and N be 11. Then:

  1. Initially, 1 is subtracted from N.
    N = 11 - 1
    N = 10
    
  2. Now, at every iteration, divide N with i where i ranges from 1 to the length and store the remainder in a stack:
    divide       Remainder    Quotient     Factoradic
    10%1           0            10              0
    10%2           0             5             00
    5%3            2             1            200
    2%4            1             0           1200
    2%5            0             0          01200  
    
  3. Now, append the elements into the resultant string from the stack and continuously remove the elements from the stack. Here, the Factoradic representation of the given number is 01200. Therefore:
    [0]=a   <- Selected
    [1]=b
    [2]=d 
    [3]=e
    [4]=f
    
    result = a
    
    [0]=b
    [1]=c <- Selected
    [2]=d
    [3]=e
    
    result= ac
    
    [0]=b
    [1]=d
    [2]=e <-Selected
    
    result= ace
    
    [0]=b <- Selected
    [1]=d
    
    result= aceb
    
    [0]=d <-selected
    
    result =acebd
    
  4. Therefore, the 11th permutation of the string is “acebd”.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to find the N-th lexicographic
// permutation of string using Factroid method
#include <bits/stdc++.h>
using namespace std;
  
// Function to calculate nth permutation of string
void string_permutation(long long int n, string str)
{
    // Creating an empty stack
    stack<int> s;
    string result;
  
    // Subtracting 1 from N because the
    // permutations start from 0 in
    // factroid method
    n = n - 1;
  
    // Loop to generate the factroid
    // of the sequence
    for (int i = 1; i < str.size() + 1; i++) {
        s.push(n % i);
        n = n / i;
    }
  
    // Loop to generate nth permutation
    for (int i = 0; i < str.size(); i++) {
        int a = s.top();
        result += str[a];
        int j;
  
        // Remove 1-element in each cycle
        for (j = a; j < str.length(); j++)
            str[j] = str[j + 1];
        str[j + 1] = '\0';
        s.pop();
    }
  
    // Final answer
    cout << result << endl;
}
  
// Driver code
int main()
{
    string str = "abcde";
    long long int n = 11;
  
    string_permutation(n, str);
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to find the N-th lexicographic
// permutation of String using Factroid method
import java.util.*;
  
class GFG{
  
// Function to calculate nth permutation of String
static void String_permutation(int n, String str)
{
      
    // Creating an empty stack
    Stack<Integer> s = new Stack<Integer>();
    String result = "";
  
    // Subtracting 1 from N because the
    // permutations start from 0 in
    // factroid method
    n = n - 1;
  
    // Loop to generate the factroid
    // of the sequence
    for(int i = 1; i < str.length() + 1; i++)
    {
       s.add(n % i);
       n = n / i;
    }
  
    // Loop to generate nth permutation
    for(int i = 0; i < str.length(); i++)
    {
       int a = s.peek();
       result += str.charAt(a);
       int j;
         
       // Remove 1-element in each cycle
       for(j = a; j < str.length() - 1; j++)
          str = str.substring(0, j) + 
                str.charAt(j + 1) + 
                str.substring(j + 1);
                  
       str = str.substring(0, j + 1);
       s.pop();
    }
  
    // Final answer
    System.out.print(result + "\n");
}
  
// Driver code
public static void main(String[] args)
{
    String str = "abcde";
    int n = 11;
  
    String_permutation(n, str);
}
}
  
// This code is contributed by sapnasingh4991

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to find the N-th lexicographic
// permutation of String using Factroid method
using System;
using System.Collections.Generic;
  
class GFG{
  
// Function to calculate nth permutation of String
static void String_permutation(int n, String str)
{
      
    // Creating an empty stack
    Stack<int> s = new Stack<int>();
    String result = "";
  
    // Subtracting 1 from N because the
    // permutations start from 0 in
    // factroid method
    n = n - 1;
  
    // Loop to generate the factroid
    // of the sequence
    for(int i = 1; i < str.Length + 1; i++)
    {
       s.Push(n % i);
       n = n / i;
    }
  
    // Loop to generate nth permutation
    for(int i = 0; i < str.Length; i++)
    {
       int a = s.Peek();
       result += str[a];
       int j;
         
       // Remove 1-element in each cycle
       for(j = a; j < str.Length - 1; j++)
       {
          str = str.Substring(0, j) + 
                str[j + 1] + 
                str.Substring(j + 1);
       }
       str = str.Substring(0, j + 1);
       s.Pop();
    }
  
    // Final answer
    Console.Write(result + "\n");
}
  
// Driver code
public static void Main(String[] args)
{
    String str = "abcde";
    int n = 11;
  
    String_permutation(n, str);
}
}
  
// This code is contributed by gauravrajput1

chevron_right


Output:

acebd

Note: An approach to find the Nth permutation with the repeating characters is discussed in this article.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

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

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.