Reprise du message précédent :
>> faire des ptits programme rigolo
   
A+,

up

Si on le veut en itératif, il y a l'algo QuickPerm
Le code qui imprime la même chose (facile a modifier si on veut creer le tableau de tous les sous tableaux permutés, et pas seulement imprimer)
 

import java.util.Arrays;
import java.lang.String;
    
public class Vapeur {
    public  String[] permuted;
    private String[] initial;
    private int[] indice;
    private int count;
 
    public Vapeur (String[] t)  {
    count = t.length;
    initial = t.clone();
    permuted = new String[count];
    indice = new int[count];
    for (int i = 0; i < count; ++i) {
        indice[i] = i;
        permuted[i] = initial[i];
    }
    }
 
    private void swap(int i, int j) {
    int tmp = indice[i];
    indice[i] = indice[j];
    indice[j] = tmp;
    }
 
    private boolean permute() {
    int tail, i, j;
 
    if (count <= 1) return false;
 
    for (i = count-1; i > 0 && indice[i-1] >= indice[i]; --i) /* */;
    tail = i;
 
    if (tail > 0) {
        for (j = count-1; j > tail && indice[j] <= indice[tail-1]; --j) /* */;
        swap(tail-1, j);
    }
        
    for (i = tail, j = count-1; i < j; ++i, --j) {
        swap(i, j);
    }
 
    for (i = 0; i < count; ++i) {
        permuted[i] = initial[indice[i]];
    }
 
    return (tail != 0);
    }
 
    public void printPermuted(){
        System.out.println(Arrays.toString(permuted));
    }
 
    public void reset() {
        for (int i = 0; i < count; ++i) {
        indice[i] = i;
        permuted[i] = initial[i];
    }
    }
 
    public static void main(String[] args){ 
    String[] texte = new String[] {"vapeur", "cochonne", "a dit", "l'alcool c'est mal!"};
    Vapeur cochonne = new Vapeur(texte);
    do {
        cochonne.printPermuted();
    } while (cochonne.permute());
    cochonne.reset();
        /* ... */
    }
}

 
A+,

mwoauis tu veux pas m'expliquer ce qui se passe quand j=3 dans ton prog recursif
 
on passe jamais dans le swap(i, j) ?

On commence a faire un permute(0), c'est a dire un permute à partir de l'indice 0
 
ça fait:
for (int j = 0; j < 3; j++) {
 swap(0, j);
 permute(1);
 swap(j, 0);
}
 
Donc ca fait
On a au départ [0, 1, 2] par exemple
swap(0,0) -> rien de modifié
permute(1); donc permutation de [1, 2] et 0 fixé en premier indice
==> swap(1,1) -> rien de modifié
      permute(2)  
       ==> plus rien à permuter -> retour avec [0, 1, 2]
      swap(1,1) -> rien de modifié
      swap(1,2) -> on a maintenant [0, 2, 1]
      permute(2)  
      ==> plus rien à permuter -> retour avec [0, 2, 1]
      swap(2,1) -> on a maintenant [0, 1, 2]
swap(0,0) -> rien de modifié
swap(0,1) -> on a maintenant [1, 0, 2]
permute(1); donc permutation de [0, 2] et 1 fixé en premier indice
==> swap(1,1) -> rien de modifié
      permute(2)  
       ==> plus rien à permuter -> retour avec [1, 0, 2]
      swap(1,1) -> rien de modifié
      swap(1,2) -> on a maintenant [1, 2, 0]
      permute(2)  
      ==> plus rien à permuter -> retour avec [1, 2, 0]
      swap(2,1) -> on a maintenant [1, 0, 2]
swap(1,0) -> on a maintenant [0, 1, 2]
swap(0,2) -> on a maintenant [2, 1, 0]
permute(1); donc permutation de [1, 0] et 2 fixé en premier indice
==> swap(1,1) -> rien de modifié
      permute(2)  
       ==> plus rien à permuter -> retour avec [2, 1, 0]
      swap(1,1) -> rien de modifié
      swap(1,2) -> on a maintenant [2, 0, 1]
      permute(2)  
      ==> plus rien à permuter -> retour avec [2, 0, 1]
      swap(2,1) -> on a maintenant [2, 1, 0]
swap(2,0) -> on a maintenant [0, 1, 2]
 
A+,