Hug les grands chefs de la programmation,
 
je cherche à faire un algo qui prend en paramètre
un tableau d'entiers (nb cases), et qui essaye toutes les possibilités d'arrangements.
 
Cet algo doit permettre de récupérer chacune des possibilités
une à une, afin de les utiliser dans une autre fonction.
 
Voilà je vois pas trop comment faire,
donc si vous avez des idées elles sont les bienvenues.
 

http://www.google.fr/search?q=tout [...] l=fr&meta=
 
je pense que tu trouveras des choses intéressante là dedans (notamment le 2ème lien). c'est le google power, faudrait apprendre à s'en servir  

prettysmile a écrit a écrit : http://www.google.fr/search?q=tout [...] l=fr&meta=   je pense que tu trouveras des choses intéressante là dedans (notamment le 2ème lien). c'est le google power, faudrait apprendre à s'en servir

 
Si je me suis permi de poster ici, c'est que ce que j'ai trouvé sur google ne me convenait pas
Je sais, je suis chiant
 
Mais en fait c'est parce que je me demande si y'a pas une solution plus optimisée que ça, parce que là mon tableau de 255 cases, contenant des chiffres à faire varier de 1 à 65 535, je te dis pas le temps que ça va prendre ...
 
Merci quand même

ben balance ton truc et on discutera optimisation

 
Ok, je le send dès qu'il est dispo, mais en fait c'est pour m'en servir dans un algo de décryptage d'une clé, dont la taille peut aller de 40 bits à 6136 bits  

up

Bon voilà une première ébauche de l'algo principal,
mais avec le nombre de boucles imbriquées,  
sa complexité est pourrave,
mais pour l'instant j'ai pas trouvé autre chose.
J'ai mis en gras les fonctions qui me posent problème.
Donc voilà si quelqu'un a des idées.
 
PS: C'est du pseudo-code mélangé avec du C, enfin un peu n'importe quoi mdr.
 
On suppose définie notre structure clé:
 
struct clé{
int nbAgents;
int *position;
int *direction;
int modification;
}
 
 
/************************************************* ALGO DECRYPTAGE ************************************************/
/*************************************************
 
**************************************************
 
***************/
 
 
ALGO Decrypt (fichier_crypte)
{
  entier: nbAgents = 1;
  entier: modif = 0; //Pour débuter on va simplement additionner cette valeur au code ascii du caractère
  fichier: FichierDecrypt;
  positions: tableau d'entiers
  directions: tableau d'entiers
  clé: uneCle
   
 
  /* Boucle sur le nombre d'agents */
  /*********************************/
  Répéter  
   {
 
     /* Creation des tableaux */
     /*************************/
     positions = creer_tableau(nbAgents); //Allocation mémoire
     directions = creer_tableau(nbAgents); //Allocation mémoire
 
     /* Initialisation des tableaux */
     /*******************************/
     initialise(positions, nbAgents); //Valeurs obligatoirement plus petites que le nombre de caractères du texte
     initialise(directions, nbAgents); //Ne prend que deux types de valeurs, G ou D par exemple
   
 
 
     /* Boucle sur les combinaisons du tableau des positions */
     /********************************************************/
     Répéter
       {
          positions = Remplissage(positions, nbAgents); //On essaye une séquence de positions des agents
 
 
  /* Boucle sur les combinaisons du tableau des directions */
  /*********************************************************/
          Répéter
            {
              directions = Remplissage(directions, nbAgents); //On essaye une séquence de directions des agents
 
 
   /* Boucle sur les possibilités de modification */
   /***********************************************/
   Répéter
    {
       
    /* Initialisation de la clé en fonction des différents paramètres */
    /******************************************************************/
      uneCle.nbAgents = nbAgents;
    uneCle.position = positions;
    uneCle.direction = directions;
    uneCle.modification = modif;
    /******************************************************************/
 
               FichierDecrypt = crypter(uneCle, fichier_crypte);
    modif++;      
              }
   Jusqu'à (texte décrypté OU modif > 64)
   /* Fin boucle sur les modifications */
   /************************************/
 
 
          Jusqu'à (texte décrypté OU possibilités de direction toutes effectuées);
  /* Fin boucle sur les directions */
  /*********************************/
 
       }
     Jusqu'à (texte décrypté OU possibilités de position toutes effectuées);
   /* Fin boucle sur les positions */
   /********************************/
 
     nbAgents ++;
   }
  Jusqu'à (texte décrypté OU nbAgents > 255);
  /* Fin boucle sur les agents */
  /*****************************/
 
  Afficher FichierDecrypt
}
 
 
EDIT: Désolé la mise en page n'a pas supporté le copier/coller