Write a program to print all Permutations of given String

Given a string S, the task is to write a program to print all permutations of a given string. 

A permutation also called an “arrangement number” or “order,” is a rearrangement of the elements of an ordered list S into a one-to-one correspondence with S itself. A string of length N has N! permutations. 

Examples:

Input: S = “ABC”
Output: “ABC”, “ACB”, “BAC”, “BCA”, “CBA”, “CAB”

Input: S = “XY”
Output: “XY”, “YX”

Print permutations of a given string using backtracking:

Follow the given steps to solve the problem:

• Create a function permute() with parameters as input string, starting index of the string, ending index of the string
• Call this function with values input string, 0, size of string – 1
  • In this function, if the value of  L and R is the same then print the same string
    • Else run a for loop from L to R and swap the current element in the for loop with the inputString[L]
    • Then again call this same function by increasing the value of L by 1
    • After that again swap the previously swapped values to initiate backtracking

Below is the implementation of the above approach:

C++14

// C++ program to print all
// permutations with duplicates allowed
#include <bits/stdc++.h>
using namespace std;

// Function to print permutations of string
// This function takes three parameters:
// 1. String
// 2. Starting index of the string
// 3. Ending index of the string.
void permute(string& a, int l, int r)
{
    // Base case
    if (l == r)
        cout << a << endl;
    else {
        // Permutations made
        for (int i = l; i <= r; i++) {

            // Swapping done
            swap(a[l], a[i]);

            // Recursion called
            permute(a, l + 1, r);

            // backtrack
            swap(a[l], a[i]);
        }
    }
}

// Driver Code
int main()
{
    string str = "ABC";
    int n = str.size();

    // Function call
    permute(str, 0, n - 1);
    return 0;
}

// This is code is contributed by rathbhupendra

C

// C program to print all permutations with duplicates
// allowed
#include <stdio.h>
#include <string.h>

/* Function to swap values at two pointers */
void swap(char* x, char* y)
{
    char temp;
    temp = *x;
    *x = *y;
    *y = temp;
}

/* Function to print permutations of string
This function takes three parameters:
1. String
2. Starting index of the string
3. Ending index of the string. */
void permute(char* a, int l, int r)
{
    int i;
    if (l == r)
        printf("%s\n", a);
    else {
        for (i = l; i <= r; i++) {
            swap((a + l), (a + i));
            permute(a, l + 1, r);
            swap((a + l), (a + i)); // backtrack
        }
    }
}

/* Driver code */
int main()
{
    char str[] = "ABC";
    int n = strlen(str);
    permute(str, 0, n - 1);
    return 0;
}

Java

// Java program to print all permutations of a
// given string.
public class Permutation {

    // Function call
    public static void main(String[] args)
    {
        String str = "ABC";
        int n = str.length();
        Permutation permutation = new Permutation();
        permutation.permute(str, 0, n - 1);
    }

    /**
     * permutation function
     * @param str string to calculate permutation for
     * @param l starting index
     * @param r end index
     */
    private void permute(String str, int l, int r)
    {
        if (l == r)
            System.out.println(str);
        else {
            for (int i = l; i <= r; i++) {
                str = swap(str, l, i);
                permute(str, l + 1, r);
                str = swap(str, l, i);
            }
        }
    }

    /**
     * Swap Characters at position
     * @param a string value
     * @param i position 1
     * @param j position 2
     * @return swapped string
     */
    public String swap(String a, int i, int j)
    {
        char temp;
        char[] charArray = a.toCharArray();
        temp = charArray[i];
        charArray[i] = charArray[j];
        charArray[j] = temp;
        return String.valueOf(charArray);
    }
}

// This code is contributed by Mihir Joshi

Python3

# Python3 program to print all permutations with
# duplicates allowed


def toString(List):
    return ''.join(List)

# Function to print permutations of string
# This function takes three parameters:
# 1. String
# 2. Starting index of the string
# 3. Ending index of the string.


def permute(a, l, r):
    if l == r:
        print(toString(a))
    else:
        for i in range(l, r):
            a[l], a[i] = a[i], a[l]
            permute(a, l+1, r)
            a[l], a[i] = a[i], a[l]  # backtrack


# Driver code
string = "ABC"
n = len(string)
a = list(string)

# Function call
permute(a, 0, n)

# This code is contributed by Bhavya Jain

C#

// C# program to print all
// permutations of a given string.
using System;

