GeeksforGeeks

DFS can be used to generate all permutations of a string.

Code: http://ideone.com/cKgy3m

Using std::string and member-functions for the below c++ solution:

/* Generate permutations of a string */

#include

#include

#include

using namespace std;

vector GenPrmutations(std::string str) {

vector strList;

if (str.empty()) {

return vector();

}

if (str.length() == 1) {

strList.push_back(str);

}

else {

char c = str.at(0);

string rest = str.substr(1, str.length()-1);

vector restList = GenPrmutations(rest);

for (vector::iterator itr = restList.begin();

itr != restList.end(); itr++) {

unsigned int len = (*itr).length();

for (unsigned int pos=0; pos <= len; ++pos) {

string tmp = (*itr);

tmp.insert(pos, 1, c);

strList.push_back(tmp);

}

}

}

return strList;

}

int main () {

vector strList = GenPrmutations(“abc”);

for (vector::iterator itr = strList.begin();

itr != strList.end(); itr++) {

cout << (*itr) << endl;

}

return 0;

}

I wrote the code for variable length string but the program gives segmentation fault.
#include
void swap(char *i,char *j)
{
char t;
t=*i;
*i=*j;
*j=t;
}
void perm(char *str,int i,int n)
{
int j;
if(i==n)
{
printf(“%s”,str);
}
else
{
for(j=i;j<=n;j++)
{
swap(str+i,str+j);
perm(str,i+1,n);
swap(str+i,str+j);
}
}
}

int main()
{
char *string;
int n;
printf("Enter the string");
scanf("%s",string);
n=strlen(string);
perm(string,0,n);
return 0;
}

please tell me where i went wrong

The code works fine with out Back Tracking.. Please explain the logic

void permute(char *a, int i, int n)
{
int j;
if (i == n)
printf(“%sn”, a);
else
{
for (j = i; j <= n; j++)
{
swap((a+i), (a+j));
permute(a, i+1, n);
// swap((a+i), (a+j)); //backtrack
}
}
}

What if i want the algorithm to stop if it reaches a limit ? for example if we have 3628800 (10!) permutations and i want it to stop when we have generated 1000 permutations ? and what time complexity we will have that way ?

thanks

//Repeatation will not harm my code….
#include
#include
using namespace std;

void Swap(char Str[],int m,int n)
{
char temp=Str[m];
Str[m]=Str[n];
Str[n]=temp;
}
bool Match(char Str[],int i,int j)
{
if(i == j)
return false;
else
for(;i=n){cout<<Str<<endl;return;}
for(int i=m;i<=n;i++)
{ if(!Match(Str,m,i))
{
Swap(Str,i,m);
Permute(Str,m+1,n);
Swap(Str,i,m);
}

}
}

int main()
{
char Str[]="AAB";
Permute(Str,0,strlen(Str)-1);

return 0;
}
//Happy coding

Can someone explain the time complexity

iam not able to understand this program ….
can anyone trace and explian it plz ……….

 public class permute { static void permute(int level, String permuted, boolean used[], String original) { int length = original.length(); if (level == length) { System.out.println(permuted); } else { for (int i = 0; i < length; i++) { if (!used[i]) { used[i] = true; permute(level + 1, permuted + original.charAt(i), used, original); used[i] = false; } } } } public static void main(String[] args) { String s = "hello"; boolean used[] = {false, false, false, false, false}; permute(0, "", used, s); } } 

//In C#….
public static void permutation(string strPrefix, string str)
{
int n = str.Length;

if(n == 1)
Console.WriteLine(strPrefix + str);

for (int i = 0; i < str.Length; i++)
{
string prefix = strPrefix + str.Substring(i, 1);
permutation(prefix, str.Substring(0,i) + str.Substring(i+1,n-i-1));

}
}

To get better understand of the code and map it to pictorial representation. Leaf nodes of the tree should also show ABC(because in the first case A is fixed and B is permuted with B itself and the B is permuted with C). This will be helpful in understanding the check.

If(i == n)
printf(“”);

 /* Paste your code here (You may delete these lines if not writing code) */ 

