#ifndef MAIN_H_INCLUDED
#define MAIN_H_INCLUDED

int sommeTableau(int tableau[], int tailleTableau)
{
    int a;
    int i;

    for (i = 0; i < tailleTableau; i++)
    {
        a = a + tableau[i];
    }
    printf("%d\n", a);
    return a;
}

double moyenneTableau(int tableau[], int tailleTableau)
{
    double moy = 0;
    int b = sommeTableau(tableau, 4);
    int i = 0;

    printf("%d\n", b);
    for (i = 0; i < tailleTableau; i++)
    {
        moy = b/tableau[i];
    }
    printf("%f\n", moy);

    return moy;
}

#endif // MAIN_H_INCLUDED

//Fichier main.c

#include <stdio.h>
#include <stdlib.h>
#include "main.h"

int sommeTableau(int tableau[], int tailleTableau);

double moyenneTableau(int tableau[], int tailleTableau);

int main()
{
    double res = 0;
    int tableau[4] = {25, 25, 25, 25};

    res = moyenneTableau(tableau, 4);

    printf("%f\n", res);
    return 0;
}

Salut je pense bien que tu devrais initialisé le tableau exp:

Int table[6]={23,22,12,etc};

Maintenant qu'on connait le contenu du tableau et sa taille tu pourras calculer la moyenne

Comment tu calcules une moyenne mathématiquement ? Toi tu calcules la somme du tableau divisé par chaque élément du tableau ! 

Mise à part ça, ta fonction sommeTableau a un problème, c'est que tu ajoutes chaque élément du tableau à une variable (a) qui n'est pas initialisé.

On ne met pas de définitions de fonction dans les fichiers entête (header) !

Tes fonctions sommeTableau et moyenneTableau ne devrait faire que seulement calculer la somme et la moyenne du tableau, l'affichage du résultat devrait se faire en dehors  !

@ AhmadouDiallo18 Il me semble que son tableau est initialisé !

#ifndef MAIN_H_INCLUDED
#define MAIN_H_INCLUDED

int sommeTableau(int tableau[], int tailleTableau)
{
    int a = 0;
    int i = 0;

    for (i = 0; i < tailleTableau; i++)
    {
        a = a + tableau[i];
    }
    return a;
}

double moyenneTableau(int tableau[], double tailleTableau)
{
    return sommeTableau(tableau, 4) / tailleTableau;
}

#endif // MAIN_H_INCLUDED


#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "main.h"

int sommeTableau(int tableau[], int tailleTableau);

double moyenneTableau(int tableau[], double tailleTableau);

int main()
{
    int tableau[4] = {50, 50, 25, 25};

    printf("%f\n", moyenneTableau(tableau, 4));
    return 0;
}

rouIoude a écrit:

Comment tu calcules une moyenne mathématiquement ? Toi tu calcules la somme du tableau divisé par chaque élément du tableau !  

Effectivement j'ai remarqué l'erreur quelques instants après avoir posté le message...

Mise à part ça, ta fonction sommeTableau a un problème, c'est que tu ajoutes chaque élément du tableau à une variable (a) qui n'est pas initialisé.

Je les ai initialisé maintenant, même si cela ne change pas le resultat

On ne met pas de définitions de fonction dans les fichiers entête (header) ! 

Je n'ai pas compris ?

Tes fonctions sommeTableau et moyenneTableau ne devrait faire que seulement calculer la somme et la moyenne du tableau, l'affichage du résultat devrait se faire en dehors  !

Oui c'est pour vérifier les resultats je les enlèves par la suite.

PierrotLeFou a écrit:

L'avantage des fonctions est de ne pas répéter du code inutilement (ni les erreurs d'ailleurs).
La fonction moyenneTableau peut s'écrire très simplement (ne pas oublier qu'on doit faire une division flottante).
double moyenneTableau(int tableau[], int taille) {
    return sommeTableau(tableau, taille) / (double) taille;
}

