Partage
  • Partager sur Facebook
  • Partager sur Twitter

Possibilité d'ordonnance des lettres...

abc, acb, bac, bca, cab, cba

Sujet résolu
    1 septembre 2007 à 13:52:19

    Bonjour, je sais que mon titre n'est pas très explicite, mais mon but est simple, je veux testé toutes les possibilité des lettres que je donne à mon programme. Je sais comment faire pour calculer le nombre de possibilité (exemple : 6 lettre = 720 (6*5*4*3*2*1) ), mais je ne sais pas du tout comment faire pour ordonner différemment les lettres et aussi testé à chaque fois (dans une boucle j'imagine) des possibilitées différentes.

    J'aimerais avoir plus d'information pour savoir comment faire cette algorithme, mais je ne veux pas que vous me donniez la solution complète (j'aimerais le coder moi même si se n'est pas au delà de mes compétences... ).

    J'aimerais que le nombre de lettres soit variable, est-ce beaucoup plus compliqué (u niveau de l'ordonnance des lettres) ?

    Merci remercie d'avance ceux qui pourront m'aider.
    • Partager sur Facebook
    • Partager sur Twitter
    Anonyme
      1 septembre 2007 à 16:01:36

      Tout d'abord, commence par voir avec un nombre de lettres fixe, par exemple 3.
      Regarde ce que toi tu ferais pour trouver toutes les possibilités. Personnellement, je commencerais par toutes les combinaisons a**, puis b**, puis c**.
      Puis pour chacune de ces 3 possibilités, par exemple a**, tu vois tout ce qui existe en ab* puis ac*, et tu fais la même chose pour les autres.
      Ainsi, la récursivité apparaît assez nettement.

      Autrement dit, tu auras une fonction dont le prototype ressemblera à ça :

      1. std::vector<std::string> combinaisons(std::string lettres);


      Cette fonction fera appel à elle-même pour trouver toutes les combinaisons possibles.

      (je ne sais pas si j'ai été très clair, si ce n'est pas le cas, désolé :euh: ).
      • Partager sur Facebook
      • Partager sur Twitter
        1 septembre 2007 à 17:01:23

        euh, je ne sais pas encore se qu'est un vector...

        Mais, est-ce que tu veux dire de faire un fonction de ce type :

        1. char lettre[3] = {'a','b','c'};
        2. int c = 2; // je fais débuter la 3ième lettre à "c"
        3. int b= 1;// je fais débuter la 2ième lettre à "b"
        4. for(int a=0; a<=2; a++) // Teste les 3 possibilité de la première lettre
        5. {
        6.     if(b == 3) // si la variable b dépasse la lettre "c", je la met à "a"
        7.     {
        8.         b = 0;
        9.     }
        10.     if(c == 3) // même chose pour la variable c
        11.     {
        12.         c = 0;
        13.     }
        14.     if(a != b && a != c && b != c) // Simple protection pour ne pas avoir "aaa" par exemple
        15.     {
        16.         cout << lettre[a] << lettre[b] << lettre[c] << endl;
        17.         system("PAUSE");
        18.     }
        19.     c++;
        20.     b++;
        21. }


        C'est le mieux que j'ai fait avec une boucle, mais je veux essayer de trouver tout les résultats (je n'en ai que 3/6).

        Voici se que ce code donne en console :

        abc
        Appuyez sur une touche pour continuer...
        bca
        Appuyez sur une touche pour continuer...
        cab
        Appuyez sur une touche pour continuer...
        Press ENTER to continue.


        Si je n'ai pas compris ta technique, peux-tu me l'expliquer avec un exemple (pas besoin d'être très détailé)
        • Partager sur Facebook
        • Partager sur Twitter
        Anonyme
          1 septembre 2007 à 17:08:38

          Déjà, ta fonction me semble assez bizarre o_O . Ensuite, ton but premier était de pouvoir étendre à autant de lettres que tu veux, ce que tu ne pourras pas faire avec ton sytème.
          Un std::vector, c'est simplement une classe de tableau dynamique fournie par la SL, ce qui est très pratique dans notre cas, où on ne connaît pas à l'avance le nombre de combinaisons (en fait, ce serait gérable autrement, mais pourqoi s'embêter à réinventer la roue ?).

          Pour ce que je souhaitais faire, ça va être assez difficile à expliquer...

          En fait, je te proposais de faire une fonction récursive (=qui fait appel à elle-même) qui détermine toutes les combinaisons possibles. Son foncionnement est assez simple : s'il y a au moins 2 lettres passées en paramètre, alors on met successivement toutes les lettres en première position et on passe les autres au prochain appel de la fonction. S'il n'y a qu'une lettre en paramètre, on la renvoie immédiatement.

          Je sais que je ne suis pas clair, c'est assez dur à expliquer (ou alors je ne suis pas pédagogue ^^ ). Il faudrait que je te fasse carrément un code, mais dans ce cas tu n'apprends rien...
          • Partager sur Facebook
          • Partager sur Twitter
            1 septembre 2007 à 17:16:38

            Juste pour être sur de se que tu me dis, la fonction s'autoappelerait quand la première lettre sera fini

            exemple :

            ----> appelle la fonction une première fois
            abc
            acb
            ----> appelle la fonction de nouveau
            bac
            bca
            ----> appelle la fonction de nouveau
            cab
            cba
            ----> termine la fonction...


            J'ai plusieurs questions...
            Je sais comment appeller une fonction à partir de cette même fonction, mais comment lui dire de changer la première lettre (j'envoie un paramètre qui indique la lettre où je suis rendu ???).

            Comment essayer toutes les possibilité avec la première lettre : a**, b**, c** (une suite de boucles ???)

            Comment dire à la fonction de se finir quand toutes les possibilité sont fair(je pourrais incrémenter une variable à chaque fois qu'une possibilité est faite et quand toutes les possibilité sont faite (exemple :3 lettre 6 (3*2*1) ), je termine le programme...)

            EDIT : la prototype que tu m'as donné, Code::Block me donne une erreur, expected constructor, destructor, or type conversion before '<' token
            • Partager sur Facebook
            • Partager sur Twitter
            Anonyme
              1 septembre 2007 à 17:21:34

              Non, ce n'est pas comme ça que je le voyais.

              En fait, si tu as 3 lettres, la première fonction va faire une boucle de 3 tours.

              A chacun des tours, elle place les lettre en première position (a**, b** puis c**), puis elle s'auto-appelle en donnant les 2 autres lettres:

              -----> Appel de la fonction
              a** ---> Appel de la fonction avec "bc", ce qui nous donne "bc" et "cb" comme possibilités : on concatène avec "a", donc ça nous donne abc et acb.
              b** ---> Pareil avec "ac".
              c** ---> Pareil avec "ab".
              -----> Fin de la fonction

              Pour "changer la première lettre", eh bien à la première fonction, tu passes "abc" en paramètre. Puis elle-même va successivement passer "bc", "ac" puis "ab" en paramètre.

              Pour déterminer quand toutes les possibilités sont faites, si tu as bien codé, ça se fera tout seul, car la fonction aura tout parcouru de manière exhaustive.
              • Partager sur Facebook
              • Partager sur Twitter
                1 septembre 2007 à 17:32:32

                Je ne vois vraiment pas comment faire ça, j'ai de la difficulté à comprendre. Je comprend un peu le principe, mais je ne sais pas comment le coder.

                Je ne vois pas comment le faire "dynamiquement", c'est-à-dire que les lettres peuvent changer (pas seulement avec abc)

                Disons que je pars du début :
                Je met mes 3 lettres (abc) dans un tableau
                1. char lettre[3] = {'a','b','c'} // Ici je n'ai qu'a demander les lettres à l'utilisateur pour "dynamiser" mon programme


                J'ai essayer de faire la fonctions mais je n'y arrive pas, je pense à la manière d'agir pour le premier tour, mais en faisant cela, je limite les prochains tour (si tu comprend se que je veux dire)...

                J'aimerais bien que tu me montre ton code car je ne crois pas y arriver tout seul, si ça ne te dérange pas trop.

                P.S.: C'est le premier programme que je fais en C++ "tout seul" (sans les cours du site), je ne me suis pas pratiqué assez puisque j'utilisait toujours le C (que je trouve plus simple)...
                • Partager sur Facebook
                • Partager sur Twitter
                Anonyme
                  1 septembre 2007 à 17:36:31

                  Tu ne vois pas comment le faire dynamiquement parce que tu n'utilises pas les outils formidables fournis par la SL : par exemple, j'ai fait vite fait un code qui répond à ta question, mais je n'utilise pas un tableau de char comme tu le fais, j'utilise std::string pour stocker les lettres possibles.
                  De même, pour stocker toutes les combinaisons possibles, j'utilise les tableaux dynamiques std::vector.

                  Avec std::string par exemple, c'est très simple de supprimer une lettre. Si tu sais qu'elle est en position i, tu fais simplement str.erase(i, 1);
                  Avec std::vector, pour rajouter une possibilité, un simple ret.push_back(str) suffit.

                  Si tu le souhaite, je peux te montrer mon code, mais bon, ça t'apprendrais beaucoup moins que de le faire par toi-même ;) .

                  EDIT: désolé si je t'ai en quelque sorte coupé la parole, c'était pour réagir déjà sur le début de ta réponse :-° .


                  Je dois être rouillé, je n'arrive plus à expliquer clairement...

                  EDIT² : à ta demande, voilà mon code, par contre, ne prends pas trop exemple dessus, je ne pense qu'il soit optimisé/propre :-° :

                  1. #include <iostream>
                  2. #include <vector>
                  3. #include <string>
                  4. std::vector<std::string> combinaisons(std::string lettres);
                  5. int main()
                  6. {
                  7.     std::vector<std::string> combi = combinaisons("abc");
                  8.     /* Boucle pour afficher toutes les possibilites */
                  9.     for(std::vector<std::string>::iterator it = combi.begin() ;
                  10.             it != combi.end() ; it++)
                  11.         std::cout << *it << std::endl;
                  12.         return 0;
                  13. }
                  14. std::vector<std::string> combinaisons(std::string lettres)
                  15. {
                  16.     /* Le vector qui sera renvoya au final */
                  17.     std::vector<std::string> ret;
                  18.     if(lettres.size() == 1)
                  19.     {
                  20.         /* Il n'y a qu'une seule lettre, on la renvoie */
                  21.         ret.push_back(lettres);
                  22.     }
                  23.     else
                  24.     {
                  25.         /* On parcourt toutes les lettres */
                  26.         for(size_t i = 0 ; i<lettres.size() ; i++)
                  27.         {
                  28.             std::string str(lettres);
                  29.             std::vector<std::string> r;
                  30.             /* On enleve la lettre en cours de la string a passer */
                  31.             str.erase(i, 1);
                  32.             /* Recursivite */
                  33.             r = combinaisons(str);
                  34.             /* Boucle pour rajouter les possibilites trouvees au vector
                  35.                 a renvoyer */
                  36.             for(std::vector<std::string>::iterator it = r.begin() ;
                  37.                     it != r.end() ; it++)
                  38.                 ret.push_back(lettres[i]+(*it));
                  39.         }
                  40.     }
                  41.     return ret;
                  42. }


                  Retour :

                  abc
                  acb
                  bac
                  bca
                  cab
                  cba
                  Process returned 0 (0x0)   execution time : 0.046 s
                  Press any key to continue.
                  • Partager sur Facebook
                  • Partager sur Twitter
                    1 septembre 2007 à 17:57:59

                    Je ne comprend pas les trucs de la SL, mais je vais m'acheter un livre sur le C++ dans les prochains jour donc je vais pouvoir le comprendre dans certains temps...
                    Même si il ne me sera pas utile tout de suite, je vais essayer de l'observer et je vais finir par le comprendre, j'en suis sûr.

                    Merci de m'avoir aidé à résoudre mon problème.
                    • Partager sur Facebook
                    • Partager sur Twitter

                    Possibilité d'ordonnance des lettres...

                    × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                    × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                    • Editeur
                    • Markdown