Partage
  • Partager sur Facebook
  • Partager sur Twitter

Exercices tableaux et fonction

fonction sommetableau

    12 juin 2021 à 18:27:22

    On ajoute habituellement qu'être fainéant, ça demande un peu de travail pour s'organiser.

    Ca me faisait penser au montage d'un meuble Ikea. Un débutant va vider toutes les pièces en vrac, pourquoi s'embêter je suis pas un pro du montage, lol, et s'apercevoir plus tard qu'il n'y a pas le bon nombre de vis de la bonne taille à une étape, parce qu'il a confondu avec les plus petites et les a utilisé à autre chose sans faire gaffe.

    Si on s'y prend bien, on déballe, on fait des petits tas qui correspondent à la notice, et APRES, on monte. Ca demande un peu de travail de préparation, mais c'est rentabilisé très rapidement, parce que démonter pour remonter, c'est beaucoup plus de boulot. Les petits tas au début, c'est pas pour faire joli.

    -
    Edité par michelbillaud 12 juin 2021 à 19:04:01

    • Partager sur Facebook
    • Partager sur Twitter
      12 juin 2021 à 18:57:00

      Le pire est que dans les faits, j'ai été confronté à un problème similaire. Je n'avais pas le mode d'emploi pour le montage.
      J'ai fait comme tu as dit. J'ai séparé les pièces et je les ai compté.
      Il faut réfléchir à ce dont on dispose et ce dont on a besoin et ne pas se lancer tête baissée.
      Écrire du pseudo-code ou tout simplement des phrase pour expliquer ce qu'on veut faire aide grandement.
      Faire des schéma ou des dessins est très bon également.
      Autrefois, on nous faisait dessiner des organigrammes avec des triangles, des rectangles, et des losanges. Pas besoin d'aller aussi loin.
      L'important est d'utiliser un mode de représentation avec lequel on est confortable et qui correspond à notre mode de pensée.t
      • Partager sur Facebook
      • Partager sur Twitter

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

        15 juin 2021 à 16:11:42

        J'ai refait tout le cours dès le début, oui j'aime bien souffrir mdr, je comprends pas trop pourquoi autant de message pour prévenir que les pointeurs sont un concept super difficile à assimiler, parce que personnellement je ne l'ai pas trouvé plus difficile que d'autre chapitre, par contre dès le chapitre des tableaux, là ça se complique clairement, enfin encore une fois pour moi qui débute.

        D'ailleurs j'ai essayé de refaire les exercices sur les tableaux, j'ai réussi à refaire pour obtenir la somme sans revenir voir ici sur le forum, donc c'est déjà ça lol.

        Par contre pour la moyenne j'ai écrit une fonction, elle renvoie bien la moyenne, mais les chiffres après la virgule sont toujours des 0... sûrement une erreur idiote de ma part mais bon j'arrive pas à savoir laquelle, je mets le code, j'ai mis directement pourquoi j'ai écrit telle ou telle ligne dans les commentaires du code.

        #include <stdio.h>
        #include <stdlib.h>
        #include <math.h>
        #include <time.h>
        #include "main.h"
        
        double moyenneTableau(int tableau[], int tailleTableau);
        
        int main(int argc, char *argv[])
        {
            int tableau[4] = {8,42,61,845}; //initialisation tableau
            printf("%f%", moyenneTableau(tableau, 4)); //affiche resultat
        
            return 0;
        }
        
        double moyenneTableau(int tableau[], int tailleTableau) {
        
            int i; somme = 0; /*j'initialise la variable i et la somme car
            j'en ai besoin pour faire la moyenne*/
            double moyenne = 0.0; //j'initialise la variable moyenne
        
            for (i = 0; i < tailleTableau; i++) {
                somme = somme + tableau[i];
            } //boucle pour faire la somme de tous les valeurs du tableau
        
            moyenne = somme / tailleTableau; // calcul de la moyenne
        
            return moyenne;
        
        }

        Encore une fois, c'est possible que pour vous, j'ai écrit des horreurs lol, mais je fais quasiment tout en autodidacte avec le cours du site, je n'ai aucune formation là-dedans ni rien.

        Comme on m'a dit j'aurai pu partir de ma fonction "sommeTableau", ça simplifierai grandement les chose, mais j'essaie de refaire en partant de rien pour m'entrainer à réfléchir, justement. Parce que si chaque fois je copie-colle les codes du site ou du forum, c'est un peu trop simple.

        EDIT : bon je crois avoir trouvé finalement mdr, fallait juste que somme soit un type "double" aussi (je crois....)

        -
        Edité par SébastienTellier 15 juin 2021 à 16:14:45

        • Partager sur Facebook
        • Partager sur Twitter
          15 juin 2021 à 16:29:24

          rouloude a écrit:

          Et quand tu divises un entier par un entier le résultat et forcement un entier et donc il est tronqué en entier.

          donc l'entier 3 converti en double ça fait 3.0000

          Effectivement pour que le résultat soit un double, il faut que au moins une des deux opérande soit un double. (si ce sont des entiers, il y a la possibilité de faire un transtypage (cast) sur une des deux opérandes).

          • Partager sur Facebook
          • Partager sur Twitter
            15 juin 2021 à 17:17:14

            > m'entrainer à réfléchir, justement. Parce que si chaque fois je copie-colle les codes du site ou du forum, c'est un peu trop simple.
            Comme je l'ai dit, un bon programmeur est fainéant (pas nécessairement vrai ...)
            Il faut t'entrainer à réfléchir sur les moyens d'écrire le moins de code possible et utiliser du code qui fonctionne.
            En utilisant une fonction déjà écrite et supposée correcte, tu réduis le risque de faire de nouveaux bugs.
            Si ta fonction a un bug, tu le corrige à un seul endroit.
            • Partager sur Facebook
            • Partager sur Twitter

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

              15 juin 2021 à 17:18:21

              C'est super dur de réorganiser toutes les valeurs par ordre croissants sans indication autre que le prototype de la fonction...
              • Partager sur Facebook
              • Partager sur Twitter
                15 juin 2021 à 17:21:04

                SébastienTellier a écrit:

                C'est super dur de réorganiser toutes les valeurs par ordre croissants sans indication autre que le prototype de la fonction...

                Bienvenu dans le monde merveilleux de l'informatique et de l'algorithmique :)

                La première question que l'on doit se poser est : comment est-ce que je le ferais à la main ? comment faire si on a des cartes numérotées devant soi et qu'on doive les trier ?

                Alors ? Comment ferais-tu ?

                • Partager sur Facebook
                • Partager sur Twitter
                  15 juin 2021 à 17:28:24

                  SébastienTellier a écrit:

                  C'est super dur de réorganiser toutes les valeurs par ordre croissants sans indication autre que le prototype de la fonction...


                  Oui en fait cet exercice arrive trop vite dans le cours, avant d'avoir consolidé, par une brouette d'exercices, les notions de

                  • parcours "bête" d'un tableau d'un bout à un autre.
                  • découpage d'un problème en fonctions, passage de paramètres.
                  La difficulté prématurée sur la moyenne vient aussi d'un exercice mal conçu : si l'exercice précédent avait demandé de faire la somme d'un tableau de réels et non d'entiers, on ne s'embrouillerait pas dans un problème annexe.
                  Le cours a été fait par quelqu'un qui ne connaissait pas très bien C, et qui n'avait jamais eu le bonheur d'enseigner pour constater les trucs stupides qui causent des difficultés aux débutants au mauvais moment.
                  > Parce que si chaque fois je copie-colle les codes du site ou du forum, c'est un peu trop simple.
                  Et surtout ça ne t'apprend rien. Copier-coller tu savais, quant à apprendre à programmer, c'est comme apprendre à jouer de la guitare en regardant les autres faire sans pratiquer. Et quand on te demande de jouer un petit morceau, t'es mal.

                  -
                  Edité par michelbillaud 15 juin 2021 à 17:38:18

                  • Partager sur Facebook
                  • Partager sur Twitter
                    15 juin 2021 à 17:30:05

                    Oui sauf que je sais où est la carte la plus petite au premier coup d'oeil pour commencer par la mettre en premier (ordre croissant).

                    Là c'est comme si les cartes étaient de dos et que je ne puisse pas les voir, car si je veux une fonction qui marche pour tous les tableaux, je sais pas où est situé la valeur la plus petite à l'avance...

                    je sais pas si je suis très clair désolé, j'ai tenté un truc avec des "tableau[i] et tableau[i+1]" mais je crois pas que ça soit faisable de cette façon lol

                    • Partager sur Facebook
                    • Partager sur Twitter
                      15 juin 2021 à 17:39:42

                      SébastienTellier a écrit:

                      Oui sauf que je sais où est la carte la plus petite au premier coup d'oeil pour commencer par la mettre en premier (ordre croissant).

                      Là c'est comme si les cartes étaient de dos et que je ne puisse pas les voir, car si je veux une fonction qui marche pour tous les tableaux, je sais pas où est situé la valeur la plus petite à l'avance...

                      je sais pas si je suis très clair désolé, j'ai tenté un truc avec des "tableau[i] et tableau[i+1]" mais je crois pas que ça soit faisable de cette façon lol


                      Alors d'un point de vue algorithmique ( = la manière de procéder) avec des cartes face cachée tu pourrais par exemple :

                      • retourner chaque carte l'une après l'autre et te souvenir où se trouve la plus grande ;
                      • une fois toutes les cartes parcourues, échanger la plus grande avec celle en dernière position ;

                      Quand tu as fais ça tu es certain d'avoir la plus grande carte à la fin

                      Il faut donc recommencer cette procédure entre la première carte et l'avant-dernière.

                      Ensuite tu fais ça tant que tu as des cartes à retourner.

                      Est-ce que tu comprends comment faire ? est-ce que cela te convainc qu'à la fin tu auras quelque chose de trié ?

                      • Partager sur Facebook
                      • Partager sur Twitter
                        15 juin 2021 à 17:42:12

                        SébastienTellier a écrit:

                        Oui sauf que je sais où est la carte la plus petite au premier coup d'oeil pour commencer par la mettre en premier (ordre croissant).

                        Là c'est comme si les cartes étaient de dos et que je ne puisse pas les voir, car si je veux une fonction qui marche pour tous les tableaux, je sais pas où est situé la valeur la plus petite à l'avance...

                        On le sait pas à l'avance, mais on peut le trouver.

                        Pour trouver la carte la plus petite, c'est pas tout à fait d'un seul coup d'oeil, puisqu'il faut les regarder TOUTES.

                        Et pour les regarder toutes, on fait une  [......].

                        ----

                        Maintenant qu'on sait trouver la plus petite, on peut l'amener au debut du tableau, en première position.

                        Mais alors qu'est-ce que qu'on fait de ce qui était en première position ?

                        ----

                        Maintenant qu'on a placé le premier au bon endroit, qu'est-ce qu'on fait pour le second ?

                        ----

                        Plus généralement, quand on en a placé un certain nombre, comment en fait pour le suivant ?

                        Et donc pour les placer toutes on fait une [......].

                         ---

                        les histoires de tableau[i] et tableau[i+1], tu as vu ça dans l'algorithme que tout le monde recopie bêtement, qui s'appelle le tri à bulles. Qui est un mauvais algorithme de plus.

                        Laisse tomber, et construit ton programme à partir d'un RAISONNEMENT, pas en bricolant des bouts de code chopés ici ou là.

                        -
                        Edité par michelbillaud 15 juin 2021 à 17:47:37

                        • Partager sur Facebook
                        • Partager sur Twitter
                          15 juin 2021 à 18:04:48

                          Pas du tout j'ai chopé aucun code nul part, d'ailleurs je sais même pas si on trouve ce genre de code quelque part. Mais c'est le premier truc qui m'est venu lol.

                          Je réessaierai l'exercice ce soir avec vos explications

                          • Partager sur Facebook
                          • Partager sur Twitter
                            15 juin 2021 à 18:25:18

                            Alors, White Crow et michelbillaud, ne repartez pas votre petite guéguerre ...
                            White Crow préconise de trouver le plus grand et le placer en dernier.
                            michelbillaud préconise de trouver le plus petit et de le placer en premier.
                            OK, pour moi, pas de problème. Mais pour un débutant, est-ce que ça embrouille?
                            Et pour information, ça s'appelle un tri par sélection, et on peut en trouver plusieurs versions sur le web ...
                            • Partager sur Facebook
                            • Partager sur Twitter

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

                              15 juin 2021 à 18:28:43

                              J'ai beau réfléchir (bon certes j'ai pas réfléchi 2 jours ni 2 semaines, depuis tout à l'heure..) mais je vois même pas un début de comment faire...

                              Ça me semble évident de passer par une boucle "for", qui revient à retourner les cartes si on reprends la même image, mais je vois pas comment celle-ci me permet de mettre la plus petite valeur "de côté" pour la déplacer en première

                              EDIT : on est d'accord que j'ai besoin de condition "if" (sinon c'est que je suis vraiment à côté de la plaque lol)

                              -
                              Edité par SébastienTellier 15 juin 2021 à 18:33:01

                              • Partager sur Facebook
                              • Partager sur Twitter
                                15 juin 2021 à 18:28:58

                                PierrotLeFou a écrit:

                                Alors, White Crow et michelbillaud, ne repartez pas votre petite guéguerre ...

                                rhôôôôô, nous n'avons jamais été en guéguerre, nous avons juste discuté avec passion.

                                PierrotLeFou a écrit:

                                [...]
                                OK, pour moi, pas de problème. Mais pour un débutant, est-ce que ça embrouille?
                                Et pour information, ça s'appelle un tri par sélection, et on peut en trouver plusieurs versions sur le web ...

                                Bonne question … je ne sais pas et je ne suis pas pédagogue pour un sou (pour trois ptêt :) ). Disons que je pense que le plus simple pour comprendre tout ça c'est de le faire réellement à la main avant, quitte à découper de petits cartons (ou utiliser un jeu de cartes).
                                 

                                Edit:

                                SébastienTellier a écrit:

                                [...]

                                Ça me semble évident de passer par une boucle "for", qui revient à retourner les cartes si on reprends la même image, mais je vois pas comment celle-ci me permet de mettre la plus petite valeur "de côté" pour la déplacer en première

                                Il faut te souvenir où elle se trouve pour ensuite pouvoir l'échanger …

                                se souvenir de ⇒ créer une variable qui va contenir la position du minimum …

                                -
                                Edité par White Crow 15 juin 2021 à 18:30:50

                                • Partager sur Facebook
                                • Partager sur Twitter
                                  15 juin 2021 à 18:40:22

                                  dans le cours on me dit que la taille ne peut pas dépendre d'une variable, ou plutôt que si mais qu'en gros faut pas le faire.

                                  D'ailleurs ça aussi ça embrouille.... je sais pas si le C est très facile comme premier langage lol

                                  EDIT : je vois déjà pas comment déterminer quel est la plus petite de tous le tableau, difficile de mettre sa position en mémoire....

                                  -
                                  Edité par SébastienTellier 15 juin 2021 à 18:44:04

                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                    15 juin 2021 à 18:55:51

                                    SébastienTellier a écrit:

                                    [...]

                                    D'ailleurs ça aussi ça embrouille.... je sais pas si le C est très facile comme premier langage lol

                                    définitivement non. D'autres langages sont plus accessibles au débutant (comme python par exemple).

                                    SébastienTellier a écrit:

                                    [...]

                                    EDIT : je vois déjà pas comment déterminer quel est la plus petite de tous le tableau, difficile de mettre sa position en mémoire....

                                    -
                                    Edité par SébastienTellier il y a 3 minutes


                                    C'est ce qu'on appelle un algorithme classique. On présente souvent les algorithmes sous forme de ce qu'on appelle du pseudo-code, c'est un mélange entre le français (ou l'anglais) et un langage de programmation. Par exemple :

                                    algo Recherche_Minimum( T : tableau d'entiers, n : entier qui est la taille du tableau ) ⇒ l'indice du  plus petit élément
                                    début
                                    
                                        indice_du_minimum = 0
                                    
                                        pour i de 1 à n-1 faire
                                            si T[i]<T[indice_du_minimum] alors
                                                indice_du_minimum = i
                                    
                                        renvoyer indice_du_minimum
                                    
                                    fin.

                                    Ici l'idée est simple : pour un tableau qui contient au moins un élément, on commence au début du tableau et a priori le premier élément du tableau est le plus petit rencontré jusque là. Ensuite on parcourt le reste du tableau et si pendant le parcourt on trouve un élément plus petit  que le plus petit rencontré jusque là alors on se souviens de la nouvelle position.

                                    L'algorithme est le même quel que soit le langage que tu choisis par la suite.

                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                      15 juin 2021 à 19:00:22

                                      La taille telle que définiepour ce tableau ne devrait pas être une variable (pas conseillé).
                                      Mais si tu passes la taille à une fonction, ça peut être une variable et tu peux la vérifier.
                                      Essaies une boucle du début jusqu'à la fin et conserve l'indice de l'élément le plus grand
                                      Mais comment je sais quel est le plus grand au départ?
                                      Je suppose que le plus grand est le premier (indice=0) et je commence à chercher à partir du deuxième (indice=1)
                                      Commence par ça.
                                      • Partager sur Facebook
                                      • Partager sur Twitter

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

                                        15 juin 2021 à 19:10:26

                                        J'ai absolument rien compris, j'imagine que c'est pas facile et clairement j'aurai sûrement pas fait mieux si j'étais l'auteur du cours (ça c'est sûr d'ailleurs lol) mais bon là pour le coup c'est totalement raté, on a absolument pas le niveau de faire ça en suivant juste le cours.

                                        Et ce même en réfléchissant 2 ans, l'idée va pas me venir comme par miracle, j'ai écrit plein de truc mais j'ai l'impression que ce sont des aberrations.

                                        En tous cas pour moi faut forcément à un moment ou un autre que j'écrive des choses genre "tableau[tailleTableau]", etc... ce que je n'ai pas le droit de faire si j'en crois le cours

                                        PierrotLeFou: désolé je n'ai vu ton message que après avoir écrit ça

                                        Soyons fou, je vais quand même mettre mon horrible code ici lol (je pense) parce que de toutes façons je vois pas comment faire donc je n'ai rien à perdre :

                                        #include <stdio.h>
                                        #include <stdlib.h>
                                        #include <math.h>
                                        #include <time.h>
                                        #include "main.h"
                                        
                                        void ordonnerTableau(int tableau[], int tailleTableau);
                                        
                                        int main(int argc, char *argv[])
                                        {
                                            int i;
                                            int tableau[3] = {7,3,5};
                                            for (i = 0; i < 3; i++) {
                                                printf("%d\n", tableau[i]);
                                            }
                                            printf("\n\n");
                                            ordonnerTableau(tableau, 3);
                                            for (i = 0; i < 3; i++) {
                                                printf("%d\n", tableau[i]);
                                            }
                                            return 0;
                                        }
                                        
                                        void ordonnerTableau(int tableau[], int tailleTableau) {
                                        
                                            int i, derniere_valeur = 0;
                                            derniere_valeur = tableau[tailleTableau-1];
                                           for (i = 0; i < tailleTableau; i++) {
                                        
                                                if (tableau[0] > tableau[i]) {
                                                    tableau[tailleTableau-1] = tableau[0];
                                                    tableau[0] = derniere_valeur;
                                                }
                                           }
                                            }
                                        

                                        Si je dis pas de bêtise, ce code va bien mettre la premiere valeur du tableau en derniere position si c'est la plus grande valeur, et la premiere valeur sera remplacée par la dernière (ici 5), parce qu'il faut bien que je la conserve cette valeur, mais bon voilà, après je vois pas comment faire

                                        -
                                        Edité par SébastienTellier 15 juin 2021 à 19:25:57

                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                          15 juin 2021 à 21:07:30

                                          Concernant la taille des tableaux, tu dois comprendre qu'il y a deux tailles :

                                          • la taille du tableau en mémoire, qui est constante ;
                                          • la taille réellement utilisée par les éléments, qui est variable, et toujours inférieur ou égale à la taille en mémoire.

                                          Exemple : j'ai besoin d'un tableau pour stocker les notes d'un élève.

                                          • Taille en mémoire : 50, car je suis certain qu'ils n'auront jamais plus de 50 notes dans l'année.
                                          • Taille utilisée : au début de l'année ce sera 0, puis cette taille sera incrémentée à chaque note. À la fin de l'année, elle vaudra peut-être 18, quelque chose comme ça.

                                          Déclaration :

                                          float tab_notes[50] ;    // taille 50 : une constante littérale
                                          int nombre_notes = 0 ;   // nombre de notes, au début 0

                                          Important : il faut stocker le nombre de notes dans une variable entière à côté du tableau et mettre à jour cette variable. (La notion de structure donne un moyen plus pratique de faire ça, ce sera pour un prochain chapitre...)

                                          Pour calculer la moyenne, ce n'est pas par 50 qu'il faut diviser la somme des notes, mais par nombre_notes.

                                          Pour ajouter une note, il faut la mettre à l'indice nombre_notes (à condition que ce soit < 50) puis incrémenter nombre_notes. Par exemple s'il y avait 3 notes, aux indices 0, 1, 2, on met la 4ème à l'indice 3, et on dit qu'il y a désormais 4 notes. Taille en mémoire : 50, taille utilisée : 4.

                                          -
                                          Edité par robun 15 juin 2021 à 21:13:14

                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                            15 juin 2021 à 21:33:01

                                            Est-ce que ça m'aide pour l'exercice ? Ou c'est plutôt une information ?

                                            Parce que perso je ne vois toujours pas comment faire pour l'exercice du coup, j'ai réussi tous les autres, avec votre aide, mais pour celui-là, j'y arrive tellement pas que je me demande si l'auteur a bien les "yeux en face des trous" quand il dit que c'est faisable avec ce qu'on sait jusqu'ici mdr...

                                            EDIT : est-ce que je peux mettre un "for" dans un autre "for", j'y avais pensé mais je me suis dit que c'était nul lol, et j'ai quand même fait une recherche rapide dans google, premier code je vois ça... c'est une bonne idée selon vous ?

                                            -
                                            Edité par SébastienTellier 15 juin 2021 à 21:38:00

                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                              15 juin 2021 à 21:49:53

                                              Je me vois en le lançant chez moi non ?
                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                                15 juin 2021 à 21:53:45

                                                SébastienTellier a écrit:

                                                Est-ce que ça m'aide pour l'exercice ? Ou c'est plutôt une information ?

                                                J'espérais que ça t'aide à ne pas être embrouillé (comme tu le disais plus haut) par le fait que la taille d'un tableau ne doit pas être une variable.

                                                • Partager sur Facebook
                                                • Partager sur Twitter
                                                  15 juin 2021 à 21:55:02

                                                  Je peux toujours espérer que la nuit porte conseil mais j'y crois pas trop^^

                                                  Bref du coup vu que l'exercice est impossible avec ce qu'on sait à ce moment, visiblement... est-ce qu'on peut poursuivre le cours sans savoir faire ça ?

                                                  D'après ceux qui l'ont lu ? Ou est-ce que c'est même pas la peine ? Parce que perso j'aurai bien aimé réussir quand même avant de poursuivre.

                                                  -
                                                  Edité par SébastienTellier 15 juin 2021 à 22:07:45

                                                  • Partager sur Facebook
                                                  • Partager sur Twitter
                                                    15 juin 2021 à 22:18:14

                                                    Pour commencer doucement, je te propose ces exercices progressifs, qui serviront à écrire le tri final.

                                                    Il s'agit d'écrire des fonctions qui lisent un tableau déclaré dans le 'main'. Exemple :

                                                    int tab[] = {2, 4, -1, 10, -3, 5}

                                                    Voici les prototypes des fonctions à écrire :

                                                    1)

                                                    void affiche(int tab[], int n);
                                                    // Affiche les n éléments du tableau tab
                                                    // Cette fonction devra être utilisée pour contrôler
                                                    // tous les résultats des autres fonctions

                                                    2)

                                                    void permute(int tab[], int n, int i, int j);
                                                    // Permute les éléments d'indice i et j du tableau tab ayant n éléments.

                                                    3)

                                                    int chercheminimum(int tab[], int n);
                                                    // Retourne l'indice du plus petit élément du tableau
                                                    // tab contenant n éléments.

                                                    4)

                                                    void deplaceminimum(int tab[], int n);
                                                    // Cherche le plus petit élément du tableau tab qui contient
                                                    // n éléments, et le place en première position du tableau
                                                    // après avoir permuté avec l'ancien premier élément.
                                                    // Ex : {2, 4, -1, 10, -3, 5} devient {-3, 4, -1, 10, 2, 5}
                                                    //                      ^ le plus petit

                                                    5)

                                                    void deplaceminimum_2(int tab[], int n, int a, int b);
                                                    // Comme précédemment, mais en se limitant au sous-tableau
                                                    // compris entre les indices a et b.
                                                    // Exemple : {2, 4, -1, 10, -3, 5}. Si a = 2 et b = 4, on
                                                    // appliquera la fonction précédente seulement au sous-tableau
                                                    // {-1, 10, -3} (éléments n°2, 3, 4).
                                                    // Résultat : {-3, 10, -1}

                                                    L'algorithme courant pour ordonner un tableau utilise ces fonctionnalités (pour trouver le k-ème plus petit élément, on cherche le plus petit du sous-tableau k à n et on permute pour le placer en position k, et ainsi de suite). [En fait, comme les indices commencent à 0, il faut remplacer les positions k par k-1 et n par n-1.]

                                                    -
                                                    Edité par robun 15 juin 2021 à 22:22:18

                                                    • Partager sur Facebook
                                                    • Partager sur Twitter
                                                      15 juin 2021 à 22:21:10

                                                      SébastienTellier a écrit:

                                                      Je me vois en le lançant chez moi non ?


                                                      Il faut cliquer sur le lien … sinon il n'y a rien qui se passe.

                                                      SébastienTellier a écrit:

                                                      Je peux toujours espérer que la nuit porte conseil mais j'y crois pas trop^^

                                                      Bref du coup vu que l'exercice est impossible avec ce qu'on sait à ce moment, visiblement... est-ce qu'on peut poursuivre le cours sans savoir faire ça ?

                                                      D'après ceux qui l'ont lu ? Ou est-ce que c'est même pas la peine ? Parce que perso j'aurai bien aimé réussir quand même avant de poursuivre.

                                                      -
                                                      Edité par SébastienTellier il y a 10 minutes

                                                      C'est pas que c'est impossible. Mais c'est clair qu'il faudrait quelques bases en algo.

                                                      • Partager sur Facebook
                                                      • Partager sur Twitter
                                                        15 juin 2021 à 22:25:00

                                                        J'ai trouvé un code sur le net, bon j'avoue ça aurait clairement été mieux de chercher et trouver moi-même mais bon je suis en partie rassuré sur le fait que mon idée de mettre un "For" dans un autre "For" n'était visiblement pas mauvaise.

                                                        Bon perso je comprends pas pourquoi il fonctionne le code, mais je vais regarder pour essayer de comprendre.

                                                        Merci pour les exercices, je vais regarder aussi.

                                                        Je comprends mieux pourquoi les solutions ne sont pas données ni expliquées dans le cours...

                                                        Ce code fonctionne mais bon, je me demande bien pourquoi :

                                                        void ordonnerTableau(int tableau[], int tailleTableau) {
                                                        
                                                            int i, j, c = 0;
                                                        
                                                            for (i = 0; i < tailleTableau-1; i++) {
                                                            for (j = i + 1; j < tailleTableau; j++) {
                                                                if (tableau[i] > tableau[j]) {
                                                                    c = tableau[i];
                                                                    tableau[i] = tableau[j];
                                                                    tableau[j] = c;
                                                                }
                                                            }

                                                        En fait je me demande s'il n'y a pas assez de détail dans le cours pour mieux comprendre analyses les algorithmes, où si je comprends juste rien à rien.



                                                        -
                                                        Edité par SébastienTellier 15 juin 2021 à 22:44:10

                                                        • Partager sur Facebook
                                                        • Partager sur Twitter
                                                          15 juin 2021 à 23:14:26

                                                          SébastienTellier a écrit:

                                                          Je peux toujours espérer que la nuit porte conseil mais j'y crois pas trop^^

                                                          Bref du coup vu que l'exercice est impossible avec ce qu'on sait à ce moment, visiblement... est-ce qu'on peut poursuivre le cours sans savoir faire ça ?

                                                          La programmation ça consiste à, de temps en temps,  inventer des solutions à des problèmes. Pas seulement  appliquer ce qu'on sait déjà faire.

                                                          C'est pour ça que ça ne sert pas à grand chose de montrer les solutions. Se faire déposer sur une montagne par hélicoptère, ça n'apprend pas à escalader.

                                                          Le probleme c'est que la marche à grimper est plus ou moins haute. Un algo de tri, c'est pas impossible mais c'est un peu beaucoup pour un  débutant qui est encore encombré par des petits soucis.

                                                          Pour les deux boucles imbriquées, l'idée est en effet excellente.

                                                          Dans la solution que je soufflais, qui est le tri par sélection (Un classique, forcement) il y a une boucle qui consiste à mettre dans la première case le plus petit élément, dans la 2ieme le plus petit de ce qui reste, dans le 3ieme pareil etc.

                                                          Et ça fait appel à une autre boucle dont le rôle est de regarder à chaque etape qui est le plus petit de ce qui reste.

                                                          J'en dis pas plus.

                                                          -
                                                          Edité par michelbillaud 15 juin 2021 à 23:20:38

                                                          • Partager sur Facebook
                                                          • Partager sur Twitter
                                                            16 juin 2021 à 2:45:58

                                                            Si tu n'as pas peur de mettre des printf() dans ton code, je te suggère ceci:
                                                            + d'abord, fais un test de tri avec un petit tableau, disons 3 ou 4 éléments seulement.
                                                            + dans un premier temps, fais un printf de  i  et  tableau[i] avant la boucle sur j
                                                            + dans un second temps, fais un printf de i, tableau[i], j, tableau[j] juste avant le test
                                                            Pour  te simplifier la tache, voici une petite fonction qui te permettra d'afficher tout le tableau sur une seule ligne:
                                                            -
                                                            void affiche(int tableau[], int taille) {   // Ça tient sur une ligne si les nombres sont petits et la taille est petite.
                                                                printf("tableau[%d] = { ", taille);   // Début de la ligne.
                                                                for(int i = 0; i < taille; i++) {
                                                                    printf("%d ", tableau[i]);   // Ne pas oublier l'espace après le %d
                                                                }
                                                                printf("}\n");   // Fin de la ligne.
                                                            }
                                                            -
                                                            Tu n'as qu'à appeler cette fonction où tu veux dans les boucles, je te suggère après la boucle sur j (entre les deux } )
                                                            • Partager sur Facebook
                                                            • Partager sur Twitter

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

                                                            Exercices tableaux et fonction

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