# Write a program to print all Permutations of given String

• Difficulty Level : Medium
• Last Updated : 06 Dec, 2022

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 ` `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 ` `#include `   `/* 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

 ``

## Javascript

 ``

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.

Another approach by concatenating Substrings:

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

 ``

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

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

My Personal Notes arrow_drop_up
Related Articles