class GFG {
    /**
    * permutation function
    * @param str string to
    calculate permutation for
    * @param l starting index
    * @param r end index
    */
    private static void permute(String str, int l, int r)
    {
        if (l == r)
            Console.WriteLine(str);
        else {
            for (int i = l; i <= r; i++) {
                str = swap(str, l, i);
                permute(str, l + 1, r);
                str = swap(str, l, i);
            }
        }
    }

    /**
     * Swap Characters at position
     * @param a string value
     * @param i position 1
     * @param j position 2
     * @return swapped string
     */
    public static String swap(String a, int i, int j)
    {
        char temp;
        char[] charArray = a.ToCharArray();
        temp = charArray[i];
        charArray[i] = charArray[j];
        charArray[j] = temp;
        string s = new string(charArray);
        return s;
    }

    // Driver Code
    public static void Main()
    {
        String str = "ABC";
        int n = str.Length;
        permute(str, 0, n - 1);
    }
}

// This code is contributed by mits

PHP

<?php
// PHP program to print all
// permutations of a given string.


/**
* permutation function
* @param str string to
* calculate permutation for
* @param l starting index
* @param r end index
*/
function permute($str, $l, $r)
{
    if ($l == $r)
        echo $str. "\n";
    else
    {
        for ($i = $l; $i <= $r; $i++)
        {
            $str = swap($str, $l, $i);
            permute($str, $l + 1, $r);
            $str = swap($str, $l, $i);
        }
    }
}

/**
* Swap Characters at position
* @param a string value
* @param i position 1
* @param j position 2
* @return swapped string
*/
function swap($a, $i, $j)
{
    $temp;
    $charArray = str_split($a);
    $temp = $charArray[$i] ;
    $charArray[$i] = $charArray[$j];
    $charArray[$j] = $temp;
    return implode($charArray);
}

// Driver Code
$str = "ABC";
$n = strlen($str);
permute($str, 0, $n - 1);

// This code is contributed by mits.
?>

Javascript

<script>
// Javascript program to print all permutations of a
// given string.

function permute(str, l, r)
{
    if (l == r)
            document.write(str+"<br>");
        else
        {
            for (let i = l; i <= r; i++)
            {
                str = swap(str, l, i);
                permute(str, l + 1, r);
                str = swap(str, l, i);
            }
        }
}

function swap(a, i, j)
{
    let temp;
let charArray = a.split("");
temp = charArray[i] ;
charArray[i] = charArray[j];
charArray[j] = temp;
return (charArray).join("");
}

let str = "ABC";
let n = str.length;
permute(str, 0, n-1);

// This code is contributed by avanitrachhadiya2155
</script>

Output

ABC
ACB
BAC
BCA
CBA
CAB

Time Complexity: O(N * N!) Note that there are N! permutations and it requires O(N) time to print a permutation.
Auxiliary Space: O(R – L)

Note: The above solution prints duplicate permutations if there are repeating characters in the input string. Please see the below link for a solution that prints only distinct permutations even if there are duplicates in input.

• Print all distinct permutations of a given string with duplicates.
• Permutations of a given string using STL

Another approach by concatenating Substrings:

Follow the below idea:

• Create a recursive function and pass the input string and a string that stores the permutation (which is initially empty when called from the main function).
• If the length of the string is 0, print the permutation.
• Otherwise, run a loop from i = 0 to N:
  • Consider S[i], to be a part of the permutation.
  • Remove this from the current string and append it to the end of the permutation.
  • Call the recursive function with the current string which does not contain S[i] and the current permutation.

Below is the implementation of this approach:

C++

// C++ program for the above approach

#include <bits/stdc++.h>
using namespace std;

void permute(string s, string answer)
{
    if (s.length() == 0) {
        cout << answer << "  ";
        return;
    }
    for (int i = 0; i < s.length(); i++) {
        char ch = s[i];
        string left_substr = s.substr(0, i);
        string right_substr = s.substr(i + 1);
        string rest = left_substr + right_substr;
        permute(rest, answer + ch);
    }
}

// Driver code
int main()
{
    string s = "ABC";
    string answer = "";

    cout << "\nAll possible strings are : ";
    permute(s, answer);
    return 0;
}

Java

import java.util.*;

class GFG {

    static void permute(String s, String answer)
    {
        if (s.length() == 0) {
            System.out.print(answer + "  ");
            return;
        }

        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            String left_substr = s.substring(0, i);
            String right_substr = s.substring(i + 1);
            String rest = left_substr + right_substr;
            permute(rest, answer + ch);
        }
    }

    // Driver code
    public static void main(String args[])
    {
        Scanner scan = new Scanner(System.in);

        String s = "ABC";
        String answer = "";

        System.out.print("\nAll possible strings are : ");
        permute(s, answer);
    }
}

