Bonsoir,

Je tenais à partager mes résultats avec vous :

Les fonctions sont dans tableau.c :

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

int sommeTableau(int *tableau, int tailleTableau)
{
    int i, compteur=0;

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

    return compteur;
}

double moyenneTableau(int *tableau, double tailleTableau)
{
    int i;
    double compteur = 0,moyenne = 0;

    for (i=0; i<tailleTableau; i++)
    {
        compteur = compteur + tableau[i];

    }
    moyenne = compteur/tailleTableau;
    return moyenne;

}

void maxTableau(int *tableau, int tailleTableau, int valeurMax)
{
    int i;

    for (i=0;i<tailleTableau;i++)
    {
        if (tableau[i]>valeurMax)
        {
            tableau[i] = 0;
        }

    }

}

void copieTableau(int *tableauSource, int *tableauCible, int tailleTableau)
{

    int i;

    for (i=0;i<tailleTableau;i++)
    {
        tableauCible[i] = tableauSource[i];
    }
}

void afficherTableau(int *tableau, int tailleTableau)
{
    int i;

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

void ordonnerTableau(int *tableau, int tailleTableau)
{
    int i=0, j=0, saveValue;

    for (i=0;i<tailleTableau;i++)
    {
        for (j=i+1; j<tailleTableau; j++) //Pour comparer le premier nombre i avec tous les nombres suivants j+1
        {
            if (tableau[j]<tableau[i])
            {
                saveValue = tableau[i]; // Avant permutation faut sauvegarder la première valeur i
                tableau[i] = tableau[j];
                tableau[j] = saveValue;
            }
        }
    }
}

Les prototypes des fonctions sont dans tableau.h :

#ifndef TABLEAU_H_INCLUDED
#define TABLEAU_H_INCLUDED

int sommeTableau(int *tableau, int tailleTableau);
double moyenneTableau(int *tableau, double tailleTableau);
void maxTableau(int *tableau, int tailleTableau, int valeurMax);
void copieTableau(int *tableauSource, int *tableauCible, int tailleTableau);
void afficherTableau(int *tableau, int tailleTableau);
void ordonnerTableau(int *tableau, int tailleTableau);

#endif // TABLEAU_H_INCLUDED

main.c :

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


int main()
{

    int tab[4];
    tab[0] = 5;
    tab[1] = 2;
    tab[2] = 4;
    tab[3] = 10;

    int tabCible[4];

    printf("Somme : %d\n", sommeTableau(tab, 4));

    printf("Moyenne : %f\n\n", moyenneTableau(tab, 4));

    copieTableau(tab, tabCible, 4);
    printf("Tableau copié :\n");
    afficherTableau(tabCible, 4);

    maxTableau(tabCible, 4, 3);
    printf("Mise à 0 des valeurs supérieures à 3 :\n");
    afficherTableau(tabCible, 4);

    ordonnerTableau(tab, 4);
    printf("Tableau original ordonné :\n");
    afficherTableau(tab, 4);
    return 0;
}

Résultat :

-
Edité par CharlesDupont6 7 février 2017 à 18:01:26

Pour un exercice de debutant cest pas mal du tout, le code est propre, correctement indente.

Quelques remarque : pourquoi taille tableau devient un double dans la fonction moyenne ?

Et egalement cette fonction pourrais tout simplement appeller sommetableau.

Ensuite tu nas qua faire :

Return (double)somme/(double)tailletableau

En tout cas continue comme ca

Pour aller plus loin tu peux aussi regarder dautres algo de tri de tableau, celui que tu as fait etant le plus simple et le moins performant. Par contre si tu las trouve tout seul cest vraiment cool !

Salut,

Je trouve que ta fonction maxTableau() n'a pas un nom adapté à ce qu'elle fait. Tu pourrais l'appeler seuilTableau() ou un truc du genre.

Tu pourrais ré-écrire la fonction maxTableau() pour qu'elle renvoie la valeur max présente dans le tableau et la fonction minTableau() pour la valeur min

Bonne continuation ...

Merci pour vos commentaires!

Voici ce que j'ai ajouté :

tableau.c :

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

int sommeTableau(int *tableau, int tailleTableau)
{
    int i, compteur=0;

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

    return compteur;
}

double moyenneTableau(int *tableau, int tailleTableau)
{
    int i;
    double compteur = 0,moyenne = 0;

    for (i=0; i<tailleTableau; i++)
    {
        compteur = compteur + tableau[i];

    }
    moyenne = (double)compteur/(double)tailleTableau; // Car l'ordinateur ne sait pas diviser des entiers car il en garde que la partie entière
    return moyenne;                                   //  ( ex : 5/2 => Combien il y a de fois 2 dans 5 => 2 fois + modulo = 1)
                                                       // Pour obtenir un résultat décimal, il faut donc diviser des nombres décimaux (double)
}

void seuilTableau(int *tableau, int tailleTableau, int valeurMax)
{
    int i;

    for (i=0;i<tailleTableau;i++)
    {
        if (tableau[i]>valeurMax)
        {
            tableau[i] = 0;
        }

    }

}

void copieTableau(int *tableauSource, int *tableauCible, int tailleTableau)
{

    int i;

    for (i=0;i<tailleTableau;i++)
    {
        tableauCible[i] = tableauSource[i];
    }
}

void afficherTableau(int *tableau, int tailleTableau)
{
    int i;

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

void ordonnerTableau(int *tableau, int tailleTableau)
{
    int i=0, j=0, saveValue;

    for (i=0;i<tailleTableau;i++)
    {
        for (j=i+1; j<tailleTableau; j++) //Pour comparer le premier nombre i avec tous les nombres suivants j+1
        {
            if (tableau[j]<tableau[i])
            {
                saveValue = tableau[i]; // Avant permutation faut sauvegarder la première valeur i
                tableau[i] = tableau[j];
                tableau[j] = saveValue;
            }
        }
    }
}

int maxTableau(int *tableau, int tailleTableau)
{
    int i, maxValue=0;

    for (i=1; i<tailleTableau; i++)
    {
        if(tableau[0]>tableau[i])
        {
            maxValue = tableau[0];
        }
        else
            maxValue = tableau[i];
    }
    return maxValue;
}

tableau.h :

#ifndef TABLEAU_H_INCLUDED
#define TABLEAU_H_INCLUDED

int sommeTableau(int *tableau, int tailleTableau);
double moyenneTableau(int *tableau, int tailleTableau);
void seuilTableau(int *tableau, int tailleTableau, int valeurMax);
void copieTableau(int *tableauSource, int *tableauCible, int tailleTableau);
void afficherTableau(int *tableau, int tailleTableau);
void ordonnerTableau(int *tableau, int tailleTableau);
int maxTableau(int *tableau, int tailleTableau);

#endif // TABLEAU_H_INCLUDED

main.c :

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


int main()
{

    int tab[4];
    tab[0] = 5;
    tab[1] = 2;
    tab[2] = 4;
    tab[3] = 10;

    int tabCible[4];

    printf("Somme : %d\n", sommeTableau(tab, 4));

    printf("Moyenne : %f\n\n", moyenneTableau(tab, 4));

    copieTableau(tab, tabCible, 4);
    printf("Tableau copié :\n");
    afficherTableau(tabCible, 4);

    seuilTableau(tabCible, 4, 3);
    printf("Mise à 0 des valeurs supérieures à 3 :\n");
    afficherTableau(tabCible, 4);

    ordonnerTableau(tab, 4);
    printf("Tableau original ordonné :\n");
    afficherTableau(tab, 4);

    printf("Valeur Max de la table d'origine : %d\n", maxTableau(tab, 4));

    return 0;
}

Résultat :

Pour la fonction minTableau, c'est l'inverse de maxTableau donc c'est transposable à une condition prêt

Pourquoi ne pas utiliser les fonctions déjà écrites ...

int maxTableau(int *tableau, int tailleTableau)
{
  ordonnerTableau(tableau, tailleTableau);
  return tableau[tailleTableau - 1];
}

int minTableau(int *tableau, int tailleTableau)
{
  ordonnerTableau(tableau, tailleTableau);
  return *tableau;
}

-
Edité par magma 8 février 2017 à 12:56:34

Pourquoi ne pas utiliser les fonctions déjà écrites ...

Parce qu’on peut très bien vouloir le maximum d’un tableau tout en voulant garder le tableau désordonné. Quand je vois une fonction maxTableau, je ne m’attends pas à ce qu’elle trie mon tableau. De plus, la recherche du maximum et du minimum sont en temps linéaire, le tri du tableau a une complexité au mieux en O(nln(n)).

Par contre, pour la fonction moyenne par exemple, c’est mieux d’utiliser la fonction somme.

yo@n97one a écrit:

Pourquoi ne pas utiliser les fonctions déjà écrites ...

Parce qu’on peut très bien vouloir le maximum d’un tableau tout en voulant garder le tableau désordonné. Quand je vois une fonction maxTableau, je ne m’attends pas à ce qu’elle trie mon tableau. De plus, la recherche du maximum et du minimum sont en temps linéaire, le tri du tableau a une complexité au mieux en O(nln(n)).

Par contre, pour la fonction moyenne par exemple, c’est mieux d’utiliser la fonction somme.

Et c'est pourquoi il serait sans doute plus simple d'introduire le mot clé const à ce moment dans le cours sans forcément l'expliquer en détail. Quelque chose de plus moderne que  :

int sommeTableau(int *tableau, int tailleTableau);
double moyenneTableau(int *tableau, int tailleTableau);
void seuilTableau(int *tableau, int tailleTableau, int valeurMax);
void copieTableau(int *tableauSource, int *tableauCible, int tailleTableau);
void afficherTableau(int *tableau, int tailleTableau);
void ordonnerTableau(int *tableau, int tailleTableau);
int maxTableau(int *tableau, int tailleTableau);

pourrait-être :

int sommeTableau(size_t taille, const int tableau[taille]);
double moyenneTableau(size_t taille, const int tableau[taille]);
void seuilTableau(size_t taille, int tableau[taille], int valeurMax);
void copieTableau(size_t taille, const int tableauSource[taille], int tableauCible[taille]);
void afficherTableau(size_t taille, const int tableau[taille]);
void ordonnerTableau(size_t taille, int tableau[taille]);
int maxTableau(size_t taille, const int tableau[taille]);

Avec le const on comprend bien que seuls le triet le seuillage modifient les données contenues dans le tableau, les autres non.
Il serait sans doute un peu overkill d'utiliser les restrict et static à ce niveau, mais bon c'est à réfléchir pour la nouvelle mouture du cours.

On pourrait aussi penser à mieux nommer les fonctions en utilisant une convention de type namespace : ordonnerTableau → int_array_sort

Edit:

Du coup j'ai crossposté vers https://openclassrooms.com/forum/sujet/exercices-tableaux-corriges?page=1#message-91511778

-
Edité par PicoDev 8 février 2017 à 16:30:37

Et c'est pourquoi il serait sans doute plus simple d'introduire le mot clé const à ce moment dans le cours sans forcément l'expliquer en détail.

Je crois qu’il est introduit avant. C’est juste qu’il n’est pas utilisé. En effet, ce serait bien d’y remédier.

On pourrait aussi penser à mieux nommer les fonctions en utilisant une convention de type namespace : ordonnerTableau → int_array_sort

Et pour rester cohérent, de renommer tous les noms de fonctions en utilisant l’anglais et le snake case .

Du coup j'ai crossposté vers https://openclassrooms.com/forum/sujet/exercices-tableaux-corriges?page=1#message-91511778

Bonne idée. Ce sujet, peut servir à regrouper les remarques à propos des améliorations à apporter.

-
Edité par yo@n97one 8 février 2017 à 16:36:51

Voici le nouveau code :

J'ai mis de côté le type namespace...

tableau.h :

#ifndef TABLEAU_H_INCLUDED
#define TABLEAU_H_INCLUDED

//int sommeTableau(int *tableau, int tailleTableau);
int sommeTableau(const int *tableau, int tailleTableau);

//double moyenneTableau(int *tableau, int tailleTableau);
double moyenneTableau(const int *tableau, int tailleTableau);

void seuilTableau(int *tableau, int tailleTableau, int valeurMax);

void copieTableau(int *tableauSource, int *tableauCible, int tailleTableau);

//void afficherTableau(int *tableau, int tailleTableau);
void afficherTableau(const int *tableau, int tailleTableau);

void ordonnerTableau(int *tableau, int tailleTableau);

//int maxTableau(int *tableau, int tailleTableau);
int maxTableau(const int *tableau, int tailleTableau);

#endif // TABLEAU_H_INCLUDED

Tableau.c :

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

static int i = 0; // La variable i devient globale uniquement pour ce fichier

//int sommeTableau(int *tableau, int tailleTableau)
int sommeTableau(const int *tableau, int tailleTableau)
{
    int compteur=0;

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

    return compteur;
}

//double moyenneTableau(int *tableau, int tailleTableau)
double moyenneTableau(const int *tableau, int tailleTableau)
{
    double compteur = 0,moyenne = 0;

    for (i=0; i<tailleTableau; i++)
    {
        compteur = compteur + tableau[i];

    }
    moyenne = (double)compteur/(double)tailleTableau; // Car l'ordinateur ne sait pas diviser des entiers car il en garde que la partie entière
    return moyenne;                                   //  ( ex : 5/2 => Combien il y a de fois 2 dans 5 => 2 fois + modulo = 1)
                                                       // Pour obtenir un résultat décimal, il faut donc diviser des nombres décimaux (double)
}

void seuilTableau(int *tableau, int tailleTableau, int valeurMax)
{
    for (i=0;i<tailleTableau;i++)
    {
        if (tableau[i]>valeurMax)
        {
            tableau[i] = 0;
        }

    }

}

//void copieTableau(int *tableauSource, int *tableauCible, int tailleTableau)
void copieTableau(int *tableauSource, int *tableauCible, int tailleTableau)
{

    for (i=0;i<tailleTableau;i++)
    {
        tableauCible[i] = tableauSource[i];
    }
}

//void afficherTableau(int *tableau, int tailleTableau)
void afficherTableau(const int *tableau, int tailleTableau)
{
    for (i=0;i<tailleTableau;i++)
    {
        printf("%d\n", tableau[i]);
    }
}

void ordonnerTableau(int *tableau, int tailleTableau)
{
    int j=0, saveValue;

    for (i=0;i<tailleTableau;i++)
    {
        for (j=i+1; j<tailleTableau; j++) //Pour comparer le premier nombre i avec tous les nombres suivants j+1
        {
            if (tableau[j]<tableau[i])
            {
                saveValue = tableau[i]; // Avant permutation faut sauvegarder la première valeur i
                tableau[i] = tableau[j];
                tableau[j] = saveValue;
            }
        }
    }
}

//int maxTableau(int *tableau, int tailleTableau)
int maxTableau(const int *tableau, int tailleTableau)
{
    int maxValue=0;

    for (i=1; i<tailleTableau; i++)
    {
        if(tableau[0]>tableau[i])
        {
            maxValue = tableau[0];
        }
        else
            maxValue = tableau[i];
    }
    return maxValue;
}

main.c :

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

int main()
{

    int tab[4];
    tab[0] = 5;
    tab[1] = 2;
    tab[2] = 4;
    tab[3] = 10;

    int tabCible[4];

    printf("Somme : %d\n", sommeTableau(tab, 4));

    printf("Moyenne : %f\n\n", moyenneTableau(tab, 4));

    copieTableau(tab, tabCible, 4);
    printf("Tableau copié :\n");
    afficherTableau(tabCible, 4);

    seuilTableau(tabCible, 4, 3);
    printf("Mise à 0 des valeurs supérieures à 3 :\n");
    afficherTableau(tabCible, 4);

    ordonnerTableau(tab, 4);
    printf("Tableau original ordonné :\n");
    afficherTableau(tab, 4);

    printf("Valeur Max de la table d'origine : %d\n", maxTableau(tab, 4));

    return 0;
}

Bonjour

Je me permets quelques modifications dans le nouveau code.

A noter que la variable i globale est une extrêmement mauvaise façon de faire, extrêmement dangereuse. Je l'ai supprimée.
J'ai aussi tout écrit en français et nommer plus systématiquement les fonctions.
La fonction seuilTableau était mal nommée, car elle plafonne plus qu'elle ne seuille. Toutefois il ne s'agit pas vraiment d'un plafonnement, puisqu'elle ne ramène pas au plafond, mais à zéro. C'est tordu, d'où le nom tordu que je lui ai donné.

J'ai simplifié maxTableau, mais j'ai laissé le comportement indéterminé en cas de tableau vide.

#ifndef TABLEAU_H_INCLUDED
#define TABLEAU_H_INCLUDED

int sommeTableau(const int *tableau, int tailleTableau);
double moyenneTableau(const int *tableau, int tailleTableau);
void plafonnerZeroTableau(int *tableau, int tailleTableau, int valeurMax);
void copierTableau(const int *tableauSource, int *tableauCible, int tailleTableau);
void afficherTableau(const int *tableau, int tailleTableau);
void ordonnerTableau(int *tableau, int tailleTableau);
int maxTableau(const int *tableau, int tailleTableau);

#endif // TABLEAU_H_INCLUDED

Tableau.c :

#include <stdio.h>


int sommeTableau(const int *tableau, int tailleTableau)
{
    int somme;

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


double moyenneTableau(const int *tableau, int tailleTableau)
{
    double somme = sommeTableau(tableau, tailleTableau);
    return somme / tailleTableau;
}


void plafonnerZeroTableau(int *tableau, int tailleTableau, int valeurMax)
{
    for (int i = 0; i < tailleTableau; i++)
    {
        if (tableau[i] > valeurMax)
        {
            tableau[i] = 0;
        }
    }
}


void copierTableau(const int *tableauSource, int *tableauCible, int tailleTableau)
{
    for (int i = 0; i < tailleTableau; i++)
    {
        tableauCible[i] = tableauSource[i];
    }
}


void afficherTableau(const int *tableau, int tailleTableau)
{
    for (int i = 0; i < tailleTableau; i++)
    {
        printf("%d\n", tableau[i]);
    }
}


void ordonnerTableau(int *tableau, int tailleTableau)
{
    for (int i = 0; i < tailleTableau; i++)
    {
        for (int j = i + 1; j < tailleTableau; j++) //Pour comparer le premier nombre i avec tous les nombres suivants j+1
        {
            if (tableau[j] < tableau[i])
            {
                int tmp = tableau[i];
                tableau[i] = tableau[j];
                tableau[j] = tmp;
            }
        }
    }
}


int maxTableau(const int *tableau, int tailleTableau)
{
    int max = tableau[0];

    for (int i = 1; i<tailleTableau; i++)
    {
        if (max < tableau[i])
        {
            max = tableau[i];
        }
    }
    return max;
}

main.c :

#include <stdio.h>
#include "tableau.h"

int main()
{
    int tab[4] = { 5, 2, 4, 10 };
    int tabCible[4];

    printf("Somme : %d\n", sommeTableau(tab, 4));

    printf("Moyenne : %f\n\n", moyenneTableau(tab, 4));

    copierTableau(tab, tabCible, 4);
    printf("Tableau copié :\n");
    afficherTableau(tabCible, 4);

    plafonnerZeroTableau(tabCible, 4, 3);
    printf("Mise à 0 des valeurs supérieures à 3 :\n");
    afficherTableau(tabCible, 4);

    ordonnerTableau(tab, 4);
    printf("Tableau original ordonné :\n");
    afficherTableau(tab, 4);

    printf("Valeur maximale du tableau original : %d\n", maxTableau(tab, 4));

    return 0;
}

Pour la fonction ordonnerTableau  je n'ai pas ajouté l'autre variable j, j'ai travailler justement avec i+1 en mettant :

void ordonnerTableau(int tableau[], int tailleTableau)

{

    int t=0, i=0;

    for (i=0 ; i<N ; i++)

         {

            if (tableau [i+1]< tableau [i])

         {

             t= tableau [i];

             tableau [i]= tableau [i+1];

             tableau [i+1]= t;

         }

         printf("%d\n", tableau [i]);

         }

}

-
Edité par MalikaOubilla 11 février 2017 à 14:28:57

Salut,

Oui tu es forcé d'utiliser deux variables pour une raison toute simple :

Imagine un tableau avec les valeurs suivantes :

[8, 10, 4]

8 < 10, donc on va pas échanger les deux valeurs

puis 10 > 4 donc on échange les deux variables.

A la fin le tableau vaudra donc :

[8, 4, 10].

Pour que celà fonctionne il faudrait que tu englobe toute ta boucle dans un do_while qui vérifie si le tableau est parfaitement trié. Mais c'est carrément pas performant du tout (imagine un tableau [10, 11, 12, 13, 14, 15, 16, 17, 4], tu le parcours 8 fois avant que le 4 soit au bon endroit ^^)

Au passage, fais attention lorsque tu utilise des [i + 1], ici tu fais varier i de 0 à N - 1, or lorsque i = N - 1, i + 1 = N et tableau[N] est une valeur non accessible, tu risque au mieux un segfault au pire un comportement indéterminé.