Skip to content
Related Articles

Related Articles

Write a program to print all permutations of a given string

Improve Article
Save Article
Like Article
  • Difficulty Level : Medium
  • Last Updated : 25 May, 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)

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.

NewPermutation

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(); 
    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 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): 
            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#




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

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




#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;
}

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




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

 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!