Code tirer d'un algorithme

a marqué ce sujet comme résolu.

Bonjour à tous.

Vu que je n’était pas assez habile avec certains code du site j’ai repris l’étude des algorithmes pour me facilité la tâche et pouvoir mieux appréhender le code, j’ai donc écris un code tirer d’un exercice d’algorithme de mon livre mais je n’arrive pas bien à le mettre en code, bien que tout mon code soit semble t’il correcte au niveau du std::size dans ma fonction cela bug je ne comprend pas pourquoi si quelqu’un pourrait m’éclairer cela serrai très sympas merci.

Voici le code en question:

#include <iostream>

double calculeMoyenne(double tab[3][3],int l, int c);

int main()
{
    double tab[3][3];
    double resu{0};
//Saisir les valeurs dans le tableau
    std::cout <<"Veuillez saisir des valeurs : ";
    for (int i{0}; i < std::size(tab); i++)
    {
        for (int j{0}; j < std::size(tab[j]); j++)
        {
            std::cin >> tab[i][j];
        }
    }
//Afficher le résultat de la fonction 
    for (int i{0}; i < std::size(tab); i++)
    {
        for (int j{0}; j < std::size(tab[j]); j++)
        {
            resu = calculeMoyenne(tab,i,j);
        }
    }
    std::cout <<"voici le resultat :" << resu <<std::endl;

}

//Fonction qui calcule la moyenne des notes entrée dans le tableau
double calculeMoyenne(double tab[3][3], int l, int c)
{
    double moy{0.0};
    double resu{0.0};

    for (int l{0}; l < std::size(tab[l]); l++)
    {
        for (int c{0}; c < std::size(tab[c]); c++)
        {
            moy += tab[l][c];
            resu = moy / std::size(tab[c]);  //sa bug ici
        }
        
    }
    

    return resu;
}

Je vous remercie d’avance passé une bonne soirée.

+0 -0

Quelques warnings :

prog.cc:11:22: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare]
    for (int i{0}; i < std::size(tab); i++)
                   ~ ^ ~~~~~~~~~~~~~~
prog.cc:13:26: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare]
        for (int j{0}; j < std::size(tab[j]); j++)
                       ~ ^ ~~~~~~~~~~~~~~~~~
prog.cc:19:22: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare]
    for (int i{0}; i < std::size(tab); i++)
                   ~ ^ ~~~~~~~~~~~~~~
prog.cc:21:26: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare]
        for (int j{0}; j < std::size(tab[j]); j++)
                       ~ ^ ~~~~~~~~~~~~~~~~~
prog.cc:36:14: warning: declaration shadows a local variable [-Wshadow]
    for (int l{0}; l < std::size(tab[l]); l++)
             ^
prog.cc:31:45: note: previous declaration is here
double calculeMoyenne(double tab[3][3], int l, int c)
                                            ^
prog.cc:38:18: warning: declaration shadows a local variable [-Wshadow]
        for (int c{0}; c < std::size(tab[c]); c++)
                 ^
prog.cc:31:52: note: previous declaration is here
double calculeMoyenne(double tab[3][3], int l, int c)
                                                   ^
prog.cc:41:26: warning: implicit conversion from 'size_t' (aka 'unsigned long') to 'double' may lose precision [-Wimplicit-int-float-conversion]
            resu = moy / std::size(tab[c]);  //sa bug ici
                       ~ ^~~~~~~~~~~~~~~~~
prog.cc:31:45: warning: unused parameter 'l' [-Wunused-parameter]
double calculeMoyenne(double tab[3][3], int l, int c)
                                            ^
prog.cc:31:52: warning: unused parameter 'c' [-Wunused-parameter]
double calculeMoyenne(double tab[3][3], int l, int c)
                                                   ^
prog.cc:36:22: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare]
    for (int l{0}; l < std::size(tab[l]); l++)
                   ~ ^ ~~~~~~~~~~~~~~~~~
