# Write a program to print all permutations of a given string

• Difficulty Level : Medium
• Last Updated : 18 Jan, 2022

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! permutation.

Source: Mathword(http://mathworld.wolfram.com/Permutation.html)

Below are the permutations of string ABC.
ABC ACB BAC BCA CBA CAB

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

Here is a solution that is used as a basis in backtracking.

## C++

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

## 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 program to test above functions */``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``{``    ``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

 `# Python 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``+``1``):``            ``a[l], a[i] ``=` `a[i], a[l]``            ``permute(a, l``+``1``, r)``            ``a[l], a[i] ``=` `a[i], a[l] ``# backtrack` `# Driver program to test the above function``string ``=` `"ABC"``n ``=` `len``(string)``a ``=` `list``(string)``permute(a, ``0``, n``-``1``)` `# 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.
Print all distinct permutations of a given string with duplicates.
Permutations of a given string using STL

Another approach:

## C++

 `#include ``#include ``using` `namespace` `std;` `void` `permute(string s , string answer)``{``    ``if``(s.length() == 0)``    ``{``        ``cout<>s;` `    ``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;``    ``String answer=``""``;``    ` `    ``System.out.print(``"Enter the string : "``);``    ``s = scan.next();``    ` `    ``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 ``=` `input``(``"Enter the string : "``)` `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;``    ``String answer=``""``;``    ` `    ``Console.Write(``"Enter the string : "``);``    ``s = Console.ReadLine();``    ` `    ``Console.Write(``"\nAll possible strings are : "``);``    ``permute(s, answer);``}``}` `// This code is contributed by gauravrajput1`

## Javascript

 ``
```Output:
Enter the string : abc
All possible strings are : abc  acb  bac  bca  cab  cba```

Time Complexity: O(n*n!) The time complexity is the same as the above approach, 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