oui c'est le genre d'aide pertinente que je recherche, merci je vais m'entrainer

Avec votre aide j'ai pu facilement simplifier le code. Je remercie également PierrotLeFou car je ne savais pas que l'ont pouvais faire le calcul directement dans le return.

-
Edité par Torq 21 août 2021 à 9:24:28

BilâlAdanur a écrit:

oui c'est le genre d'aide pertinente que je recherche, merci je vais m'entrainer

Forcement, puisque c'est la solution servi sur un plateau ! 

Sauf que ta fonction à un petit problème :

double moyenneTableau(int tableau[], double tailleTableau)
{
    return sommeTableau(tableau, 4) / tailleTableau;
}

Je te laisse cherché, je te donne comme indice de la tester sur des tableaux de différentes tailles.

Dans un fichier entête ou header comme tu l'appelles, on y met que des déclarations, or toi tu y mets les définitions de fonctions.

Une définition de fonction c'est la portion de code qui contient le code de ta fonction, si on prend l'exemple de ta fonction moyenne alors la définition de fonction c'est :

double moyenneTableau(int tableau[], double tailleTableau)
{
    return sommeTableau(tableau, 4) / tailleTableau;
}

Cette partie de code doit se trouver dans un fichier source, extension .c

La déclaration de la fonction c'est :

double moyenneTableau(int tableau[], double tailleTableau);

C'est elle que l'on met dans les fichier entête ou header, fichier avec l'extention .h 

rouIoude a écrit:

BilâlAdanur a écrit:

oui c'est le genre d'aide pertinente que je recherche, merci je vais m'entrainer

Forcement, puisque c'est la solution servi sur un plateau ! 

Sauf que ta fonction à un petit problème :

double moyenneTableau(int tableau[], double tailleTableau)
{
    return sommeTableau(tableau, 4) / tailleTableau;
}

Je te laisse cherché, je te donne comme indice de la tester sur des tableaux de différentes tailles.

Je pense avoir compris mais depuis un certain moment je suis en train de chercher à comprendre une chose, lorsque je décrémente tailleTableau et que je fais un printf je découvre 10 , je ne comprend absolument pas pourquoi je reçois cette valeur...

J'ai essayé avec différentes boucles, en vain. Si j'ai bien compris dans la boucle FOR je crée une boucle SI pour lorsque i renvois une valeur 0 qu'il réduise tailleTableau de -1 à chaque fois que la boucle for est relancé (car i doit aller de 0 à 15 vu la taille du tableau). Et que les valeur supérieur à 0 sois additionnées... Mais je reçois 10

    printf("%f\n", moyenneTableau(tableau, 16));

Ici lorseque je met (tableau, 16), cela annule l'instruction dans la boucle ??Mais si oui pourquoi je reçois la valeur 10 ?

#include <stdio.h>
#include <stdlib.h>
#include "main.h"

int main()
{
    int tableau[16] = {50, 50, 25, 25};

    printf("%f\n", moyenneTableau(tableau, 16));

    return 0;
}

double moyenneTableau(int tableau[], double tailleTableau)
{
    int i = 0;
    int a = 0;

    for (i = 0; i < tailleTableau; i++)
    {
        if (tableau[i] > 0)
        {
            a = a + tableau[i]; // addition pour pouvoir calculer la moyenne.
        }
        else
        {
            tailleTableau--; //décrémentation de la taille du tableau lorseque la valeur [i] lis un 0 lorsequ'il parcours dans le tableau.
        }

    }

    return a / tailleTableau;
}

-
Edité par Torq 21 août 2021 à 14:12:40

Tu avais 2 problèmes avec ta fonction moyenneTableau
La première est que tu déclares tailleTableau comme double, elle doit être int.
Remarques que je fais le cast dans le return.
L'autre erreur est que tu appelles sommeTableau avec une valeur constante comme longueur.

