Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
4990 connectés 

 


Dernière réponse
Sujet : Un algo qui renvoit toutes les possibilités d'arrangements d'un tab
Notsukaw 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 :lol:

Votre réponse
Nom d'utilisateur    Pour poster, vous devez être inscrit sur ce forum .... si ce n'est pas le cas, cliquez ici !
Le ton de votre message                        
                       
Votre réponse


[b][i][u][strike][spoiler][fixed][cpp][url][email][img][*]   
 
   [quote]
 

Options

 
Vous avez perdu votre mot de passe ?


Vue Rapide de la discussion
Notsukaw 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 :lol:
ceyquem up
Notsukaw

prettysmile a écrit a écrit :

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  :ouch:

prettysmile ben balance ton truc et on discutera optimisation
Notsukaw

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 :D
Je sais, je suis chiant :lol:
 
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 :hello:

prettysmile 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  ;)
Notsukaw 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.
 
:hello:

Copyright © 1997-2025 Groupe LDLC (Signaler un contenu illicite / Données personnelles)