Distinct permutations of the string | Set 2 - GeeksforGeeks

17 Apr, 2022
Print all distinct permutations of a string having duplicates.
Examples:  
Input : ABCA
Output : AABC AACB ABAC ABCA ACBA 
         ACAB BAAC BACA BCAA CABA 
         CAAB CBAA
An algorithm to print all distinct permutations has already been discussed here. Here we’ll discuss one more approach to do the same. Recall first how we print permutations without any duplicates in the input string. It is given here. Let’s now take the case of the string “ABAC”. While generating permutations, let’s say we are at index = 0, swap it with all elements after it. When we reach i=2, we see that in the string s[index...i-1], there was an index that is equal to s[i]. Thus, swapping it will produce repeated permutations. Thus, we don’t swap it. The below explains it better.
Illustration: Let us understand with the below example. 
i = 0 1 2 3
    A B A C
index = 0, s[0] = A
Start swapping s[index] with s[i] following it:
i = index + 1 = 1 

Since s[index] != s[i], swap and recur.

i = 2, s[index] == s[i], don't swap

i = 3,  s[index] != s[i], swap and recur. 
Below code does the same. 
C++
C
Java
Python3
C#
Javascript
// C++ program to distinct permutations of the string#include <bits/stdc++.h>using namespace std; // Returns true if str[curr] does not matches with any of the// characters after str[start]bool shouldSwap(char str[], int start, int curr){    for (int i = start; i < curr; i++)        if (str[i] == str[curr])            return 0;    return 1;} // Prints all distinct permutations in str[0..n-1]void findPermutations(char str[], int index, int n){    if (index >= n) {        cout << str << endl;        return;    }     for (int i = index; i < n; i++) {         // Proceed further for str[i] only if it        // doesn't match with any of the characters        // after str[index]        bool check = shouldSwap(str, index, i);        if (check) {            swap(str[index], str[i]);            findPermutations(str, index + 1, n);            swap(str[index], str[i]);        }    }} // Driver codeint main(){    char str[] = "ABCA";    int n = strlen(str);    findPermutations(str, 0, n);    return 0;} // This code is contributed by Aditya Kumar (adityakumar129)
// C program to distinct permutations of the string#include <stdbool.h>#include <stdio.h>#include <string.h> // Returns true if str[curr] does not matches with any of// the characters after str[start]bool shouldSwap(char str[], int start, int curr){    for (int i = start; i < curr; i++)        if (str[i] == str[curr])            return 0;    return 1;} // Prints all distinct permutations in str[0..n-1]void findPermutations(char str[], int index, int n){    if (index >= n) {        printf("%s\n", str);        return;    }     for (int i = index; i < n; i++) {         // Proceed further for str[i] only if it        // doesn't match with any of the characters        // after str[index]        bool check = shouldSwap(str, index, i);        if (check) {            // Swapping the str[index] with str[i]            char temp = str[index];            str[index] = str[i];            str[i] = temp;            findPermutations(str, index + 1, n);            // Swapping the str[index] with str[i]            temp = str[index];            str[index] = str[i];            str[i] = temp;        }    }} // Driver codeint main(){    char str[] = "ABCA";    int n = strlen(str);    findPermutations(str, 0, n);    return 0;} // This code is contributed by Aditya Kumar (adityakumar129)
// Java program to distinct permutations of the stringpublic class GFG { // Returns true if str[curr] does not matches with any of the// characters after str[start]    static boolean shouldSwap(char str[], int start, int curr) {        for (int i = start; i < curr; i++) {            if (str[i] == str[curr]) {                return false;            }        }        return true;    } // Prints all distinct permutations in str[0..n-1]    static void findPermutations(char str[], int index, int n) {        if (index >= n) {            System.out.println(str);            return;        }         for (int i = index; i < n; i++) {             // Proceed further for str[i] only if it            // doesn't match with any of the characters            // after str[index]            boolean check = shouldSwap(str, index, i);            if (check) {                swap(str, index, i);                findPermutations(str, index + 1, n);                swap(str, index, i);            }        }    }     static void swap(char[] str, int i, int j) {        char c = str[i];        str[i] = str[j];        str[j] = c;    }     // Driver code    public static void main(String[] args) {         char str[] = {'A', 'B', 'C', 'A'};        int n = str.length;        findPermutations(str, 0, n);    } }
# Python3 program to distinct# permutations of the string # Returns true if str[curr] does not# matches with any of the characters# after str[start]def shouldSwap(string, start, curr):     for i in range(start, curr):        if string[i] == string[curr]:            return 0    return 1 # Prints all distinct permutations# in str[0..n-1]def findPermutations(string, index, n):     if index >= n:        print(''.join(string))        return     for i in range(index, n):         # Proceed further for str[i] only        # if it doesn't match with any of        # the characters after str[index]        check = shouldSwap(string, index, i)        if check:            string[index], string[i] = string[i], string[index]            findPermutations(string, index + 1, n)            string[index], string[i] = string[i], string[index] # Driver codeif __name__ == "__main__":     string = list("ABCA")    n = len(string)    findPermutations(string, 0, n)     # This code is contributed by Rituraj Jain
// C# program to distinct permutations// of the stringusing System; class GFG{ // Returns true if str[curr] does// not matches with any of the// characters after str[start]static bool shouldSwap(char []str,                       int start, int curr){    for (int i = start; i < curr; i++)    {        if (str[i] == str[curr])        {            return false;        }    }    return true;} // Prints all distinct permutations// in str[0..n-1]static void findPermutations(char []str,                             int index, int n){    if (index >= n)    {        Console.WriteLine(str);        return;    }     for (int i = index; i < n; i++)    {         // Proceed further for str[i] only        // if it doesn't match with any of        // the characters after str[index]        bool check = shouldSwap(str, index, i);        if (check)        {            swap(str, index, i);            findPermutations(str, index + 1, n);            swap(str, index, i);        }    }} static void swap(char[] str, int i, int j){    char c = str[i];    str[i] = str[j];    str[j] = c;} // Driver codepublic static void Main(){    char []str = {'A', 'B', 'C', 'A'};    int n = str.Length;    findPermutations(str, 0, n);}} // This code is contributed// by 29AjayKumar
<script> // Javascript program to distinct permutations of the string // Returns true if str[curr] does not matches with any of the// characters after str[start]    function shouldSwap(str, start, curr) {        for (let i = start; i < curr; i++) {            if (str[i] == str[curr]) {                return false;            }        }        return true;    }  // Prints all distinct permutations in str[0..n-1]    function findPermutations(str, index, n) {        if (index >= n) {            document.write(str);            document.write("<br/>")            return;        }                   for (let i = index; i < n; i++) {              // Proceed further for str[i] only if it            // doesn't match with any of the characters            // after str[index]            let check = shouldSwap(str, index, i);            if (check) {                swap(str, index, i);                findPermutations(str, index + 1, n);                swap(str, index, i);            }        }    }      function swap(str, i, j) {        let c = str[i];        str[i] = str[j];        str[j] = c;    }     // Driver code         let str = ['A', 'B', 'C', 'A'];        let n = str.length;        findPermutations(str, 0, n);                       </script>
ABCA
ABAC
ACBA
ACAB
AACB
AABC
BACA
BAAC
BCAA
CBAA
CABA
CAAB
Better Approach:
Generate all distinct strings is to simply use some if conditions. The technique above uses an extra loop inside the recursion which causes a major time complexity cost. Instead, we can improve it by little pre-processing. We first sort the given string and then apply the below code.
Below is the implementation of the above idea:
C++
Java
Python3
Javascript
// C++ program to print all the permutation// of the given string.#include <algorithm>#include <iostream>#include <string>using namespace std; // count of total permutationsint total = 0; void permute(int i, string s){    // base case    if (i == (s.length() - 1)) {        cout << s << endl;        total++;        return;    }       char prev = '*';       // loop from j = 1 to length of string    for (int j = i; j < s.length(); j++) {        string temp = s;        if (j > i && temp[i] == temp[j])            continue;        if (prev != '*' && prev == s[j]) {            continue;        }               // swap the elements        swap(temp[i], temp[j]);        prev = s[j];               // recursion call        permute(i + 1, temp);    }} // Driver codeint main(){    string s = "abca";         // sort    sort(s.begin(), s.end());       // Function call    permute(0, s);    cout << "Total distinct permutations = " << total         << endl;    return 0;} // This code is contributed by risingStark.
// Java program to print all the permutation// of the given String.//include <algorithm> //include <String>import java.util.*; class GFG{ // Count of total permutationsstatic int total = 0; static void permute(int i, String s){         // Base case    if (i == (s.length() - 1))    {        System.out.print(s + "\n");        total++;        return;    }       char prev = '*';       // Loop from j = 1 to length of String    for(int j = i; j < s.length(); j++)    {        char []temp = s.toCharArray();        if (j > i && temp[i] == temp[j])            continue;        if (prev != '*' && prev == s.charAt(j))        {            continue;        }               // Swap the elements        temp = swap(temp,i,j);        prev = s.charAt(j);               // Recursion call        permute(i + 1, String.valueOf(temp));    }} static char[] swap(char []arr, int i, int j){    char temp = arr[i];    arr[i] = arr[j];    arr[j] = temp;    return arr;} static String sortString(String inputString){         // Convert input string to char array    char tempArray[] = inputString.toCharArray();           // Sort tempArray    Arrays.sort(tempArray);           // Return new sorted string    return new String(tempArray);} // Driver codepublic static void main(String[] args){    String s = "abca";         // Sort    s = sortString(s);       // Function call    permute(0, s);    System.out.print("Total distinct permutations = " +                     total +"\n");}} // This code is contributed by Amit Katiyar
# Python program to print all the permutation# of the given String. # Count of total permutationstotal = 0 def swap(arr, i, j):    temp = arr[i]    arr[i] = arr[j]    arr[j] = temp    return arr def permute(i, s):    global total     # Base case    if(i == (len(s) - 1)):        print(s)        total += 1        return         prev = '*'         # Loop from j = 1 to length of String    for j in range(i,len(s)):        temp = list(s)        if (j > i and temp[i] == temp[j]):            continue        if (prev != '*' and prev == s[j]):            continue                 # Swap the elements        temp = swap(temp,i,j)        prev = s[j]                 # Recursion call        permute(i + 1, "".join(temp)) def sortString(inputString):     # Convert input string to char array    tempArray = list(inputString)             # Sort tempArray    tempArray.sort()             # Return new sorted string    return "".join(tempArray) # Driver codes = "abca" # Sorts = sortString(s) # Function callpermute(0, s)print(f"Total distinct permutations = {total}") # This code is contributed by shinjanpatra
<script> // JavaScript program to print all the permutation// of the given String.  // Count of total permutationslet total = 0;function permute(i,s){    // Base case    if (i == (s.length - 1))    {        document.write(s + "<br>");        total++;        return;    }        let prev = '*';        // Loop from j = 1 to length of String    for(let j = i; j < s.length; j++)    {        let temp = s.split("");        if (j > i && temp[i] == temp[j])            continue;        if (prev != '*' && prev == s[j])        {            continue;        }                // Swap the elements        temp = swap(temp,i,j);        prev = s[j];                // Recursion call        permute(i + 1, (temp).join(""));    }} function swap(arr,i,j){    let temp = arr[i];    arr[i] = arr[j];    arr[j] = temp;    return arr;} function sortString(inputString){    // Convert input string to char array    let tempArray = inputString.split("");            // Sort tempArray    (tempArray).sort();            // Return new sorted string    return (tempArray).join("");} // Driver codelet s = "abca"; // Sorts = sortString(s); // Function callpermute(0, s);document.write("Total distinct permutations = " +                 total +"<br>");  // This code is contributed by rag2127 </script>
aabc
aacb
abac
abca
acba
acab
baac
baca
bcaa
caba
caab
cbaa
Total distinct permutations = 12
Time complexity: If we take the length of the string to be N, then the complexity of my code will be O(N log N) for sorting and O(N*N!) for the permutation. Total time complexity would be O(N log N + N*N!) which is effectively only O(N*N!).
sadiqRaza
Rajput-Ji
29AjayKumar
rituraj_jain
shreyashagrawal
risingStark
susmitakundugoaldanga
amit143katiyar
rag2127
shinjanpatra
adityakumar129
Combinatorial
Strings
Strings
Combinatorial
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Find the Number of Permutations that satisfy the given condition in an array
Python program to get all subsets of given size of a set
Print all subsets of given size of a set
Find all distinct subsets of a given set using BitMasking Approach
Make all combinations of size k
Reverse a string in Java
Write a program to reverse an array or string
Longest Common Subsequence | DP-4
C++ Data Types
Python program to check if a string is palindrome or not