prog.cc:38:26: warning: comparison of integers of different signs: 'int' and 'size_t' (aka 'unsigned long') [-Wsign-compare]
        for (int c{0}; c < std::size(tab[c]); c++)
                       ~ ^ ~~~~~~~~~~~~~~~~~
11 warnings generated.

En les corrigeant, ca corrige (sauf erreur de ma part) ton problème. (Ou tout au moins, comprendre un truc qui ne va pas).

Il y a aussi des choses qui sont bof en termes de C++ (utilise std::array)

Ton algo est sensé faire quoi exactement ? Comment tu sais qu’il n’est pas correct ?

+0 -0

Merci à tous d’avoir répondu voici l’exercice qu’il demande :

je vous propose un nouvelle exercice: il s’agit de saisir les notes reçues à l’école par quatre enfants pour ensuite calculer leurs moyenne il est nécessaire de créer une fonction permettant de calculer la moyenne d’un tableau de notes, passé en paramètre, peu importe sa taille.

+0 -0

Tu ne peux pas utiliser std::size() sur un paramètre de type double tab[42][42]. C’est à mon avis pour cela que tu fais des trucs bizarres en l’appelant sur la l-ieme ligne. Ca n’a pas de sens par rapport à ce que tu écris.

Le pourquoi n’est AMA pas à ton niveau pour l’instant: c’est des histoires à la noix de typage imparfait hérité du C. Bref: des saletés sans la moindre importance. juste retenir pour l’instant: "c’est pas possible" et "le C fait des trucs bizarres avec les paramètres tableaux (dont le C++ a hérité)"

Garde les structures présentées dans le tuto/cours de ZdS: à savoir les std::array. Mais … l’énoncé semble dire qu’il y a des nombres quelconques… Auquel cas il faut un std::vector<std::vector<note>>. (j’ai la flemme de parler des std::span qui sont le paramètre parfait pour une fonction qui s’appelle moyenne).

Merci à tous pour vos retour.

Réponse à elegance : Pour ce qui est de répondre à l’exercice demandé exactement je n’ai pas pris en compte les 4 enfants, et pour ce qui est du nombre de notes je ne sais pas il semble dire que cela n’a pas d’importance sauf si j’ai pas compris l’énoncé.

réponse à Gil Cot : oui je n’ai pas tout fait respecté l’exercice j’ai pas pris en compte les 4 enfants mais j’ai quand même un programme fonctionnelle sauf pour le std::size sur le tableau par contre quand je met 9 pour diviser par 9 j’ai pas bonne réponse et mon code fonctionne mais je voulais savoir pourquoi std::size ne fonctionnais pas..

Réponse à lmghs : Ah ok je ne savais pas j’ai repris cette fonction car dans la réponse de l’exercice de l’algorithme il utilise cette fonction pas de la même façon que moi j’en conviens mais il l’utilise alors je voulais voir comment faire pour récupérer la taille du tableau pour diviser moy.

voila l’algo :

Fonction calculMoyenne(tab : tableau entier)
variables
   moyenne <- 0
//calcule la moyenne
pour i allant de 0 taille(tab) - 1 par pas de 1 faire
   moyenne <- moyenne / taille(tab)
finpour
moyenne <- moyenne / taille(tab) //ici il fait ce que j'essaye de faire dans le code que j'ai fais
retourner moyenne
FIN

Algorithme exerciceTableauMulti
variables
   nootes[n][n] : tableau entier
DEBUT
   notes [
            [12,14,16],
            [11,5],
            [17,18,10,12],
            [12,10,13]
         ]

pour i allant de 0 a taille(notes) - 1 par pas de 1 faire
    Afficher "la moyenne du " i + 1, " ème enfant est : " , calculMoyenne(tab[i])
fin pour
FIN
    
+0 -0

Dans ton algo : tu as une boucle (lignes 5 à 7) qui fait la somme des notes, puis tu calcules ensuite (ligne 8) avant de la renvoyer (ligne 9)
Dans ton code : tu as bien la boucle pour faire la somme des notes (lignes 38 à 42), mais le calcul de la moyenne n’est pas faite après la boucle (elle est ligne 41) …ce qui est déjà un algo un peu différent (en terme de gestion d’erreurs)
Pour continuer à dévier de l’algorithme, ta boucle (lignes 38 à 42) est dans une autre (lignes 36 à 44) ; cela n’aide pas.