Tu es entrain de chercher midi à quatorze heurs !

Pourquoi tu décrémentes tailleTableau ? Le tableau que tu envois à la fonction ne change pas de taille en cours d’exécution !

La moyenne d'un tableau c'est la somme de ses éléments divisé par sa taille ! Ce n'est pas plus compliqué que cela ! 

La somme, la moyenne, la copie est effectué pour ma part, je sais calculer une moyenne. D'ailleurs plus haut dans le code on le vois bien la formule dans le return... 

J'en suis à essayer de supprimer les valeurs au delà d'une valeur indiqué dans le tableau.

BilâlAdanur a écrit:

... J'en suis à essayer de supprimer les valeurs au delà d'une valeur indiqué dans le tableau.

Ok, mais il faut le dire, et surtout dans ce cas il ne faut pas appeler ta fonction moyenneTableau ! mais lui donner un nom qui nous fait comprendre ce qu'elle est censé faire !

PierrotLeFou a écrit:

Que veut dire "supprimer"?
Ça peut vouloir les mettre à 0.
Ou tasser les autres valeurs vers le début
exemple: si j'ai [3, 6, 9, 4] et je supprime les valeurs plus grandes que 7, j'aurais [3, 6, 4]
Mais je devrai retourner la nouvelle longueur.

rouIoude a écrit:

BilâlAdanur a écrit:

... J'en suis à essayer de supprimer les valeurs au delà d'une valeur indiqué dans le tableau.

Ok, mais il faut le dire, et surtout dans ce cas il ne faut pas appeler ta fonction moyenneTableau ! mais lui donner un nom qui nous fait comprendre ce qu'elle est censé faire !

-
Edité par Torq 21 août 2021 à 20:02:16

Si ton tableau est [3, 15, 62, 50] après l'appel de ta fonction pour mise à 0 des valeurs >= 50  il devrait être [3, 15, 0, 0].

Il suffit donc juste de mettre la case du tableau à 0 si elle répond au critère. C'est pas plus compliqué que ça !

Et puis, il ne faut peut-être pas aller trop vite, parce que pour l'instant tu n'as pas fait une fonction moyenneTableau correcte.

PierrotLeFou a écrit:

Et il faut être précis dans la définition de sa fonction.
Est-ce supérieur (>) à 50, ou supérieur "ou égal" (>=) à 50?
Et comme dit RouIoude, il faudrait que tu comprennes bien comment faire une moyenne.
Je n'ai pas dit que tu l'as fait, mais il ne suffit pas de faire un copier-coller.

rouIoude a écrit:

Si ton tableau est [3, 15, 62, 50] après l'appel de ta fonction pour mise à 0 des valeurs >= 50  il devrait être [3, 15, 0, 0]. 

oui c'est ça que je doit faire.

Il suffit donc juste de mettre la case du tableau à 0 si elle répond au critère. C'est pas plus compliqué que ça !

Et puis, il ne faut peut-être pas aller trop vite, parce que pour l'instant tu n'as pas fait une fonction moyenneTableau correcte.

Oui je m'entraine toujours sur les tableaux, je n'avance pas plus vite. Je veux bien cerner la logique avant d'avancer, j'ai le temps et ne suis pas pressé.

Je vais refaire la fonction moyenne, je sais faire une moyenne, mais je ne connais pas le C, je l'apprend.

-
Edité par Torq 22 août 2021 à 9:37:05

PierrotLeFou a écrit:

Alors, si je te demandais comment faire une moyenne sur papier?

Une moyenne exemple :

10 , 10, 10 , 10 , 10 , 0 , 0 , 0 = 50 

Divisé par la quantité de nombre : ici il y en à 8 donc 50 / 8 = 6.25