Please see my series on this for a solution in Java, plus generating sub-permutations (for string “abcd” – all permutations of abcd, all permutations of bcd, all permutations of cd, etc), plus solving when duplicate characters are part of the string as in the examples, “aabc,” “dddd,” etc.

http://code.scottshipp.com/2013/04/12/permutations-generator-part-1/

http://code.scottshipp.com/2013/04/16/permutation-generator-part-2/

http://code.scottshipp.com/2013/04/21/permutation-generator-part-3/

http://code.scottshipp.com/2013/04/29/permutation-generator-part-4/

#include
#include

void swap(char *n,int x,int y){
char temp;
temp = *(n+x);
*(n+x) = *(n+y);
*(n+y) = temp;
}

int main () {

char b[] = “abcd”;
int size = strlen(b);
for(int k=0;k<size;k++){
char *a = b;
swap(a,0,k);
for(int j=0;j1;i–){
swap(a,i-1,i);
printf(“%s \n”,a);
}
}
}

return 0;
}

/* Paste your code here (You may delete these lines if not writing code) */
/**
*
* @author Dharmendra Singh
*/
public class PermutationOfStringCharsPassed {

private void getPermutationOfStringCharsPassed(char[] keys){
int size = (int) Math.pow(2, keys.length);

for(int i = 0 ; i < size ; i++){
for(int k = 0; k > k) & 1) == 1){
System.out.print(keys[k]);
}
}
System.out.println();
}
}

public static void main(String[] args) {
char[] keys = {'a','b','c','d'};
PermutationOfStringCharsPassed p = new PermutationOfStringCharsPassed();
p.getPermutationOfStringCharsPassed(keys);
}
}

this code can permutate strings of any length and is written only for strings without any repeatation.

how do i improve so as to incorporate the strings with repeatation……

/* Paste your code here (You may delete these lines if not writing code) */

//***************anagrams**************//

//************************************** this code works only when there are no repeatations in the original string*************//
#include<iostream>
using namespace std;

int counter=0;

void print(char empty[],int size)
{

for(int i=0;i<size;i++)
{
cout<<empty[i];
}
cout<<endl;
}

void makecombination(char original[],char empty[],char comb[],int k,int& nc,int size)
{
nc=0;

int flag=0;
for(int i=0;i<size;i++)
{
flag=0; // {
for(int j=0;j<k;j++)
{
if(empty[j]==original[i]) // remove this code fragment
{ // to print permutations with repeatation
flag=1;
break;
}
}
if(flag==0) // }
{
comb[nc++]=original[i];
}
}
// cout<<"checks ";
// print(comb,nc);
}

void recurse(char original[],char empty[],int k,int size)
{
char *comb=new char[size];

int nc;

if(k==size)
{
counter++;
print(empty,size);

}
else
{
makecombination(original,empty,comb,k,nc,size);
k=k+1;
for(int i=0;i<nc;i++)
{
empty[k-1]=comb[i];
//cout<<"checks ";
//print(empty,size);
recurse(original,empty,k,size);
}
}

}

int main()
{
const int size=4;
int k=0;
char original[]="ABCD";

char empty[size];
for(int f=0;f<size;f++)
empty[f]=’*’;

recurse(original,empty,k,size);

cout<<endl<<counter<<endl;
return 0;
}

