Un autre en Python, ce n’est pas comme @ cdiggins, mais je pense que c’est plus facile à comprendre

 def permute(num): if len(num) == 2: # get the permutations of the last 2 numbers by swapping them yield num num[0], num[1] = num[1], num[0] yield num else: for i in range(0, len(num)): # fix the first number and get the permutations of the rest of numbers for perm in permute(num[0:i] + num[i+1:len(num)]): yield [num[i]] + perm for p in permute([1, 2, 3, 4]): print p 

Je pensais écrire un code pour obtenir les permutations d’un nombre entier quelconque de n’importe quelle taille, c’est-à-dire fournir un numéro 4567, nous obtenons toutes les permutations possibles jusqu’à 7654 … est le code écrit en “c”. Vous pouvez simplement le copier et l’exécuter sur tous les compilateurs open source. Mais certains défauts attendent d’être débogués. S’il vous plaît apprécier.

Code:

 #include  #include  #include  //PROTOTYPES int fact(int); //For finding the factorial void swap(int*,int*); //Swapping 2 given numbers void sort(int*,int); //Sorting the list from the specified path int imax(int*,int,int); //Finding the value of imax int jsmall(int*,int); //Gives position of element greater than ith but smaller than rest (ahead of imax) void perm(); //All the important tasks are done in this function int n; //Global variable for input OR number of digits void main() { int c=0; printf("Enter the number : "); scanf("%d",&c); perm(c); getch(); } void perm(int c){ int *p; //Pointer for allocating separate memory to every single entered digit like arrays int i, d; int sum=0; int j, k; long f; n = 0; while(c != 0) //this one is for calculating the number of digits in the entered number { sum = (sum * 10) + (c % 10); n++; //as i told at the start of loop c = c / 10; } f = fact(n); //It gives the factorial value of any number p = (int*) malloc(n*sizeof(int)); //Dynamically allocation of array of n elements for(i=0; sum != 0 ; i++) { *(p+i) = sum % 10; //Giving values in dynamic array like 1234....n separately sum = sum / 10; } sort(p,-1); //For sorting the dynamic array "p" for(c=0 ; c *(p+j)) { temp = *(p+i); *(p+i) = *(p+j); *(p+j) = temp; } } } } int imax(int *p, int i , int d) { while(ip[k]) { small = p[i]; j = i; } } return j; } 

 void permutate(char[] x, int i, int n){ x=x.clone(); if (i==n){ System.out.print(x); System.out.print(" "); counter++;} else { for (int j=i; j<=n;j++){ // System.out.print(temp); System.out.print(" "); //Debugger swap (x,i,j); // System.out.print(temp); System.out.print(" "+"i="+i+" j="+j+"\n");// Debugger permutate(x,i+1,n); // swap (temp,i,j); } } } void swap (char[] x, int a, int b){ char temp = x[a]; x[a]=x[b]; x[b]=temp; } 

J'ai créé celui-ci. basé sur des recherches trop permutées (qwe, 0, qwe.length-1); Juste pour que vous sachiez, vous pouvez le faire avec ou sans backtrack

Voici une méthode Ruby qui fonctionne comme #permutation.to_a qui pourrait être plus lisible pour les fous. C’est hella slow, mais aussi 5 lignes.

 def permute(ary) return [ary] if ary.size <= 1 ary.collect_concat.with_index do |e, i| rest = ary.dup.tap {|a| a.delete_at(i) } permute(rest).collect {|a| a.unshift(e) } end end 

J’ai écrit cette solution récursive dans ANSI C. Chaque exécution de la fonction Permutate fournit une permutation différente jusqu’à ce que tout soit terminé. Les variables globales peuvent également être utilisées pour les variables fact et count.

 #include  #define SIZE 4 void Rotate(int vec[], int size) { int i, j, first; first = vec[0]; for(j = 0, i = 1; i < size; i++, j++) { vec[j] = vec[i]; } vec[j] = first; } int Permutate(int *start, int size, int *count) { static int fact; if(size > 1) { if(Permutate(start + 1, size - 1, count)) { Rotate(start, size); } fact *= size; } else { (*count)++; fact = 1; } return !(*count % fact); } void Show(int vec[], int size) { int i; printf("%d", vec[0]); for(i = 1; i < size; i++) { printf(" %d", vec[i]); } putchar('\n'); } int main() { int vec[] = { 1, 2, 3, 4, 5, 6 }; /* Only the first SIZE items will be permutated */ int count = 0; do { Show(vec, SIZE); } while(!Permutate(vec, SIZE, &count)); putchar('\n'); Show(vec, SIZE); printf("\nCount: %d\n\n", count); return 0; } 

Version Java

 /** * @param uniqueList * @param permutationSize * @param permutation * @param only Only show the permutation of permutationSize, * else show all permutation of less than or equal to permutationSize. */ public static void my_permutationOf(List uniqueList, int permutationSize, List permutation, boolean only) { if (permutation == null) { assert 0 < permutationSize && permutationSize <= uniqueList.size(); permutation = new ArrayList<>(permutationSize); if (!only) { System.out.println(Arrays.toSsortingng(permutation.toArray())); } } for (int i : uniqueList) { if (permutation.contains(i)) { continue; } permutation.add(i); if (!only) { System.out.println(Arrays.toSsortingng(permutation.toArray())); } else if (permutation.size() == permutationSize) { System.out.println(Arrays.toSsortingng(permutation.toArray())); } if (permutation.size() < permutationSize) { my_permutationOf(uniqueList, permutationSize, permutation, only); } permutation.remove(permutation.size() - 1); } } 

Par exemple

 public static void main(Ssortingng[] args) throws Exception { my_permutationOf(new ArrayList() { { add(1); add(2); add(3); } }, 3, null, true); } 

sortie:

  [1, 2, 3] [1, 3, 2] [2, 1, 3] [2, 3, 1] [3, 1, 2] [3, 2, 1] 

en PHP

 $set=array('A','B','C','D'); function permutate($set) { $b=array(); foreach($set as $key=>$value) { if(count($set)==1) { $b[]=$set[$key]; } else { $subset=$set; unset($subset[$key]); $x=permutate($subset); foreach($x as $key1=>$value1) { $b[]=$value.' '.$value1; } } } return $b; } $x=permutate($set); var_export($x); 

 // 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 ssortingng This function takes three parameters: 1. Ssortingng 2. Starting index of the ssortingng 3. Ending index of the ssortingng. */ 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; } 

Référence: Geeksforgeeks.org

Voici le code en Python pour imprimer toutes les permutations possibles d’une liste:

 def next_perm(arr): # Find non-increasing suffix i = len(arr) - 1 while i > 0 and arr[i - 1] >= arr[i]: i -= 1 if i <= 0: return False # Find successor to pivot j = len(arr) - 1 while arr[j] <= arr[i - 1]: j -= 1 arr[i - 1], arr[j] = arr[j], arr[i - 1] # Reverse suffix arr[i : ] = arr[len(arr) - 1 : i - 1 : -1] print arr return True def all_perm(arr): a = next_perm(arr) while a: a = next_perm(arr) arr = raw_input() arr.split(' ') arr = map(int, arr) arr.sort() print arr all_perm(arr) 

J'ai utilisé un algorithme d'ordre lexicographique pour obtenir toutes les permutations possibles, mais un algorithme récursif est plus efficace. Vous pouvez trouver le code de l'algorithme récursif ici: permutations de récursion Python

 public class PermutationGenerator { private LinkedList> _permutationsList; public void FindPermutations(List list, int permutationLength) { _permutationsList = new LinkedList>(); foreach(var value in list) { CreatePermutations(value, permutationLength); } } private void CreatePermutations(int value, int permutationLength) { var node = _permutationsList.First; var last = _permutationsList.Last; while (node != null) { if (node.Value.Count < permutationLength) { GeneratePermutations(node.Value, value, permutationLength); } if (node == last) { break; } node = node.Next; } List permutation = new List(); permutation.Add(value); _permutationsList.AddLast(permutation); } private void GeneratePermutations(List permutation, int value, int permutationLength) { if (permutation.Count < permutationLength) { List copyOfInitialPermutation = new List(permutation); copyOfInitialPermutation.Add(value); _permutationsList.AddLast(copyOfInitialPermutation); List copyOfPermutation = new List(); copyOfPermutation.AddRange(copyOfInitialPermutation); int lastIndex = copyOfInitialPermutation.Count - 1; for (int i = lastIndex;i > 0;i--) { int temp = copyOfPermutation[i - 1]; copyOfPermutation[i - 1] = copyOfPermutation[i]; copyOfPermutation[i] = temp; List perm = new List(); perm.AddRange(copyOfPermutation); _permutationsList.AddLast(perm); } } } public void PrintPermutations(int permutationLength) { int count = _permutationsList.Where(perm => perm.Count() == permutationLength).Count(); Console.WriteLine("The number of permutations is " + count); } } 

À Scala

  def permutazione(n: List[Int]): List[List[Int]] = permutationeAcc(n, Nil) def permutationeAcc(n: List[Int], acc: List[Int]): List[List[Int]] = { var result: List[List[Int]] = Nil for (i ← n if (!(acc contains (i)))) if (acc.size == n.size-1) result = (i :: acc) :: result else result = result ::: permutationeAcc(n, i :: acc) result } 

c’est une version java pour la permutation

 public class Permutation { static void permute(Ssortingng str) { permute(str.toCharArray(), 0, str.length()); } static void permute(char [] str, int low, int high) { if (low == high) { System.out.println(str); return; } for (int i=low; i