// This code is contributed by adityapande88

Python3

def permute(s, answer):
    if (len(s) == 0):
        print(answer, end="  ")
        return

    for i in range(len(s)):
        ch = s[i]
        left_substr = s[0:i]
        right_substr = s[i + 1:]
        rest = left_substr + right_substr
        permute(rest, answer + ch)


# Driver Code
answer = ""

s = "ABC"

print("All possible strings are : ")
permute(s, answer)

# This code is contributed by Harshit Srivastava

C#

using System;

public class GFG {

    static void permute(String s, String answer)
    {
        if (s.Length == 0) {
            Console.Write(answer + "  ");
            return;
        }

        for (int i = 0; i < s.Length; i++) {
            char ch = s[i];
            String left_substr = s.Substring(0, i);
            String right_substr = s.Substring(i + 1);
            String rest = left_substr + right_substr;
            permute(rest, answer + ch);
        }
    }

    // Driver code
    public static void Main(String[] args)
    {

        String s = "ABC";
        String answer = "";

        Console.Write("\nAll possible strings are : ");
        permute(s, answer);
    }
}

// This code is contributed by gauravrajput1

Javascript

<script>
    // JavaScript Program to implement
    // the above approach
function permute(s , answer)
{
    if (s.length == 0)
    {
        document.write(answer + "  ");
    }

    for(let i = 0 ;i < s.length; i++)
    {
        let ch = s[i];
        let left_substr = s.slice(0, i);
        let right_substr = s.slice(i + 1);
        let rest = left_substr + right_substr;
        permute(rest, answer + ch);
    }
}

    // Driver Cod"e
    let s= "abc";
    let answer="";

    document.write("Enter the string  : ");

    document.write("\nAll possible string are : ");
    permute(s, answer);

// This code is contributed by code_hunt.
</script>

Output

All possible strings are : ABC  ACB  BAC  BCA  CAB  CBA  

Time Complexity: O(N * N!) i.e. there are N! permutations and it requires O(N) time to print a permutation.
Auxiliary Space: O(|S|)

Another approach by using itertools package(Python):

By using this package we can find permutations with help of permutations() function.

To know more about itertools click here.

• Import itertools package for permutations function
• Convert the string into individual elements
• Find all the permutations by passing the list into and function
• Print the permutations by iterating the object.

Python3

# A Python program to print all permutations of given string
# Importing package
from itertools import permutations

#Taking input
string = "ABC"

# Converitng into iterable object to pass in the function
string = list(string)
permu = permutations(string, 3)

# Printing all the permutations
# Using join function to join the string

for i in list(permu):
  print("".join(i))

Javascript

// install the package js-combinatorics by using the
// npm package manager

// A JavaScript program to print all permutations of given string

// Importing package
const permutations = require('js-combinatorics').permutations;

// Taking input
let string = "ABC";

// Converting into iterable object to pass in the function
string = string.split('');
const permu = permutations(string, 3);

// Printing all the permutations
// Using join function to join the string
for (let i of permu) {
  console.log(i.join(''));
}

Output

ABC
ACB
BAC
BCA
CAB
CBA

Time Complexity: O(n!) where n is the size of the string.
Auxiliary Space: O(n*n!) 

Another Approach Using Inbuilt STL function:

By using next_permutation() inbuilt stl function we can generate permuation of string.

To know more about it

C++

#include <bits/stdc++.h>
using namespace std;

int main()
{
    string s = "ABC";
    sort(s.begin(), s.end());
    do {
        cout << s << endl;
    } while (next_permutation(s.begin(), s.end()));
    return 0;
}

Python3

# This code generates all possible permutations of a given string

import itertools

s = "ABC"

# Sort the characters of the string in ascending order
s_sorted = sorted(s)

# Generate all permutations of the sorted string
permutations = itertools.permutations(s_sorted)
# Print each permutation
for perm in permutations:
    print(''.join(perm))

Output

ABC
ACB
BAC
BCA
CAB
CBA

Time Complexity: O(N*N!)  i.e. there are N! permutations and it requires O(N) time to print a permutation. 

Space Complexity: O(|S|)

Please write comments if you find the above codes/algorithms incorrect, or find other ways to solve the same problem.