missing case: string with repeat characters.
such as: abcdmabc

 void swap(char str[], int i, int j){ char c; c = str[i]; str[i] = str[j]; str[j] = c; } void printStr(char str[], int k, int m){ if(k == m){ cout<<str<<endl; }else{ for(int i=k; i<=m; i++){ for(int j=k;j<i;j++) // remove the repeat characters if(str[j]==str[i]) goto nextloop; swap(str, i, k); printStr(str, k+1, m); swap(str, k, i); nextloop:; } } } 

how is this O(n*n!)?

What is the need to call swap once again after the permute function. I tried removing it and it still generates all the permutations except that order differs!
With 2nd Swap ->
ABC
ACB
BAC
BCA
CBA
CAB
Without 2nd Swap ->
ABC
ACB
CAB
CBA
ABC
ACB

 permute(int input[]) { int n=size(input[]); int out[]=malloc(sizeof(input[])); int used[]=malloc(sizeof(input[])); for(int i=0;i<size(used[]);i++) { used[i]=0; } dopermute(input,0,n,out,used); } void dopermute(int input[],int level, int size, int out[],int used[]) { If(level>=size) { for(int i=0;i<size(out);i++) { printf("%c",out[i]); } return; } for(j=0;j<size;j++) { If used[i] continue; used[j]=1 out[level]=arr[j]; dopermute(input,level+1,size,out,used); used[j]=0; } } 

 ArrayList<String> permutationsOf(String s) { ArrayList<String> result = new ArrayList<String>(); if (s.length() == 1) { result.add(s); return result; } else { char first = s.charAt(0); String rest = s.substring(1); ArrayList<String> simpler = permutationsOf(rest); for (String permutation : simpler) { ArrayList additions = insertAtAllPositions(first, permutation); result.addAll(additions); } return result; } } 

<?php

function sort_string($str){
$arr = NULL;
$len = strlen($str);
for($i=0; $i<$len; $i++){
$arr[] = $str[$i];
}
sort($arr);
$str = "";
for($i=0; $i<$len; $i++){
$str = $str . $arr[$i];
}
return $str;
}

function permute($str){
//base cases
if ($str == NULL){
return "";
}
$len = strlen($str);
if ($len == 1){
return $str;
}
else if ($len == 2){
return $str ."," . $str[1] . $str[0];
}
// the recursion
else {
$ans = "";
for($i=0; $i<$len; $i++){
// currenct char
$char = $str[$i];
// the string without the selected char
$str_b = substr($str,0,($i-1 < 0 ? 0 : $i)) . substr($str,$i+1, $len-$i-1);
//build all the sub-permutations without char
$sub_perm = permute($str_b);
//now add char
$ans = $ans . add_first_char($sub_perm, $char);
}
return $ans;
}
}

function add_first_char($str, $char){
$ans = "";
$items = explode (‘,’,$str);
$len = sizeof($items);
for($i=0; $i<$len; $i++){
$ans = $ans . "," . $char . $items[$i];
}
// remove the first ","
return $ans;//
}

$filename = $argv[1];
$handle = fopen($filename, "rb");
$line = "";
while (!feof($handle)) {
$line = fgets($handle, 8192);
$line = trim($line);
if ($line != NULL) {
$line = sort_string($line);
$ans = permute($line);
//remove first "," from the final response
$ans = substr($ans,1,strlen($ans)-1);
echo trim($ans) . "\n";
}
}
fclose($handle);
return 0;

?>

http://n1b-algo.blogspot.com/2009/01/string-permutations.html

hii..
i want a program to print the first letter of given sentence of each word and at the end the last word of given sentence also printed..
for ex:
the given string is: hii hello how are you
output:hhhayyou
like this… pls anybody tel me the code…

plzz reply sharp……….write a program in c to print all posible permutations of abcde

 /* Paste your code here (You may delete these lines if not writing code) */ 

nice

@geeksforgeeks correct this code.for same type of word it is not working.

Great post!

Nice solution here as well:

http://www.programmerinterview.com/index.php/recursion/permutations-of-a-string/

Just another improvement.
The function prototype can be just permute(char *a, int size);

Modification would be:
instead of swapping every element in loop with first element,
we can swap it with last element and call permute(a, size-1);

what do you say?

I think this will work. I ran this and its working:

 private void swap(ref char a, ref char b) { if (a == b) return; a ^= b; b ^= a; a ^= b; } private void go(char[] list, int k, int m) { int i; if (k == m) { Console.Write(list); Console.WriteLine(" "); } else for (i = k; i <= m; i++) { if (list[k] == list[i] && k != i) continue; swap(ref list[k], ref list[i]); go(list, k + 1, m); swap(ref list[k], ref list[i]); } } 

Only difference is in Swap function, So swap is also checking if swapping characters are equivalent.

The complete code is at :
http://techpuzzl.wordpress.com/2010/01/11/string-permutation/