salut les filles  
je cherche un algo (recursif ?) qui prend un tableau ("A" "B" "C" etc) en parametre et qui renvoie tout les tableau possible avec les permutations des elements du tableau  
 
merci
 

Où est la difficulté ?
 
Si on fait les devoirs à la place des étudiants, ils n'apprennent pas, et ce n'est pas bon pour eux.
Ce ne serait pas non plus équitable pour ses camarades.
Et enfin, ça inciterait le prof à faire des exercices de plus en plus compliqués.
 
Franchement, un algorithme récursif de permutation, c'est assez facile à écrire.

je sais pas quel age tu as mais mois je suis plus a l'école  

Alors, c'est encore pire que ce que je croyais.
 
Il faudrait retourner à l'école (en commençant par le CE1 où l'on apprend à mettre une majuscule au début de chaque phrase).

A l'école, il sont tout de même doué pour demander des idée aux autres...  

Tu peux pas prendre l'algo que gilou a donné comme solution pour les chaîne de caractères ?
Au lieu de mettre des caractère tu mets les élément de ton tableau.
C'est pas la même chose ?
Si t'as deux éléments identique t'aura des doublon par contre.

Si tu t'autorises le récursivité, alors en 2 coup de cuillère à pot, je te ponds celui la, que tu peux adapter à tes besoins:

 
Après, tu n'as plus qu'a adapter à tes besoins:
 

 
A+,

merci gilou !
 
je vais le simplifier pour du pseudo code
 
pdt que tu es la avec jovalise
mon pb est le suivant
 
faire un itinéraire optimisé avec n étape
 
mon idée c'"était  
1 - generer tout les trajets (je sais calculer les temps entre 2 villes)
2 calculer le temps d'un trajet
3 sortir le min du tableau de trajet
 
y'a plus simple ?  
 
c'est juste un exo /amusement en formation mais je trouve ça marant
en pseudo code on a le droit aux * méthodes magique* comme celle qui génere le tableau de trajet
 
 

Ce dont tu parles équivaut au problème classique du voyageur de commerce, non?
On peut toujours faire une approche combinatoire, mais des qu'on a beaucoup de ville, ça explose en temps de calcul.
Le problème du voyageur de commerce se solutionne avec des temps de calcul raisonnables en se contentant d'une bonne solution (même si c'est pas nécessairement la meilleure). Cf le lien Wikipedia donné.
A+,

L'algo est très simple:
J'échange pas swap le premier élément avec un quelconque des autres (dont lui même pour avoirs les cas ou il est stable), puis je réapplique récursivement au reste moins ce premier élément (la boucle initiale sert a faire l'échange du premier élément avec chacun des éléments possibles).
A+,

c'est marrant je croyais que les possibilité de voyage c'était en n^n mais c'est plutot en n! non ?

Si tu as n villes, c'est n! le nombre de permutations des villes.
Notes que dans ce cas, il y a des trajets équivalents (a vue de nez, le trajet dans un sens ou l'autre déjà, donc ça réduit déjà à n!/2)
A+,
 

amiens -> paris <> paris amiens ²

C'est la même distance Il suffit donc de faire le trajet en marche arrière  
A+,

pas le meme temps voyons bouchons toussa ²

a ouais

:???:
 
j'essaie de l'implementer en java  
et c'est bizard, mon swat mache ^pas sans le tableau en parametre
si je met 2 string  
 
public void swat(String x, String y){
 
alors que public void swap(String tab[], int x, int y){
fonctionne

Comme méthode d'une classe tableau?
Ah non, j'ai pas trop compris ce que les String viennent faire la dedans.
A+,

non

Ben alors c'est quoi String x et String y  (parce que en java, les strings étant pas modifiables une fois construites...)
A+,

bah c'est t[i]; t[j]

Chez moi, ça marche...  
 

import java.util.Arrays;
 
public class Cochonne {
    private String[] table;
 
    public Cochonne (String[] t)  {
    table = t;
    }
 
    private void swap(int i, int j) {
    String tmp = table[i];
    table[i] = table[j];
    table[j] = tmp;
    }
 
    private void permute(int i) {
    if (i < table.length) {
        for (int j = i; j < table.length; j++) {
        swap(i, j);
        permute(i+1);
        swap(j, i);
        }
        return;
    }
    System.out.println(Arrays.toString(table));
    }
 
    public void permute() {
    permute(0);
    }
 
    public static void main(String[] args){ 
    Cochonne vapeur = new Cochonne(new String[] {"vapeur", "cochonne", "a dit", "l'alcool c'est mal!"});
    vapeur.permute();
    }
}

A+,

non mais j'avais pas de return ...

sinon comment on peux ranger les resultats dans un tableau ?

Dans ce cas la, plusieurs possibilités:
Soit tu utilises un tableau que tu fais croître au fur et a mesure, un ArrayList.
Soit tu alloues un tableau de table.length! au début de permute
Il faut changer la signature de permute (pour qu'elle renvoie ton tableau des permutations) et celle de permute(int i) pour qu'elle prenne le tableau des permutations en paramètre.
Et tu ajoute chaque nouvelle permutation au niveau de la ligne
System.out.println(Arrays.toString(table));
en copiant (une vraie copie avec clone, bien sur) table à ce moment la.
 
A+,
 

ok

Bon, la, un exemple vite fait, en foutant tout en statique dans la classe, pour aller plus vite:

Notes que bien sur, dès que l'on a un tableau initial un peu grand, factorielle va nous exploser dans la tronche  
Faudrait donc en tenir compte, par exemple, en allant lire ceci: http://chaosinmotion.com/blog/?p=622
A+,

cool ²

tout en anglais, galere

Le forum n'est pas là pour faire vos exercices à votre place

tait toi vilain

Je vais faire une alerte modo, tiens, si ça se trouve, gilou va passer par là et locker ce topic

3 Mois que je suis a paris et tu m'as jamais payé une biere gilou non plus d'ailleurs !

Ça ne sera envisageable que quand ma situation financière évoluera positivement. La je dois faire vraiment gaffe à mon budget.
Ça semble se débloquer pour début janvier heureusement.
A+,

De toute façon, si tu es coincé par le fait que ta factorielle dépasse maxint, vu que tu auras besoin de cela fois la taille de ton array initial a allouer en mémoire pour le String[][], c'est la mémoire qui manquera, même si on utilise une classe adaptée pour que factorielle soit sans problème.
C'est pour ça que le pb de la qualité de l'implem de factorielle m'a pas trop inquiété
A+,

comme si je pouvais pas te payer une biere ou pire, mutch ²
 
sinon revend une ou deux caisse de dvd

bah meme pour travailler sur les grands nombres premiers il faudra que je regarde les tres grand entier dans des classes adapté

> sinon revend une ou deux caisse de dvd
Pas évident de revendre des DVD anglais en France.
 
> bah meme pour travailler sur les grands nombres premiers il faudra que je regarde les tres grand entier dans des classes adapté
Je suis pas certain que java soit particulièrement efficace pour faire du number crunching.
Et je vois pas trop le lien avec cette histoire de permutation.
 
A+,

faire des ptits programme rigolo

>> faire des ptits programme rigolo
   
A+,