Write a  program to print all permutations of a given string


07 Jul, 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: Mathworld(http://mathworld.wolfram.com/Permutation.html)
Chapters
descriptions off, selected
captions settings, opens captions settings dialog
captions off, selected
English
This is a modal window.
Beginning of dialog window. Escape will cancel and close the window.
End of dialog window.
Below are the permutations of string ABC. ABC ACB BAC BCA CBA CAB
Here is a solution that is used as a basis in backtracking.
C++14
C
Java
Python3
C#
PHP
Javascript
 

 
 










// 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();  
    permute(str, 0, n-1);  
    return 0;  
}  
  
// This is code is contributed by rathbhupendra  






 

 
 










// 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 program to test above functions */
int main()  
{  
    char str[] = "ABC";  
    int n = strlen(str);  
    permute(str, 0, n-1);  
    return 0;  
}  






 

 
 










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






 

 
 










# 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):  
            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)  
  
# This code is contributed by Bhavya Jain  






 

 
 










// 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 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.  
?>  






 

 
 










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






ABC
ACB
BAC
BCA
CBA
CAB

Algorithm Paradigm: Backtracking 
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++
Java
Python3
C#
Javascript
 

 
 










#include <bits/stdc++.h> 
#include <string> 
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); 
    } 
  
} 
  
int main() 
{ 
    string s; 
    string answer=""; 
  
    cout<<"Enter the string : "; 
    cin>>s; 
  
    cout<<"\nAll possible strings are : "; 
    permute(s , answer); 
    return 0; 
} 






 

 
 










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






 

 
 










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






 

 
 










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  






 

 
 










<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:
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. 
 
Mithun Kumar
ArindamDuttagupta
rathbhupendra
nikhilchhipa9
imsushant12
srivastavaharshit848
adityapande88
avanitrachhadiya2155
GauravRajput1
subhammahato348
amartyaghoshgfg
code_hunt
codessrivastava
ishankhandelwals

Accolite


Amazon


Apple


Cisco


Citrix


MAQ Software


OYO Rooms


permutation


Samsung


Snapdeal


Walmart


Backtracking


Combinatorial


Greedy


Mathematical


Recursion


Strings

Accolite
Amazon
OYO Rooms
Samsung
Snapdeal
Citrix
Walmart
MAQ Software
Cisco
Apple
Strings
Greedy
Mathematical
Recursion
permutation
Combinatorial
Backtracking
Writing code in comment? 
                                    Please use ide.geeksforgeeks.org, 
                                    generate link and share the link here.