Partage
  • Partager sur Facebook
  • Partager sur Twitter

Exercices tableaux et fonction

fonction sommetableau

    16 juin 2021 à 8:35:40

    J'étais sur le point d'écrire que j'avais beau mettre par écrit je comprenais toujours pas, et du coup en voulant rédiger le message j'ai fini par retrouver la même chose que le programme lol, donc je suis pas sûr d'avoir compris toutes les subtilités non plus mais c'est déjà un petit pas en avant.

    Je pense que les boucles imbriquées m'ont bien embrouillée, et à mon avis c'est une notion complexe clairement, en tous cas je parle pour un débutant.

    En fait c'est tout simplement qu'il faut penser qu'on entre dans la boucle sur i, mais que i ne s'incrémentera que quand on sortira de la boucle sur j.

    Je comprends un tout petit peu mieux la comparaison avec les cartes maintenant. Bon clairement vu la difficulté que j'ai eu, faudrait que je trouve d'autres exos pour m'entrainer...

    • Partager sur Facebook
    • Partager sur Twitter
      16 juin 2021 à 10:46:05

      SébastienTellier a écrit:

      Je pense que les boucles imbriquées m'ont bien embrouillée, et à mon avis c'est une notion complexe clairement, en tous cas je parle pour un débutant.

      En fait c'est tout simplement qu'il faut penser qu'on entre dans la boucle sur i, mais que i ne s'incrémentera que quand on sortira de la boucle sur j.

      Je comprends un tout petit peu mieux la comparaison avec les cartes maintenant. Bon clairement vu la difficulté que j'ai eu, faudrait que je trouve d'autres exos pour m'entrainer...

      S'embrouiller : c'est là où la notion de fonction peut aider.  Une fonction, c'est une manière de donner un nom à une suite d'instructions pour pouvoir l'appeler d'ailleurs. Et de séparer les difficultés.

      Par exemple, dans le tri par sélection, dans la version "commençons par le premier", le pseudo code de la boucle principale est du genre

      pour i de 0 à taille-1 {
          déménager dans tableau[i] le plus petit élément 
              de tableau[i]...tableau[taille-1]
      }
      



      là on rentre pas dans le détail des opérations qu'il faudra faire pour déménager (etc). Ca nous soulage d'un tas de complications, qu'on verra plus tard.

      Déjà on peut coder ce bout-là, qui fait la moitié du boulot :

      void trier_par_selection(int tableau[], int taille)
      {
          for (int i = 0; i < taille; i++) {
               demenager(tableau, taille, i);
          }
      }
      
      // avec
      void demenager(int tableau[], int taille, int position);
      

      Ensuite, pour déménager il faut

      - trouver l'indice du plus petit élément
           parmi tableau[position]...tableau[taille-1];
      - échanger les contenus de tableau[position] et tableau[indice]
      

      Y a qu'a pas s'embêter, on en fait des fonctions

      void demenager(int tableau[], int taille, int position) {
          int indice = indice_du_minimum(tableau, taille, position);
          échanger_contenus(tableau, indice, position);
      }


      Bref, on y allant calmement, en décomposant tranquillement, on y arrive très bien. Une difficulté à la fois.

      En fait le problème des débutants, c'est de s'imaginer que le saint esprit va leur dicter le code directement. Ca peut être l'impression quand on voit en direct faire quelqu'un qui sait programmer, ou qu'on regarde une solution toute faite. Mais derrière, c'est le travail de décomposition qui est important, et qu'il faut apprendre à faire. Parce qu'il faut vraiment très peu de choses pour s'embrouiller si on ne s'organise pas.


      PS: en gros, un débutant complet en programmation, il lui faut 2-3 mois en moyenne pour arrêter de s'embrouiller avec des algorithmes  où il y a une boucle et un test (recherche d'une valeur, du plus petit, du plus grand, etc), donc faut pas s'inquièter sur le tri.

      En Psychologie de la Programmation (si si, ça existe, et c'est un domaine passionnant), les chercheurs utilisent souvent le RainFall problem qui est de ce type pour mesure les compétences des programmeurs (ou des formateurs :-))

      > Ecrire un programme qui traite une série de nombres (entiers positifs) qui représentent des mesures de plus, jusqu'à tomber sur la valeur 999999. Le programme doit afficher la moyenne des nombres rencontrés avant le 999999.

      Le Résultat Vous Surprendra : “In one study, only 14% of students in Yale’s CS1 could solve this problem correctly"

      Oups. Un sur sept.

      Et c'est une observation assez générale,

      “The general conclusion is that large numbers of students are still making the same sorts of error that they were making 30 years ago.”


      https://www.curriculumonline.ie/getmedia/8bb01bff-509e-48ed-991e-3ab5dad74a78/Seppletal-2015-DoweknowhowdifficulttheRainfallProblemis.pdf


      Il faut certes relativiser, CS1 c'est un cours d'initiation à la programmation pour non informaticiens, traditionnellement vécu comme inintéressant avec une catastrophe garantie le jour de l'exam. Mais quand même.

      -
      Edité par michelbillaud 16 juin 2021 à 11:11:49

      • Partager sur Facebook
      • Partager sur Twitter
        16 juin 2021 à 11:04:49

        Voilà, c'est ça le secret : décomposer le problème en sous-problèmes, en partant du plus global, et ensuite on écrit les détails.

        Par exemple pour écrire Windows, c'est tout simple :

        exit = false;
        while (!exit)
        {
            etat = lire_etat();  // en fonction de là où est la souris, si on a cliqué, etc.
            if (etat == 0)       // j'ai noté 0 l'état "exit"
                exit = true ;
            else
                traitement(etat);
        }

        Ensuite on s'occupera de la fonction 'lire_etat' puis de la fonction 'traitement', chacun étant décomposée à son tour...
        (J'ignore complètement si Windows ressemble à ça, c'est juste pour illustrer le principe.)

        -
        Edité par robun 16 juin 2021 à 11:05:43

        • Partager sur Facebook
        • Partager sur Twitter
          16 juin 2021 à 11:10:47

          robun a écrit:

          [...]

          (J'ignore complètement si Windows ressemble à ça, c'est juste pour illustrer le principe.)

          -
          Edité par robun il y a moins de 30s


          Certainement lol

          Toute boucle d'évènements ressemble plus ou moins à ça, du simple des REPL (Read/Eval/Print/Loop) comme bash ou bc jusqu'au plus gros de GUI. C'est l'essence même d'un OS si on pousse le bouchon un peu loin :

          Tant qu'il a des tâches à exécuter faire
              exécuter la tâche qu'il faut
          Fin tant que

          D'où les fameuse tâche Idle pour ne rien faire quand il n'y à rien à faire.

          • Partager sur Facebook
          • Partager sur Twitter
            16 juin 2021 à 11:55:07

            robun a écrit:

            (J'ignore complètement si Windows ressemble à ça, c'est juste pour illustrer le principe.)

            C'est le principe, si tu as vu des codes Windows directement écrit avec les fonctions de API Win32, tu as vu cette boucle qui ressemble à la tienne :

                while (GetMessage(&msg, NULL, 0, 0))
                {
                    DispatchMessage(&msg);
                }

            Sans rentrer trop dans les détail : GetMessage est la fonction qui va lire et extraire les messages dans ce qu'on appelle la file d'attente des messages. (Pour tout événement qui ce passe Windows génère un message et le dépose dans la file d'attente). La fonction DispatchMessage l'envois à ce qu'on appelle la procédure de fenêtre de la fenêtre à qui il est destiné. (La procédure de fenêtre est une fonction callback où tu programme les actions en fonction du message qu'elle reçoit).

            GetMessage est une fonction bloquante, s'il ne ce passe rien, il n'y a donc pas de message dans la file d'attente, elle attend qu'il y en ai un. Elle renvoi toujours true sauf si elle extrait le message WM_QUIT qui dans ce cas met fin à la boucle et en général à l'application.

            • Partager sur Facebook
            • Partager sur Twitter
              16 juin 2021 à 12:18:58

              Je ne veux pas vous vexer mais les 4 derniers message m'embrouillent justement encore plus qu'autre chose^^.

              Mais bon si je reprend l'exemple des cartes, le code revient à :

              -Retourner la première

              -Retourner la 2ème

              -Si valeur de la 2ème supérieur je la remets à sa place sinon je la place devant tout en me rappelant la valeur de la première

              -Puis recommencer en retournant la première (qui est donc maintenant l'ancienne 2ème si on a inversé lol)

              Bon OK, même dans mes explications je m'embrouille^^. Bref, quand j'ai commencé à m'intéresser à la programmation, je m'attendais clairement pas à ce que ce soit facile, mais je m'attendais pas à ce que faire quelque chose d'aussi simple (trier c'est quand même pas dur de base) soit aussi compliqué.

              Franchement quand je vois ça j'aimerai bien voir le code source de gros logiciels ou alors de gros jeux vidéos, ça doit faire des dizaines de milliers de lignes de code, et surtout ça m'étonne pas qu'il y ait autant de monde qui bosse sur la création d'un jeu même s'il dure 1h lol

              -
              Edité par SébastienTellier 16 juin 2021 à 12:19:47

              • Partager sur Facebook
              • Partager sur Twitter
                16 juin 2021 à 12:26:12

                SébastienTellier a écrit:

                 mais je m'attendais pas à ce que faire quelque chose d'aussi simple (trier c'est quand même pas dur de base) soit aussi compliqué.

                Coder un tri, c'est pas trier, c'est analyser le problème de façon à fournir un code détaillé qui marche dans tous les cas.

                Conduire une voiture c'est pas compliqué, et il faut des millions de lignes de code pour "expliquer" à l'ordinateur ce qu'il doit faire.

                Le tri par sélection, c'est une bricole, une dizaine de lignes. Mais ça suffit pour voir que coder, c'est du boulot.

                -
                Edité par michelbillaud 16 juin 2021 à 12:28:45

                • Partager sur Facebook
                • Partager sur Twitter
                  16 juin 2021 à 12:47:24

                  En même temps ça ne serait pas le métier de certaines personnes si ça se faisait tout seul, mais c'est justement pour ça que j'ai l'impression (je me trompe peut-être) que le cours vend un peu du rêve quand il est écrit qu'à la fin de celui-ci on sera capable de coder un jeu 2D, en fait on sera surtout capable d'affiche "hello word" et éventuellement de coder 2 ou 3 trucs un peu marrant genre calculatrice en mode console ou autre, voilà....

                  Evidemment j'exagère un peu volontairement, mais c'est pour dire que c'est totalement exagéré de dire qu'on sera capable de coder un jeu 2 D, en tous cas pas sans faire d'autres recherches ailleurs, et s'arracher les cheveux jusqu'à ce que ça fonctionne^^.

                  Vous ne connaissez pas un site où on peut trouver d'autres exercices avec des indication et la correction ? Je suis à cours d'inspiration^^, notamment sur les tableaux puisque c'est visiblement là que je commence à galérer

                  • Partager sur Facebook
                  • Partager sur Twitter
                    16 juin 2021 à 13:17:37

                    Je pense que si, à la fin du cours tu sauras écrire un petit jeu 2D. C'est juste que "à la fin du cours" peut prendre du temps, voire ne jamais arriver.

                    SébastienTellier a écrit:

                    Vous ne connaissez pas un site où on peut trouver d'autres exercices avec des indication et la correction ? Je suis à cours d'inspiration^^, notamment sur les tableaux puisque c'est visiblement là que je commence à galérer

                    Tu peux essayer les exercices que je proposais : j'aime bien venir papoter ici donc je peux donner des indications de temps en temps.

                    Tiens, voici une correction du n°3 avec des commentaires :

                    int chercheminimum(int tab[], int n);
                    // Retourne l'indice du plus petit élément du tableau
                    // tab contenant n éléments. On suppose n > 0.
                    {
                        int min_temp = tab[0];     // min_temp = le plus petit élément qu'on a trouvé
                                                   // pour l'instant ("minimum temporaire")
                        for (int i = 1 ; i < n ; i++)
                        {
                            if (tab[i] < min_temp) // si j'ai trouvé plus petit...
                                min_temp = tab[i]; // ...ben du coup c'est lui le min. temp.
                        }
                        return min_temp;           // à la fin, le minimum temporaire, c'est le minimum
                    }

                    -
                    Edité par robun 16 juin 2021 à 13:29:07

                    • Partager sur Facebook
                    • Partager sur Twitter
                      16 juin 2021 à 13:27:17

                      - Faire une fonction qui retourne la plus petite valeur d'un tableau.

                      - Faire une fonction qui retourne l'indice de la plus petite valeur d'un tableau.

                      Edit : je n'avais pas vu la modif de robun. (mais il faut enlever le point virgule fin de ligne 1 !

                      Aussi ton commentaire ne correspond pas à ce que la fonction fait !

                      robun a écrit:

                      // Retourne l'indice du plus petit élément du tableau

                      Or la fonction retourne la plus petite valeur et non pas l'indice de la plus petite valeur. 

                      Mais Sébastien va nous faire celle qui retourne l'indice !

                      -
                      Edité par rouloude 16 juin 2021 à 13:40:13

                      • Partager sur Facebook
                      • Partager sur Twitter
                        16 juin 2021 à 14:04:02

                        >>Mais Sébastien va nous faire celle qui retourne l'indice !

                        je vais essayer ça mdr, et vos autres exercices, je sais pas trop quand, je garantis pas que ça sera aujourd'hui, d'ailleurs même si je cherche à les faire ajd faut encore partir du principe que je réussirai avant la fin de la journée lol

                        • Partager sur Facebook
                        • Partager sur Twitter
                          16 juin 2021 à 14:26:50

                          SébastienTellier a écrit:

                          c'est pour dire que c'est totalement exagéré de dire qu'on sera capable de coder un jeu 2 D, en tous cas pas sans faire d'autres recherches ailleurs, et s'arracher les cheveux jusqu'à ce que ça fonctionne^^.

                          Oui mais bon, le cours de C, c'est truc promotionnel sur un site qui vend des formations.

                          Et pour vendre des formations, il faut dire aux gens que grâce à la formation rapide pas chère amusante et sans douleur, ils sauront tout faire.

                          En réalité, il faut quelques années pour être un programmeur raisonnable, qui en sait assez pour se rendre compte qu'il ne saura jamais tout faire (en plus ça change tout le temps !)

                          -
                          Edité par michelbillaud 16 juin 2021 à 14:27:55

                          • Partager sur Facebook
                          • Partager sur Twitter
                            16 juin 2021 à 14:58:54

                            Je rajouterai que pour un novice, le C n'est peut-être pas le bon premier pas. Programmer en C est très peu interactif. Tu dois éditer un code, le compiler, l'exécuter, ensuite le débuggage est des plus rudimentaires …

                            Avec des premiers pas en Python par exemple, en utilisant un notebook interactif cela devient moins contraignant.

                            • Partager sur Facebook
                            • Partager sur Twitter
                              16 juin 2021 à 15:31:20

                              >>>pour se rendre compte qu'il ne saura jamais tout faire (en plus ça change tout le temps !)

                              Lol, le truc bien frustrant, mais bon ça se retrouve dans tous les domaines.

                              Alors pour en dire un peu plus sur moi, j'ai pas commencé direct sur C, enfin du moins y a très longtemps, quand le site s'appelait encore "siteduzero" (ça date) j'avais déjà suivi le tuto, mais un peu à l'arrache, j'avais pas totalement compris ce que je faisais.

                              Au bout d'un moment j'ai plus ou moins abandonné, j'ai regardé un peu d'autres langages, d'ailleurs qui n'ont strictement rien à avoir, mais ça reste de la programmation, genre Batch, VBScript, VBA, python, puis là je reviens sur C car y a que ici qu'on trouve un cours tout de même bien fait (malgré ce qu'on pourrait croire que je pense) et gratuit.

                              Après je pourrai payer une ou des formation, mais bon ne comptant pas me reconvertir dans ce domaine je pense pas en avoir un vrai intérêt.

                              Voilà c'était juste pour expliquer un peu. Sinon pour les exercices de robun, j'ai fait le premier, heureusement, parce que bon faut quand même pas abuser, si je savais pas faire ça en ayant suivi le cours je pense que je pourrai abandonner tout espoir.

                              Par contre dès le 2ème la solution me saute clairement pas du tout aux yeux.

                              Enfin disons que pour le 2ème exo je suis déjà pas sûr de comprendre l'énoncé (permuter les élément d'indice i et j) est-ce que je dois considérer que j est forcément i+1 ?

                              en fait je crois que j'ai réussi pour retourner le minimum, est-ce que ça semble correct ça ? :

                              int chercheminimum(int tab[], int n) {
                                  int i,j,c = 0;
                                  for (i = 0; i < n-1; i++){
                                      for (j = i + 1; j < n; j++){
                                          if (tab[i] < tab[j]) {
                                              c = tab[i];
                                          }
                                      }
                                      }
                                      printf("%d", c);
                                  }
                              

                              Bon ça ressemble tellement au tri par ordre croissant qu'il y a rien d'extraordinaire à avoir trouver mais bon c'est quand même ça mdr

                              -
                              Edité par SébastienTellier 16 juin 2021 à 15:35:58

                              • Partager sur Facebook
                              • Partager sur Twitter
                                16 juin 2021 à 16:10:20

                                SébastienTellier a écrit:

                                en fait je crois que j'ai réussi pour retourner le minimum, est-ce que ça semble correct ça ? :

                                Oui et non !

                                Comme tu l'as remarqué, la fonction devrait retourner un entier (le minimum) or la tienne ne retourne rien ! (Elle affiche seulement le résultat alors que ce n'est pas son rôle, son rôle c'est de retourner le résultat).

                                Je n'ai pas regardé en détail, mais ce que je peut te dire c'est que pour cet exercice une seule boucle suffit, tu te complique bien la vie avec tes deux boucle.

                                Conclusion, sans être extraordinaire, l'exercice te pose encore des problèmes.

                                • Partager sur Facebook
                                • Partager sur Twitter
                                  16 juin 2021 à 17:03:14

                                  SébastienTellier a écrit:

                                  Enfin disons que pour le 2ème exo je suis déjà pas sûr de comprendre l'énoncé (permuter les élément d'indice i et j) est-ce que je dois considérer que j est forcément i+1 ?

                                  Si c'était forcément i+1, on dirait permuter les éléments d'indice i et i+1.

                                  ---

                                  Il ne faut pas hésiter à se donner des exemples concrets, pour bien comprendre de quoi on cause. Et ça sert aussi à écrire des tests unitaires (une autre lacune de ce cours, par rapport à un enseignement moderne où la place des tests a beaucoup grandi).

                                  Si on part du tableau contenant [ 11, 22, 33, 44, 55]

                                  "permuter les éléments d'indice 1 et 4", ça veut dire que le contenu du tableau devient [11, 55, 33, 44, 22]

                                  indice  0  1  2  3  4
                                  ------ -- -- -- -- --
                                  avant  11 22 33 44 55
                                  après  11 55 33 44 22
                                  


                                  A partir de là on peut raisonner sur l'exemple concret

                                  1. on met de côté la valeur qui est à l'indice 1 (la valeur 22)

                                  2. à l'indice 1, on met une copie de ce qu'il y a à l'indice 4 (55)

                                  3. à l'indice 4, on copie ce qu'on avait mis de côté (22)

                                  et puis on généralise joyeusement, en disant que 1 c'est i, et 4 c'est j.

                                  -
                                  Edité par michelbillaud 16 juin 2021 à 17:10:51

                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                    16 juin 2021 à 17:21:33

                                    rouloude a écrit:

                                    Or la fonction retourne la plus petite valeur et non pas l'indice de la plus petite valeur.

                                    Comme on dit dans ces cas là : c'était pour voir si vous suiviez... ;)

                                    Sébastien : pour retourner l'indice du plus petit élément, inspire-toi de ma fonction qui retournait la valeur du plus petit élément. Si tu as compris ce que fait cette fonction, tu verras que c'est presque pareil.

                                    Et pour comprendre ce que fait cette fonction, prends un bout de papier et un crayon et note pas à pas ce qu'elle fait. Cette méthode est importante, tout le monde l'utilise.

                                    Remarque, on peut aussi mettre plein de 'printf' :

                                    int chercheminimum(int tab[], int n)
                                    // Retourne la valeur du plus petit élément du tableau
                                    // tab contenant n éléments. On suppose n > 0.
                                    {
                                        int min_temp = tab[0];     // min_temp = le plus petit élément qu'on a trouvé
                                                                   // pour l'instant ("minimum temporaire")
                                        for (int i = 1 ; i < n ; i++)
                                        {
                                            printf("tab[%d] = %d\n", i, tab[i]);
                                            printf("    min_temp = %d\n", min_temp);
                                            if (tab[i] < min_temp) // si j'ai trouvé plus petit...
                                            {
                                                printf("    cet élément est plus petit !\n");
                                                min_temp = tab[i]; // ...ben du coup c'est lui le min. temp.
                                                printf("    désormais min_temp = %d\n", min_temp);
                                            }
                                            else
                                            {
                                                printf("    cet élément n'est pas plus petit\n");
                                            }
                                        }
                                        return min_temp;           // à la fin, le minimum temporaire, c'est le minimum
                                    }

                                    -
                                    Edité par robun 16 juin 2021 à 17:31:33

                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                      16 juin 2021 à 18:29:14

                                      Je sais que même sans être extraordinaire ça me pose encore problème (j'aurai dû écrire "rien d'extraordinaire de peut-être avoir trouvé"), c'est exactement la raison pour laquelle je dis que le cours vend un peu trop du rêve, sauf peut-être pour 2 ou 3 exceptions qui ont une logique sur-développée.

                                      C'est aussi pour ça que je suis là et que j'essaie tant bien que mal de faire des exercices, mais surtout, même si j'y arrive, d'essayer de comprendre pourquoi ça marche, ça parait peut-être bête, mais au cours du cours, la première fois que je l'avais suivi, j'ai réussi des exos un peu "par hasard" et ça, ça va pas si je veux progresser un minimum.

                                      Avec une seule boucle je vois pas comment récupérer le minimum, je peux récupérer la première valeur qui est inférieur à celle d'avant et celle d'après (code ci-dessous), mais si j'ai une autre valeur dans le même cas, alors ma fonction récupèrera cette dernière. J'ai pas dit qu'avec 2 boucles j'y arriverai non plus^^ :

                                      int chercheminimum(int tab[], int n) {  // int tab[6] = {2, -54, -1, -10, -3, 5};
                                          int i,j,c = 0;
                                          for (i = 1; i < n-1; i++){
                                            if (tab[i] < tab[i+1] && tab[i] < tab[i-1]) {
                                              c = tab[i];
                                            }
                                      
                                            }
                                            return c;
                                          }


                                      Je n'ai pas regardé ta correction robun pour le moment, parce que j'avais déjà regardé une solution pour le tri, j'aimerai  bien ne pas faire ça chaque fois, si je dois chaque fois copier-coller du code, ça sert à rien d'apprendre à programmer.

                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                        16 juin 2021 à 19:07:09

                                        Et bien à mesure que tu parcours la boucle, tu affectes et conserves la valeur mini dans une variable à part et quand tu as parcouru tout le tableau, ta variable contient la valeur mini, que tu vas donc retourner.
                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                          16 juin 2021 à 20:20:10

                                          SébastienTellier a écrit:

                                          Je n'ai pas regardé ta correction robun pour le moment, parce que j'avais déjà regardé une solution pour le tri, j'aimerai  bien ne pas faire ça chaque fois, si je dois chaque fois copier-coller du code, ça sert à rien d'apprendre à programmer.

                                          Copier-coller ? Pas du tout ! J'ai proposé que tu regardes ma solution, que tu la comprennes, pour ensuite l'adapter. Chercher l'indice du minimum, ça ressemble à chercher la valeur du minimum. Mais ce n'est pas pareil, donc il ne faut pas copier-coller.

                                          À un moment donné il faut bien commencer par quelque chose, tu ne peux pas tout réinventer. Je pense que ça peut être utile de regarder comment font les autres. L'important est d'avoir essayé soi même, par exemple de s'être trompé pour constater que « ah OK, en fait il fallait faire ci et pas faire ça ».

                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                            16 juin 2021 à 21:11:01

                                            Oui tu as raison, c'est vrai que si je tourne en rond dans mon coin sans jamais rien regarder pour m'aider, en soi je serai même pas ici.

                                            En tous cas j'ai d'abord regarder ton code, même si j'aurai préféré trouve comment coder cette fonction par moi-même, surtout qu'une fois que je l'ai vu je me suis dis que c'était vraiment pas si compliqué, demain si j'ai le temps j'essaierai de faire celle qui renvoie l'indice.

                                            Déjà là quand j'ai regardé ta solution, ensuite j'ai effacé tout mon programme et je l'ai ré-écris quelque dizaine de minutes plus tard, même si du coup c'est pas très dur, ça m'aide un peu à mémoriser

                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                              16 juin 2021 à 21:21:32

                                              rouloude a écrit:

                                              Je dirais qu'il n'y a rien de mieux que des images pour illustrer, là tout est clair, on a l'algorithme complet. Merci rouloude.
                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                                17 juin 2021 à 3:15:41

                                                J'ajoute qu'il ne faut pas hésiter à faire des tests, même si ça plante.
                                                Comme aurait dit Edison, ça te fait une façon de plus sur comment ne pas faire les choses ...
                                                Et mon ordi n'a pas encore explosé parce que je fais beaucoup de tests.
                                                Je ne sais pas si la comparaison suivante va t'aider au sujet des boucles imbriquées.
                                                Prend une horloge numérique: Il est 23:41:27
                                                les secondes passent et font le tour, oups! après 59, on retourne à 00. Et tiens! les minutes viennent d'avancer
                                                Et quand elles passent le 59 elles aussi, elles passent à 00 elles aussi et les heures avancent.
                                                La boucle la plus interne, ce sont les secondes, ...
                                                for(int heures = 0; heures < 24; heures++) {
                                                    for(int minutes = 0; minutes < 60; minutes++) {
                                                        for(int secondes = 0; secondes < 60; secondes++) {
                                                            // Tu verras, le temps passe vite avec moi ...
                                                        }
                                                    }
                                                }
                                                En espérant que ça va t'aider au lieu de t'embrouiller. :)
                                                • Partager sur Facebook
                                                • Partager sur Twitter

                                                Le Tout est souvent plus grand que la somme de ses parties.

                                                  17 juin 2021 à 9:40:24

                                                  Dans l'algorithme de tri par sélection, on aura en fait besoin d'une variante de cette fonction (un tout petit peu plus générale), qui cherche (et qui trouve !) l'indice du plus petit élément à partir d'une certaine position de départ dans un tableau d'une certaine taille.

                                                  int indice_du_minimum(int tableau[], int taille, int depart );
                                                  

                                                  cette position n'est 0 qu'au premier coup, quand on cherche de ce qu'il faut amener à la position 0.

                                                  ---

                                                  > j'ai effacé mon programme et je l'ai réécrit.

                                                  Tu sais, ce n'est pas la peine de l'effacer, il suffit que tu le sauves sous un autre nom.

                                                  Un autre truc, c'est de ne pas hésiter à gribouiller avec un papier et un crayon, dont le fonctionnement est nettement plus intuitif qu'un éditeur de textes. Sur le brouillon, on n'est pas obligé d'avoir une syntaxe tout à fait correcte correcte, on peut faire des ratures et revenir dessus etc. Ca permet de réfléchir plus librement. On tape une fois qu'on est à peu près content de ce qu'on a écrit. La programmation, c'est réfléchir, pas taper du code.

                                                  -
                                                  Edité par michelbillaud 17 juin 2021 à 9:58:01

                                                  • Partager sur Facebook
                                                  • Partager sur Twitter
                                                    17 juin 2021 à 20:36:32

                                                    En fait la fonction pour retourner l'indice du plus petit élément d'un tableau, c'est tout simplement ça non ? :

                                                    int afficheIndiceMinimum(int tab[], int n) {
                                                        int i, x = 0;
                                                        x = tab[0];
                                                        for (i = 0; i < n; i++) {
                                                            if (tab[i] < x) {
                                                                x = i;
                                                            }
                                                        }
                                                        return x;
                                                    }

                                                    Je dis tout simplement car j'avais juste à laisse unique "i" au lieu de "tab[i]" en partant de la fonction de robun qui retourne le minimum. Enfin si je me trompe pas ?

                                                    • Partager sur Facebook
                                                    • Partager sur Twitter
                                                      17 juin 2021 à 21:22:50

                                                      SébastienTellier a écrit:

                                                      En fait la fonction pour retourner l'indice du plus petit élément d'un tableau, c'est tout simplement ça non ? 

                                                      Il faut tester ton code avec différents tableaux, et tu verras que malheureusement ça ne fonctionne pas !

                                                      PS : Pourquoi utiliser le mot affiche dans le nom de la fonction, alors qu'elle n'est pas censé afficher quoi que ce soit ?

                                                      • Partager sur Facebook
                                                      • Partager sur Twitter
                                                        18 juin 2021 à 1:38:51

                                                        Je l'ai dit, fais des tests et imprime les valeurs s'il le faut.
                                                        Ici, tu peux imprimer i, x, tab[i], tab[x] et ce que tu retournes juste avant le return.
                                                        S'il n'y a pas de fumée qui sort de ton ordi, tu es correct pour d'autres tests ...
                                                        • Partager sur Facebook
                                                        • Partager sur Twitter

                                                        Le Tout est souvent plus grand que la somme de ses parties.

                                                          18 juin 2021 à 5:22:32

                                                          Cette fois je crois que je l'ai.

                                                          En fait je teste bien les codes, avant de poster, mais je pense que j'avais pas testé avec suffisamment de tableau différent.

                                                          Suite à la réponse de rouloude, j'ai fait d'autres tests et j'ai compris que le code précédent ne fonctionne que si j'ai une valeur minimum, puis après celles-ci, uniquement des valeurs supérieures, donc en gros comme vous me l'avez fait remarqué, il ne fonctionne pas^^.

                                                          J'ai aussi repensé au message de robun qui m'a dit que ça ressemblait à retourner le minimum, et du coup j'ai compris (en tous cas je crois avoir compris) que je devrait insérer la valeur de tab[i] dans x afin que ma boucle "for" ne rencontre plus de valeur inférieur à x en continuant à parcourir le tableau, et utiliser une autre variable pour récupérer la valeur de l'indice.

                                                          Je sais pas si j'explique très bien, donc voici le code que j'ai maintenant :

                                                          int afficheIndiceMinimum(int tab[], int n) {
                                                              int i, x, y = 0;
                                                              x = tab[0];
                                                              for (i = 0; i < n; i++) {
                                                                  if (tab[i] < x) {
                                                                      x = tab[i];
                                                                      y = i;
                                                                  }
                                                              }
                                                              return y;
                                                          }
                                                          

                                                          Pour répondre quant au nom de ma fonction, j'ai mis "affiche" car je me sert de cette fonction pour afficher l'indice du minimum, mais c'est vrai que la fonction en elle-même n'affiche pas l'indice, elle le recherche uniquement. Je pense que c'est pour ça que tu m'as fait remarqué que le nom est mal choisi rouloude ? Je penserai à changer ça aussi et mieux réfléchir aux noms dorénavant.

                                                          • Partager sur Facebook
                                                          • Partager sur Twitter
                                                            18 juin 2021 à 6:19:23

                                                            Ta boucle pourrait commencer à i=1, puisque tab[0] à déjà été pris en compte.

                                                            Tes variables  sont mal nommées. Une des deux contient l'indice du minimum provisoire  l'autre sa valeur. X et y, ça ne permet pas de s'y retrouver. 

                                                            -
                                                            Edité par michelbillaud 18 juin 2021 à 6:19:50

                                                            • Partager sur Facebook
                                                            • Partager sur Twitter

                                                            Exercices tableaux et fonction

                                                            × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                                            • Editeur
                                                            • Markdown