+0 -0

Dans ton dernier travail, tu pars sur cette interprétation de l’énoncé : on a plusieurs élèves, chaque élève a plusieurs notes, et pour chaque élève, on doit calculer la moyenne de ses notes. Ok. C’est peut-être ce qui est demandé. Si l’énoncé parle de leurs moyennes (avec s à leurs et à moyennes), c’est ça. S’il parle de leur moyenne (sans s à leur ni moyenne), alors ce n’est pas ça.

Je pense que tu pourrais commencer plus simple : On a plusieurs notes (un élève, plusieurs épreuves, ou plusieurs élèves, une seule note par élève), et il faut calculer la moyenne de ces notes.

Et ensuite, tu pourras adapter.

Excusez moi petite erreur je rectifie :

Fonction calculMoyenne(tab : tableau entier)
variables
   moyenne <- 0
//calcule la moyenne
pour i allant de 0 taille(tab) - 1 par pas de 1 faire
   moyenne <- moyenne + tab[i] 
finpour
moyenne <- moyenne / taille(tab) //ici il fait ce que j'essaye de faire dans le code que j'ai fais
retourner moyenne
FIN

Algorithme exerciceTableauMulti
variables
   nootes[n][n] : tableau entier
DEBUT
   notes [
            [12,14,16],
            [11,5],
            [17,18,10,12],
            [12,10,13]
         ]

pour i allant de 0 a taille(notes) - 1 par pas de 1 faire
    Afficher "la moyenne du " i + 1, " ème enfant est : " , calculMoyenne(tab[i])
fin pour
FIN
+0 -0

C’est un 'algorithme’, donc on a beaucoup de tolérance sur la syntaxe. Disons que c’est ok, mais je suis certainement beaucoup beaucoup trop tolérant. Maintenant, il faut traduire ça en langage de programmation. Et là, plus droit à l’erreur, toutes les petites impasses que j’ai laissé passer vont certainement ressortir.

Bonsoir à tous.

Bon j’ai réussi à faire ce que je voulais avec mon programme :-) voici le code pour ceux que cela intéresse. Bonne soirée/journée à tous et merci pour votre aide.

#include <iostream>

double calculeMoyenne(double tab[2][3],int l, int c);

int main()
{
    double tab[2][3];
    double resu{0};
//Saisir les valeurs dans le tableau
    std::cout <<"Veuillez saisir des valeurs : ";
    for (int i{0}; i < std::size(tab); i++)
    {
        for (int j{0}; j < std::size(tab[j]); j++)
        {
            std::cin >> tab[i][j];
        }
    }
//Afficher le résultat de la fonction 
    for (int i{0}; i < std::size(tab); i++)
    {
        for (int j{0}; j < std::size(tab[j]); j++)
        {
            resu = calculeMoyenne(tab,i,j);
        }
    }
    std::cout <<"voici le resultat :" << resu <<std::endl;

}

//Fonction qui calcule la moyenne des notes entrée dans le tableau
double calculeMoyenne(double tab[2][3], int l, int c)
{
    double moy{0.0};
    double resu{0.0};

    for (int l{0}; l < std::size(tab[l]); l++)
    {
        
        for (int c{0}; c < std::size(tab[c]); c++)
        {
            
            moy += tab[l][c]; 
        }
    }
        
    c++;
    l++;
    resu = moy / (l * c);
    
    return resu;
}
+0 -0

J’imagine que ça fonctionne, mais il y a plein de choses à redire.

L’instruction en ligne 23 est exécutée plusieurs fois. Tu calcules la moyenne plusieurs fois. En clair : tu calcules resu, puis tu calcules resu ( a priori, tu trouves le même résultat), etc, et après avoir calculé resu 6 fois, tu affiches le résultat du dernier calcul.