Il y a deux choses que tu manques à mon avis.
Quand tu fais une somme, la longueur du tableau doit être un entier, sinon tu risques d'avoir des problèmes. 
Ensuite, dans une moyenne, tu dois faire une division en nombres réels (float ou double).
Pour ça, il faut qu'au moins un de tes termes soit lui-même réel.
Et que le résultat soit assigné à un réel.

 donc le tableau lui même en char int ou long, la taille du tableau de même, mais le résultat doit etre en float ou double si j'ai bien compris ? Lorsque j'avais fais sa m'avais marqué erreur, (edit: oui sa me met cette erreur : error: invalid operands to binary / (have 'int (*)(int *, int)' and 'int')|)

donc si je doit mettre un terme en réel, il faut qu'à titre d'exemple, je mette à la place de 10, je met 10.00 ? et à ce moment la donnée de tailletableau en double sera exact ?

-
Edité par Torq 23 août 2021 à 17:43:16

BilâlAdanur a écrit:

donc le tableau lui même en char int ou long, la taille du tableau de même, mais le résultat doit etre en float ou double si j'ai bien compris ?

Oui.

BilâlAdanur a écrit:

Lorsque j'avais fais sa m'avais marqué erreur

Ça ne veut pas dire que l'idée était mauvaise, mais qu'elle avait été mal mise en œuvre.

BilâlAdanur a écrit:

donc si je doit mettre un terme en réel, il faut qu'à titre d'exemple, je mette à la place de 10, je met 10.00 ? et à ce moment la donnée de tailletableau en double sera exact ?

Argh, non ! Les éléments du tableau peuvent rester des entiers (ça dépend de ce qu'ils représentent), et la taille du tableau doit forcément être un entier ! C'est seulement la moyenne qui doit obligatoirement être un nombre à virgule.

Maintenant, quand tu divises deux entiers (par exemple la somme des éléments du tableau divisée par le nombre d'éléments), tu peux forcer la division à donner un résultat 'double' en procédant ainsi :

int somme;
int nb_elem;
double moyenne;
/* ... ... ... ... */
moyenne = (1.0 * somme) / nb_elem;    // astuce pour forcer une division à virgules

Ou bien tu mets la somme dans une variable de type 'double' (mais la fonction somme peut continuer à retourner un 'int'). Si c'était moi, c'est ce que je ferais (pas besoin de « cast », pas besoin de l'astuce du 1,0...).

-
Edité par robun 23 août 2021 à 17:46:35

#include <stdio.h>
#include <stdlib.h>
#include "main.h"

int main()
{
    int tab[5]= {16, 45, 30, 20};

    sommeTab(tab, 5);
    moyenneTab(tab, 5);

    printf("%f\n", moyenneTab(tab, 5));
    return 0;
}

double sommeTab(int tab[], int tailleTab)
{
    int i = 0;
    int add = 0;
     for (i = 0; i < tailleTab; i++)
     {
         add = add + tab[i];
     }
     return add;
}


double moyenneTab(int tab[], int tailleTab)
{
    return sommeTab(tab, 5) / tailleTab;
}

#include <stdio.h>
#include <stdlib.h>
#include "main.h"

int main()
{
    int tab[5]= {16, 45, 30, 20};

    sommeTab(tab, 5);
    moyenneTab(tab, 5);

    printf("%f\n", moyenneTab(tab, 5));
    return 0;
}

int sommeTab(int tab[], int tailleTab)
{
    int i = 0;
    int add = 0;
     for (i = 0; i < tailleTab; i++)
     {
         add = add + tab[i];
     }
     return add;
}


double moyenneTab(int tab[], int tailleTab)
{
    return (1.0* sommeTab(tab, 5)) / tailleTab;
}

Les deux tests illustrent bien les deux méthodes, mais le tableau donné en exemple a 4 éléments et tu appelles les fonctions en donnant 5...

Quand tu déclares un tableau, tu ne sais pas à l'avance combien il contiendra d'éléments. Une méthode classique est de surdimensionner le tableau. C'est en fait ce que tu as fait : tu as déclaré un tableau de 5 cases, mais tu n'en as remplies que 4 (la 5ème est mise à 0).

Il y a deux tailles :

• La taille à la déclaration, suffisamment grande pour être sûr d'avoir de la place. Exemple : int tab[1000]
• La taille effective, qui est souvent stockée dans une variable ('tailleTab'). C'est cette taille qu'on passe en paramètre aux fonctions.

La taille à la déclaration ne sert qu'à la déclaration. La taille effective est la « vraie » taille, elle sert partout ailleurs, notamment dans les appels de fonctions.

robun a écrit:

Les deux tests illustrent bien les deux méthodes, mais le tableau donné en exemple a 4 éléments et tu appelles les fonctions en donnant 5...

Ça c'est toi qui le dit :

int tab[5]= {16, 45, 30, 20};

Moi j'en vois 5 : 16, 45, 30, 20, 0 BilâlAdanur aussi puisqu'il trouve le résultat bon.

La multiplication par 1.0 fonctionne mais n'est pas la bonne façon de procéder on fait plutôt un cast (ou transtypage) comme l'a montré Pierrot. 

Pour en revenir au code, ta fonction moyenne à un petit problème, c'est qu'elle ne fonctionne pas pour toute les taille de tableau, je te l'avais dit plus haut, mais tu n'en as pas tenu compte. 

Pour en revenir au code, ta fonction moyenne à un petit problème, c'est qu'elle ne fonctionne pas pour toute les taille de tableau, je te l'avais dit plus haut, mais tu n'en as pas tenu compte. 

Voici qui est mieux ? :

#include <stdio.h>
#include <stdlib.h>
#include "main.h"

int main()
{
    int tab[5]= {16, 45, 30, 20};

    sommeTab(tab, 5);
    moyenneTab(tab, 5);

    printf("%f\n", moyenneTab(tab, 5));
    return 0;
}

int sommeTab(int tab[], int tailleTab)
{
    int i = 0;
    int add = 0;
     for (i = 0; i < tailleTab; i++)
     {
         add = add + tab[i];
     }
     return add;
}


double moyenneTab(int tab[], int tailleTab)
{
    return sommeTab(tab, tailleTab) / (double) tailleTab;
}

robun a écrit:

Il y a deux tailles :

• La taille à la déclaration, suffisamment grande pour être sûr d'avoir de la place. Exemple : int tab[1000]
• La taille effective, qui est souvent stockée dans une variable ('tailleTab'). C'est cette taille qu'on passe en paramètre aux fonctions.

La taille à la déclaration ne sert qu'à la déclaration. La taille effective est la « vraie » taille, elle sert partout ailleurs, notamment dans les appels de fonctions.

aaaaa oui, je viens de nommé tab[1000] et laissé tout les autres paramètres et c'est vrai que sa ma donné le même résultat, intéressant...

EDIT : J'ai même remarqué que je peux directement demander le printf et appeler la fonction directement, je pense que les headers servent à ça, n'empêche qu'on apprend beaucoup en pratiquant...

#include <stdio.h>
#include <stdlib.h>
#include "main.h"

int main()
{
    int tab[1000]= {16, 45, 30, 20};

    printf("%f\n", moyenneTab(tab, 5));
    return 0;
}

int sommeTab(int tab[], int tailleTab)
{
    int i = 0;
    int add = 0;
     for (i = 0; i < tailleTab; i++)
     {
         add = add + tab[i];
     }
     return add;
}

double moyenneTab(int tab[], int tailleTab)
{
    return sommeTab(tab, tailleTab) / (double) tailleTab;
}

-
Edité par Torq 23 août 2021 à 20:51:11

Ok, pour la fonction moyenne, la ça me va !

-
Edité par rouIoude 23 août 2021 à 20:50:46

Voici la copie ci-dessous si vous voyez des choses maladroit ... : 

#include <stdio.h>
#include <stdlib.h>
#include "main.h"

int main()
{
    int tab[1000]= {16, 45, 30, 20}, i = 0, tTab = 10;
    int tab2[1000];


    copie(tab, tab2, 10);

    for (i = 0; i < tTab; i++)
    {
            printf("%d\n", tab2[i]);
    }

    return 0;
}

void copie(int tabOriginal[], int tabCopie[], int tailleTab)
{
    int i = 0;

    for (i = 0; i < tailleTab; i++)
    {
        tabCopie[i] = tabOriginal[i];
    }
}

Néanmoins, j'ai plusieurs questions sur des sujets que je n'ai pas compris malgré qu'en "trifouillant" j'ai pu réussir à obtenir le résultat...

1 -> Pourquoi lorsque je met dans void copie dans la boucle for tabOriginal[i] = tabCopie[i] sa fonctionne pas j'ai cherché 2 heures pour cette erreur que je ne comprend pas encore, il faut mettre la copie = l'original et non l'original = copie, pourquoi ?

2 -> le paramètre dans le fonction void copie(int*, int, int tailleTab) n'est valable que pour cette fonction, du coup j'ai du recréer un tTab dans la fonction main pour afficher la copie, mais est'il possible de se passer d'inscrire manuellement le tTab pour lire et utiliser le 10 dans copie(tab, tab2, 10)     exemple: un pointeur qui puisse cibler l'adresse d'une variable dans une autre fonction (ici tel que dans le void) est il possible ?

-
Edité par Torq 23 août 2021 à 21:40:33

BilâlAdanur a écrit:

Voici la copie ci-dessous si vous voyez des choses maladroit ...

C'est bien comme cela qu'il faut faire.

BilâlAdanur a écrit:

1 -> Pourquoi lorsque je met dans void copie dans la boucle for tabOriginal[i] = tabCopie[i] sa fonctionne pas 

Et bien les créateur du langage C ont décidé que ça serait comme cela : la variable ou constante à droite du = est affecté à la variable situé à gauche du =

Tu écris bien x = 0 et non pas 0 = x

      2) Je n'ai pas compris la question 2

Bonsoir

BilâlAdanur a écrit:

Voici la copie ci-dessous si vous voyez des choses maladroit ... : 

#include <stdio.h>
#include <stdlib.h>
#include "main.h"

#define TAILLE 10

int main()
{
    int tab[TAILLE]= {16, 45, 30, 20};
    int tab2[TAILLE];

    copieTab(tab, tab2, TAILLE);
    afficheTab(tab2, TAILLE);

    return 0;
}

void afficheTab(int tab[], int taille)
{
    for (int i = 0; i < taille; i++)
    {
        printf("%d ", tab[i]);
    }
    printf("\n");
}

void copieTab(int source[], int destination[], int taille)
{
    for (int i = 0; i < taille; i++)
    {
        destination[i] = source[i];
    }
}

1 -> Pourquoi lorsque je met dans void copie dans la boucle for tabOriginal[i] = tabCopie[i] sa fonctionne pas j'ai cherché 2 heures pour cette erreur que je ne comprend pas encore, il faut mettre la copie = l'original et non l'original = copie, pourquoi ?

J'ai renommé les variables en source et destination pour rendre plus explicite le d'où les données viennent, et où elles vont.

2 -> le paramètre dans le fonction void copie(int*, int, int tailleTab) n'est valable que pour cette fonction, du coup j'ai du recréer un tTab dans la fonction main pour afficher la copie, mais est'il possible de se passer d'inscrire manuellement le tTab pour lire et utiliser le 10 dans copie(tab, tab2, 10)     exemple: un pointeur qui puisse cibler l'adresse d'une variable dans une autre fonction (ici tel que dans le void) est il possible ?

Ton tTab est maladroit. Le plus propre est de définir une constante et l'utiliser partout, comme j'ai fait.

-
Edité par Marc Mongenet 24 août 2021 à 0:27:04