Même si le résultat affiché par ton programme est correct, je pense que tu auras une très mauvaise évaluation sur cet exercice.

Tu n’as pas vu std::array, mais tu as vu std::size? WTF? C’est particulièrement improbable. Tu suis quel livre/cours?

Bref si tu ne veux pas utiliser std::array, alors n’utilise pas std::size ainsi… car tu demandes à chaque fois combien il y a de colonnes: d’abord sur la ligne l, puis sur la ligne c. Et donc les deux fois sur fais une boucle sur le nombre de colonnes et ce n’est pas ce que tu veux faire!

Tu n’as pas vu std::array, mais tu as vu std::size? WTF? C’est particulièrement improbable. Tu suis quel livre/cours?

Bref si tu ne veux pas utiliser std::array, alors n’utilise pas std::size ainsi… car tu demandes à chaque fois combien il y a de colonnes: d’abord sur la ligne l, puis sur la ligne c. Et donc les deux fois sur fais une boucle sur le nombre de colonnes et ce n’est pas ce que tu veux faire!

lmghs

Je l’ai dit plus haut que j’ai repris l’étude d’un livre d’algorithme et dans le livre il parlais de la fonction taille(tab) par exemple et vu que j’avais déjà vu std::size() dans la section des tableau j’ai seulement repris cette fonction pour l’employé pour résoudre mon exercice d’algorithme … mais je n’ai pas vu la totalité des tableau j’ai arrêter avant d’arriver à std::array … Mais la je vais reprendre les cours car j’ai fini mon livre d’algo.

+0 -0

Je l’ai dit plus haut que j’ai repris l’étude d’un livre d’algorithme et dans le livre il parlais de la fonction taille(tab) par exemple et vu que j’avais déjà vu std::size() dans la section des tableau j’ai seulement repris cette fonction pour l’employé pour résoudre mon exercice d’algorithme … mais je n’ai pas vu la totalité des tableau j’ai arrêter avant d’arriver à std::array … Mais la je vais reprendre les cours car j’ai fini mon livre d’algo.

Si j’ai bien compris, tu vas à la pêche. Tiens ceci pourrait être utile, donc je le prend …

Si vraiment la fonction doit accepter un nombre variable d’élèves et pour lesquels tu ne connais pas le nombre de notes au départ, il me semble que std::vector<std::vector<double>> serait approprié.

Si en plus le nombre de notes n’est pas le même pour tous les élèves, ça sera encore plus approprié.

On dit toujours que Google est notre ami … mais il faut en user judicieusement.

Je l’ai dit plus haut que j’ai repris l’étude d’un livre d’algorithme et dans le livre il parlais de la fonction taille(tab) par exemple et vu que j’avais déjà vu std::size() dans la section des tableau j’ai seulement repris cette fonction pour l’employé pour résoudre mon exercice d’algorithme … mais je n’ai pas vu la totalité des tableau j’ai arrêter avant d’arriver à std::array … Mais la je vais reprendre les cours car j’ai fini mon livre d’algo.

Si j’ai bien compris, tu vas à la pêche. Tiens ceci pourrait être utile, donc je le prend …

Si vraiment la fonction doit accepter un nombre variable d’élèves et pour lesquels tu ne connais pas le nombre de notes au départ, il me semble que std::vector<std::vector<double>> serait approprié.

Si en plus le nombre de notes n’est pas le même pour tous les élèves, ça sera encore plus approprié.

On dit toujours que Google est notre ami … mais il faut en user judicieusement.

PierrotLeFou

Non je ne vais pas à la pêche je fais avec ce que j’ai appris pas ce que je n’ais pas appris et std::array je ne l’a pas encore vu, … par contre on vois std::size avant std::array dans le cours de zeste donc voila je n’ai pas été jusqu’au bout des tableaux pour pouvoir utilisé array…

La vous me compliqué avec votre double vector lol… je suis juste au début des tableaux dans zeste donc c’est notion double vector me sont encore inconnue ….

+0 -0
Connectez-vous pour pouvoir poster un message.
Connexion

Pas encore membre ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte