Aller au menu - Aller au contenu

Les tableaux

Pour accéder à cette section
Connectez-vous !
connexion_rpx
Page Précédente  1  2  3  ...  26  27  28  29  30  31  Suivante
Pseudo Commentaire
Page Précédente  1  2  3  ...  26  27  28  29  30  31  Suivante
Hors ligne maxstill59 # Posté le 26/01/2012 à 11:16:46

Avis : Très bon

Citation : billounet95
Voilà le code que j'ai realise pour l'exercice 2, le probleme est que ça m'affiche 16.000000 alors que ça devrait etre 16.50000
Merci de m'aider


#include <stdio.h>
#include <stdlib.h>
double moyenneTableau(int tableau[], int tailleTableau);

int main()
{
int tableau[2] = {12, 21};
printf("\n\n%f\n\n", moyenneTableau(tableau, 2));

return 0;
}

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

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



Je pense que le pb vient du fait que à la fois "somme" et "tailleTableau" sont des entiers, donc lorsque quand tu fais la division, l'ordinateur les divise d'abord tels des "int" (il obtient donc 16) puis transforme le résultat en "double" (16.00000). Pour que ça marche il faut que tu déclares ta variable "somme" avec ta variable "moyenne" en tant que double.

Code : C
1
double moyenne = 0, somme = 0;


Mais tu pourrais surtout ne pas avoir à créer tant de variables:

Code : C
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
double moyenneTableau(int tableau[], int tailleTableau)
{
    int i;
    double moy = 0;
    for (i=0; i < tailleTableau; i++)
    {
        moy += tableau[i];
    }
    
    return (moy / tailleTableau);
}
Hors ligne maxstill59 # Posté le 26/01/2012 à 11:37:52

Avis : Très bon

Une fonction peut elle retourner un tableau ? ( return tableau )
Hors ligne Asajj # Posté le 27/01/2012 à 17:25:05
Avatar

 --> DangerousMic :
En effet le tableau est un pointeur, mettre "int*tableau" revient à dire à ta fonction qu'il s'agit d'un tableau. Tu peut toute fois t'en passer : regarde la différence entre ta ligne de code et la mienne, elles reviennent exactement au même ;)
Code : C
1
void affiche(int *tableau, int tailleTableau);

Code : C
1
void affiche(int tableau[], int tailleTableau);



--> Bien le bonjour! je bloque un peu sur l'exercice 5 et je refuse de prendre un code trouvé dans les commentaires parce que je ne comprends pas vraiment le pourquoi du comment...
Mon problème est que j'ai créé un tableau de 9 valeurs (1 - 8 - 5 - 7 - 2 - 4 - 3 - 9 - 6) et que, avec mon code, seules les 6 premières valeurs s'affichent (dans l'ordre croissant). Les 3 dernières valeurs du tableau (à savoir 3 - 6 - 9) ne s'affichent pas..
Si vous pouviez m'éclairer un poil sur l'erreur que j'ai fait, ça serait cool =)

Voici mon code :

main.c :
Code : C
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

// exercices sur les tableaux, by Asajj

int main(int argc, char *argv[])
{
    int tableau[9]={1,8,5,7,2,4,3,9,6};
    int tableau1[9]={0};
    int valMax=0,i=0,menu=0,total=0;
    printf("\n 1. Somme\n 2. Moyenne\n 3. Copie\n 4. Valeur max\n 5. Classer\n\n Entrez votre choix (1/2/3/4/5) --> ");
    scanf("%d",&menu);
    switch (menu)
    {
// somme
        case 1:
        total=somme(tableau,9);
        printf("\n somme --> %d\n\n",total);
        break;
// moyenne
        case 2:
        total=somme(tableau,9);
        moyenne(tableau,9,total);
        break;
// copie
        case 3:
        printf("\n\n copie du tableau :\n\n");
        copie(tableau,9,tableau1);
        break;
// valeur max
        case 4:
        printf("\n\n entrez la valMax --> ");
        scanf("%d",&valMax);
        printf("\n\n tableau avec les chiffres >%d = 0 :\n\n",valMax);
        max(tableau,9,valMax);
        break;
// classer
        case 5:
        printf("\n\n valeur du tableau dans l'ordre croissant :\n\n");
        ordonner(tableau,9);
        break;
// defalut
        default:
        printf("\n\n fuck u bitch! i saied a nomber beetwin 1 and 5!\n\n");
        break;
    }
    return(0);
}


fonction.c

Code : C
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "fonction.h"

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

void moyenne(int tableau[],int taille,int total)
{
    int moy=0,i=0;
    for (i=0;i<taille;i++)
    {
        moy=total/taille;
    }
    printf("\n moyenne --> %d\n\n",moy);
}

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

void max(int tableau[],int taille,int valMax)
{
    int i=0;
    for (i=0;i<taille;i++)
    {
        if (tableau[i]>valMax)
        {
            tableau[i]=0;
        }
        printf(" %d\n\n",tableau[i]);
    }
}

void ordonner(int tableau[], int taille)
{
    int i=0;
    for (i=0;i<taille;i++)
    {
        if (tableau[i]<tableau[i++])
        {
            printf(" %d\n %d\n",i,i++);
        }
        else
        {
            printf(" %d\n %d\n",i++,i);
        }
    }
}


fonction.h
Code : C
1
2
3
4
5
int somme(int tableau[], int taille);
void moyenne(int tableau[],int taille,int total);
void copie(int tableau[],int taille, int tableau1[]);
void max(int tableau[],int taille,int valMax);
void ordonner(int tableau[], int taille);



Edit --> j'ai trouvé en mettant le code ci-dessous mais ça me classe également 10 qui est la 10ème case (i=9) parce que le code trie par paires et donc vu que j'ai fait une boucle disant de continuer tant que i<9, pour i=8 il continue et s'occupe donc aussi de i=9.

fonction "ordonner" de fonction.c
Code : C
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
void ordonner(int tableau[], int taille)
{
    int i=0;
    for (i=0;i<taille;i++)
    {
        do
        {
        if (tableau[i]<tableau[i++])
        {
            printf(" %d\n %d\n",i,i++);
        }
        else
        {
            printf(" %d\n %d\n",i++,i);
        }
        } while (i<9 && i>=0);
    }
}
Hors ligne ijiboom # Posté le 27/01/2012 à 21:48:08

Avis : Bon

Voici mon code pour l'exercice 1:



#include <stdio.h>
#include <stdlib.h>
int i=0;
int sommetableau(int tableau[5], int tailletableau);
int resultat;
int main()
{
int tableau[5]={1,7,16,345,3};

int sommetableau(int tableau[5], int tailletableau);
printf("la somme des nombres de ce tableau est %d", resultat);


return 0;
}

int sommetableau(int tableau[5], int tailletableau)
{
while (i<4 && i>=0);
{
resultat=tableau[i]+tableau[i+1];
i++;
return resultat;
}

}

Le processus renvoit zero... Je suis assez sûr que c'est une erreur au niveau de la présentation des fonctions, mais je n'arrive pas à la trouver (oui, je sais, cours à revoir...) Merci d'avance de me la signaler si vous la trouvez :)
Hors ligne Asajj # Posté le 28/01/2012 à 01:30:29
Avatar

 @ ijiboom --> je pense avoir assez bien expliqué ce que j'ai fait à ton code ;) bon d'accord... j'ai passé sous silence les coups de fouets :p si t'as un truc pas clair dans ce que j'ai fait, je serai ravi de t'expliquer, il faut juste garder à l'esprit que je débute moi aussi ^^

Code : C
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <stdio.h>
#include <stdlib.h>
int sommetableau(int tableau[], int tailletableau); //pas besoin du 5 entre []

int main()
{
    int tableau[5]={1,7,16,345,3};
    int resultat=0; // ne crée pas de variables globales, crée tes variables dans tes fonctions
    resultat=sommetableau(tableau,5); // pas de int : tu ne crée rien, pas de [] non plus / "resultat=" permet de dire que ce que tu vas renvoyer avec le "return" de la fonction "sommetableau" sera la valeur de ta variable "resultat".
    printf("\n\n la somme des nombres de ce tableau est %d\n\n", resultat); // les sauts de ligne c'est que j'aime mieux, je trouve ça plus lisible sur la console (idem pour le premier espace ^^)
return 0;
}

int sommetableau(int tableau[], int tailletableau) // pas besoin de ton 5 entre [] ici non plus du coup ^^
{
    int i=0,resultat=0; // tu crée ces variables ici (tu n'as besoin de "i" que dans cette fonction)
    do // je verrais plus un "do...while" --> fait ça tant que c'est comme ça
    {
        resultat+=tableau[i]; // cette façon de faire le calcule me parait plus juste (la tienne me donnais pour résultat l'adresse de la valeur)
        i++;
    } while (i<5 && i>=0); // i<5 car "i = 0 1 2 3 ou 4", ce qui fait tes 5 valeurs

return(resultat); // toujours mettre "return" à la fin de ta fonction (juste avant le dernier "}"
}


En fait, je crois que j'ai mis 2 fois plus de commentaire que ce qu'il y a comme code! x) du coup, j'espère pour toi que t'es pas fâché(e) avec la barre de défilement horizontale :p
Hors ligne Mikael Benhaiem # Posté le 28/01/2012 à 19:09:57

Bonjour ! Après ces exercices que j'ai réussit, je me suis dis que ça faisait quand même beaucoup de fonctions.. Du coup je me suis demandé si ça marcherai pas de mettre les prototypes et les fonctions dans le " .h " ...
Je me disais que bon ça devrait pas marcher, vu que sur le tuto c'était dis qu'on y mettait que les prototypes. Mais à ma grande surprise ça a marché... Aurai-je mal lu un tuto? Ou quelqu'un peut-il me dire pourquoi si ça marche on ne l'a pas utilisé? Il y a-t-il des risques ?
Merci :)
Hors ligne ijiboom # Posté le 28/01/2012 à 22:36:51

Avis : Bon

-->Asajj
Merci beaucoup! J'espère que je peux me faire pardonner pour les nombreux gros blasphèmes contenus dans ce code... :p J'ai du vraiment trop speeder le chapitre des fonctions, je reverrai ça avant de refaire un exo de tableaux.
Et encore une fois merci :)
Hors ligne Asajj # Posté le 28/01/2012 à 23:45:43
Avatar

 mais je t'en prie ;)

j'ai un bon truc pour m'entrainer (enfin bon pour moi du moins) : j'incrémente de nouvelles fonctionnalités au jeu du nombre mystère au cours des nouveaux chapitres, je sais plus si j'ai ajouté des trucs à ce chapitres mais, par exemple, grâce au suivant, que l'on joue à 1 ou 2 joueurs, on ne s'appelle plus "joueur 1" ou "joueur 2" mais chaque joueur a un pseudo qu'il a lui-même choisi =)

pour ma part, je trouve ce système d'amélioration de ce petit programme très pratique parce que ça permet de voir "réellement" notre avancement dans la compréhension du langage et que c'est plutôt motivant ^^
Hors ligne Mydym # Posté le 01/02/2012 à 17:51:51

C'est un super code Asajj mais je pense qu'il n'est pas assez général. Après le while, tu mets "i < 5 && i >= 0", je pense que ce serait plus simple de mettre
"i < tailleTableau && i >= 0" Enfin après, c'est juste pour que ça fonctionne avec n'importe quelle taille du tableau car on aura besoin de ces fonctions plus tard. =)
Hors ligne Mydym # Posté le 01/02/2012 à 23:35:59

J'ai trouvé ce code en réponse à l'exercice 5 car je ne trouvais pas la réponse, j'ai testé, ça fonctionne mais je ne comprends pas pourquoi...

Code : C
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include <stdio.h>
#include <stdlib.h>


void ordonnerTableau(int tableau[], int tailleTableau);

int main(int argc, char *argv[])
{
    int tableau[4] = {10, 15, 4, 16};

    ordonnerTableau(tableau, 4);

    return 0;
}

void ordonnerTableau(int tableau[], int tailleTableau)
{
    int i , j , difference;

    for (i = 0 ; i < tailleTableau ; i++)
    {
        for (j = 0 ; j < tailleTableau ; j++)
        {
            if (tableau[i] < tableau[j])
            {
                difference = tableau[i] - tableau[j];
                tableau[i] -= difference;
                tableau[j] += difference;
            }
        }
    }
    for(i = 0; i < tailleTableau ; i++)
    {
        printf("%d\n", tableau[i]);
    }
}
Hors ligne CreiZyz # Posté le 03/02/2012 à 23:25:33

Salut salut! D'abord, je tient a remercier le site du zero, et surtout mateo pour tout ce qu'il nous apporte!

Sinon, j'ai un petit problème avec mon code a l'exercice 5... il se base sur une boucle, mais ca déconne dans ma prise en compte des valeurs. En fait, il prend en compte une valeur de trop a cause du fonctionnement de ma boucle (le i+1 ligne 9). J'ai cherché a résoudre ce problème en remettant a zero cette valeur, mais ca ne marche pas. Quelqu'un aurait une solution?
Code : C
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
void ordonf(int tableau[], int taille)
{
    int i = 0, c = 0, d = 0, m = 0;
    for (c = 0; c < taille - 1; c++)
    {
        for (i = 0; i < taille - 1; i++) //for (i = 0; i < taille; i++) changé en for (i = 0; i < taille - 1; i++)
        {
            if (tableau[i] < tableau[i+1])
            {
                d = tableau[i];
                m = tableau[i+1];
                tableau[i] = m;
                tableau[i+1] = d;
            }
        }
    }
    for (i = 0; i < taille; i++)
    {
        printf("\nvaleur %d apres tri: %d", i, tableau[i]);
    }
}


EDIT:
Problème résolu... c'est plutôt idiot d'ailleurs, il suffisait que je fasse 1 test de moins :)
Hors ligne Ismuur # Posté le 05/02/2012 à 14:36:38
Avatar

Ville : Dijon
Pays : France métropolitaine

 Salut à tous!
Tout d'abord un GRAND merci à M@théo21, parce que ce tuto est vraiment génial!
Ensuite pour ceux qui le veulent, voilà ma solution pour l'exercice 5, ce n'est peut être pas la meilleure mais elle à l'air de fonctionner et c'est le principal!Secret (cliquez pour afficher)
Code : C
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
//Organise un tableau en mettant ses valeurs dans l'ordre croissant
void ordonnerTableau(int tableau[], int tailleTableau)
{
    int i = 0, k = 0, l = 0;

    for(l = 0; l < tailleTableau; l++) //Cette boucle est là pour ranger toutes les cases du tableau dans l'ordre croissant
    {
        for(i = 0; i < tailleTableau; i++) // Cette boucle permet de ranger une case par rapport à celle qui la suit seulement (d'où la nécessité de la boucle précédante)
        {
            if(tableau[i] > tableau[i+1])
            {
                k = tableau[i]; //On a besoin de k sinon on perd une valeur
                tableau[i] = tableau[i + 1];
                tableau[i + 1] = k;
            }
        }
    }

}

Voilà! Bon courage à tous et encore merci pour ce tuto! :)
Hors ligne X.Yassir.Matar.X # Posté le 06/02/2012 à 21:11:22

bonjour un GRAND merci a mateos pour ce très bon cours .
bon je bloque sur l'exercice n°5 bien que je crois que le probleme n'a rien a voir avec les tableau en sois , en effet bien que je n'ai aucune erreure lors de la compilation mon programme plante des son lancemment , voici mon code :
Code : C
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#include <stdio.h>
#include <stdlib.h>
void ordonnerTableau(int tableau[], int taille);

int permuter(int* A,int* B);

int main(int argc,int *argv)
{
    int taille=5 ,i=0;
	int tableau[5]={0};

    for(i=0;i>taille;i++)
    {
        printf("entrez la valeur n°%d de votre tableau:",i);
        scanf("%d",&tableau[i]);
    }
    ordonnerTableau(tableau,taille);
    for(i=0;i>taille;i++)
    printf("%d",i);
}
void ordonnerTableau(int tableau[],int taille)
{
    int i=0, anomallie=1;/* variable qui sert a detecter si il y a une anomalie dans l'arrangement du tableau, si la boucle parcours le tableau sans 
						 changer la variable anomalie ca veut dire que que le tableau est trié */
    do
    {
    for(i=0;i>taille;i++)
    {
        if (tableau[i]>tableau[i+1])
		{
            permuter(&tableau[i],&tableau[i+1]);
			anomallie=1;
		}
        else anomallie=0;
    }
    }while (anomallie==1);
}
int permuter(int *A,int *B)
{
    int temp=0;
    temp=*A;
    *B=*A;
    *A=temp;
    return 0;
}
Hors ligne X.Yassir.Matar.X # Posté le 06/02/2012 à 21:16:43

je m'excuse oubliez mon misérable post :D
Hors ligne Alexprog0 # Posté le 12/02/2012 à 19:43:36

Citation : Mydym
J'ai trouvé ce code en réponse à l'exercice 5 car je ne trouvais pas la réponse, j'ai testé, ça fonctionne mais je ne comprends pas pourquoi...

Code : C
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include <stdio.h>
#include <stdlib.h>


void ordonnerTableau(int tableau[], int tailleTableau);

int main(int argc, char *argv[])
{
    int tableau[4] = {10, 15, 4, 16};

    ordonnerTableau(tableau, 4);

    return 0;
}

void ordonnerTableau(int tableau[], int tailleTableau)
{
    int i , j , difference;

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


J'ai trouvé l'explication à ce programme en fait pour le comprendre il faut interpréter les boucles et sous-boucles unes par unes
La fonction int signifie que si une valeur du tableau est placée est dessous d'une autre et si elle est inférieure à cette autre valeur alors la valeur située en dessous sera finalement au-dessus de l'autre valeur...
En gros si tableau[i] < tableau[j] alors tableau[i] > tableau[j]
La boucle j est incluse dans la boucle i
Pour i=1, on compare la première valeur du tableau avec la boucle j qui contient les valeurs du tableau de 0 à 3 et l'on fait un classement :
Tableau [0] de i1 = Tableau [0] de j1 On a donc 10 15 4 16
Tableau [0] de i1 < Tableau [1] de j1 On a donc 15 10 4 16 (On échange 15 et 10)
Tableau [0] de i1 > Tableau [2] de j1 On a donc 15 10 4 16
Tableau [0] de i1 < Tableau [3] de j1 On a donc 16 10 4 15 (On inverse en prenant en compte l'ordre précédent et pas celui du début de la boucle de i1)

Pour i=2
Tableau [1] de i2 < Tableau [0] de j2 On a donc 16 10 4 15 (On continu avec le même ordre)
Tableau [1] de i2 = Tableau [1] de j2 On a donc 10 16 4 15
Tableau [1] de i2 > Tableau [2] de j2 On a donc 10 16 4 15
Tableau [1] de i2 > Tableau [3] de j2 On a donc 10 16 4 15

Pour i=3
Tableau [2] de i3 < Tableau [0] de j3 On a donc 4 16 10 15
Tableau [2] de i3 < Tableau [1] de j3 On a donc 4 10 16 15
Tableau [2] de i3 = Tableau [2] de j3 On a donc 4 10 16 15
Tableau [2] de i3 > Tableau [3] de j3 On a donc 4 10 16 15

Pour i=3
Tableau [3] de i4 > Tableau [0] de j4 On a donc 4 10 16 15
Tableau [3] de i4 > Tableau [1] de j4 On a donc 4 10 16 15
Tableau [3] de i4 < Tableau [2] de j4 On a donc 4 10 15 16
Tableau [3] de i4 = Tableau [3] de j4 On a donc 4 10 15 16

Finalement les valeurs du tableau seront bien rangés dans l'ordre croissant...
Il faut quand même être tordus pour penser à une méthode pareil
o_O
Hors ligne Oussama Abdelmoumen # Posté le 14/02/2012 à 14:41:47

Avis : Très bon

Mon Code pour les 5 exercices :) j'ai tous mis dans le main.c

/******************************************************************************/
/************************* Exemple d'un bon programme *************************/
/******************************************************************************/

/************************** Bibliothèques standards ***************************/
#include <stdio.h>
#include <stdlib.h>
/******************************************************************************/

/************************** Prototypes des fonctions **************************/

/******************************* Fonction somme *******************************/

// Cette fonction calcule la somme de toutes les valeurs du tableau
double Somme_tableau(int tableau[], int taille_tableau);

/******************************************************************************/

/****************************** Fonction moyenne ******************************/

// Cette fonction calcule la moyenne de toutes les valeurs du tableau
double Moyenne_tableau(int tableau[], int taille_tableau);

/******************************************************************************/

/******************************* Fonction copie *******************************/

// Cette fonction copie un tableau dans un autre
void Copie(int tableau_original[], int tableau_copie[], int taille_tableau);

/******************************************************************************/

/****************************** Fonction maximum ******************************/

// Cette fonction met à 0 toute les valeurs supérieures à une valeur max
void Maximum_tableau(int tableau[], int taille_tableau, int valeur_max);

/******************************************************************************/

/*************************** Fonction tri croissant ***************************/

// Cette fonction trie le tableau par ordre croissant
void Ordonner_tableau(int tableau[], int taille_tableau);

/******************************************************************************/


/***************************** Fonction principale ****************************/

int main()
{
int taille=0;double somme=0;int i=0;double moyenne=0;int *tableaucopier=NULL;int valeurmax=0;int indice_case=0;int indice1=0;int indice2=0;
int *tableau=NULL;
int place_min=0;
printf("Veuillez rentrer la taille de votre tableau : ");
scanf("%d", &taille);
tableau=malloc(sizeof(int)*taille);
printf("Veuillez rentrer les %d valeurs de votre tableau :\n", taille);
for(i=0;i<taille;i++)
{
printf("Veuillez rentrer une valeur : ");
scanf("%d", &tableau[i]);
}
somme = Somme_tableau(tableau,taille);
printf("La somme des valeurs du tableau est : %f \n", somme);
moyenne = Moyenne_tableau(tableau,taille);
printf("La moyenne des valeurs du tableau est : %f \n", moyenne);
tableaucopier=malloc(sizeof(int)*taille);
Copie(tableau,tableaucopier,taille);
printf("Les valeurs du tableau copier sont : \n");
for(i=0;i<taille;i++)
{
printf("==> %d\n", tableaucopier[i]);
}
printf("La valeur max que les valeurs doivent pas depasser : ");
scanf("%d", &valeurmax);
Maximum_tableau(tableau,taille,valeurmax);
printf("Les nouvelles valeurs du tableau sont : \n");
for(i=0;i<taille;i++)
{
printf("==> %d\n", tableau[i]);
}
Ordonner_tableau(tableau,taille);


return(0);
}


/******************************************************************************/


/************************** Déclaration des fonctions *************************/

/******************************* Fonction somme *******************************/

// Cette fonction calcule la somme de toutes les valeurs du tableau
double Somme_tableau(int tableau[], int taille_tableau)
{
int i=0; // Indice de la boucle
double somme=0; // Pour mémoriser la somme des valeurs dans le tableau

for(i=0; i<taille_tableau; i++) // Boucle pour parcourir tout le tableau
{
somme=somme+tableau[i]; // La somme des cases précédentes + la case i
}

return(somme); // On retourne la somme de toutes les cases du tableau
}

/******************************************************************************/

/****************************** Fonction moyenne ******************************/

// Cette fonction calcule la moyenne de toutes les valeurs du tableau
double Moyenne_tableau(int tableau[], int taille_tableau)
{
int moyenne=0; // Pour mémoriser la moyenne des valeurs du tableau

// On calcule la moyenne
moyenne=Somme_tableau(tableau,taille_tableau) / taille_tableau;

return(moyenne); // On retourne la moyenne
}

/******************************************************************************/

/******************************* Fonction copie *******************************/

// Cette fonction copie un tableau dans un autre
void Copie(int tableau_original[], int tableau_copie[], int taille_tableau)
{
int i=0; // Indice de la boucle de parcourt du tableau

for(i=0; i<taille_tableau; i++) // On parcourt toutes les cases du tableau
{
tableau_copie[i]=tableau_original[i]; // On copie la valeur de la case i
}
}

/******************************************************************************/

/****************************** Fonction maximum ******************************/

// Cette fonction met à 0 toute les valeurs supérieures à une valeur max
void Maximum_tableau(int tableau[], int tailleTableau, int valeur_max)
{
int i=0; // Indice de la boucle de parcourt du tableau

for(i=0; i<tailleTableau; i++) // On parcourt tout le tableau
{
if(tableau[i] > valeur_max) // Si on trouve une valeur non autorisée
{
tableau[i]=0; // On met cette valeur à 0
}
}
}

/******************************************************************************/

/****************************** Fonction tri croissant ************************/

// Cette fonction trie le tableau par ordre croissant
void Ordonner_tableau(int tableau[], int taille_tableau)
{
int temp;
int i=0;
int j=0;
for(i=0;i<taille_tableau;i++)
{
for(j=0;j<(taille_tableau-i);j++)
{
if(tableau[j]>tableau[j+1])
{
temp = tableau[j+1];
tableau[j+1]=tableau[j];
tableau[j]=temp;
}
}
}
printf("Les nouvelles valeurs du tableau triees sont : \n");
for(i=0;i<taille_tableau;i++)
{
printf("==> %d\n", tableau[i]);
}
}

/******************************************************************************
Hors ligne julink # Posté le 16/02/2012 à 13:31:04

Bonjour. je suis en plein dans les exercices de tableaux.
et je me suis lancer dans un tableaux qui génère tout seuls ses valeurs, aléatoirement biensur.
mais les valeurs qui saffiches sont juste la première valeur créé, en plusieur exemplaires.
voici mon code =D


Code : C
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main(int argc, char *argv[])
{
    int tableau[10], i=0;
    for (i=0 ; i<10 ; i++) //insertion de valeurs aléatoires dans le tableau
    {

    int valeurtableau = 0;

    srand(time(NULL));

    valeurtableau = (rand() % (100 - 0 + 1)) + 0;//générateur du nombre

    tableau[i] = valeurtableau;

    }
//affichage du tableau complet
int j=0;
for (j=0 ; j<10 ; j++)
    {

    printf("%d\n", tableau[j]); //affichage de toutes le valeurs du tableau.
    }
    return 0 ;
}


Merci de bien vouloir m'aider, je trouve pas. =D :p
Hors ligne tony33600 # Posté le 16/02/2012 à 16:03:12

voici ma solution pour l'exercice 5
si quelqu'un a des amélioration a proposer ou veux des explications il suffit de demander :)


Code : C
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
void ordonnerTableau (int tableau[], int tailleTableau)
{
    int i = 0, i2 = 0,tampon = 0;

    for (i2=0 ; i2<tailleTableau-1 ; i2++)
    {
        for (i=0 ; i<tailleTableau-1 ; i++) 
        {
            if (tableau[i2] > tableau[i+1] && i2<i+1) 
            {
                tampon = tableau[i2];
                tableau[i2] = tableau[i+1];
                tableau[i+1] = tampon;
            }
        }
    }
}
Hors ligne Ghost_anon # Posté le 16/02/2012 à 17:23:37
Avatar

Avis : Très bon

sérieux, j'avoue que je galère grave.

non pas que j'ai pas compris les cours, mais surtout, je dois chercher surement compliqué!

Après 6 heures de cogitations intensives, j'explique:

en programmation modulaire, mon tableau , qui était placé dans un fichier tableau.c et déclaré dans un fichier tableau.h dans le main, n'était pas du tout pris en compte par mes fonctions :(

4 heures plus tard , en regardant un peu les codes de mes co-programmeurs en herbe ( :p ), tous déclaraient leurs tableaux dans leur main.

Bon, je me suis dis, pourquoi pas, mais c'est nul, cela ne s'appelle plus de la programmation modulaire !!! enfin... passons.

cela m'avait débloqué les erreurs de compilation et ça marchait donc tant mieux :p

j'en suis qu'au troisième exercice , mais bon, j'aurais aimer comprendre pourquoi il voulait même pas savoir comment s'appelle mon tableau ^^

sérieux, j'ai relu le cours trois fois, en m'apercevant de certaines erreurs remarquées dans certains commentaires.

et mon code est quasi identique au cours (juste j'ai changé les noms de variables) et il veut rien entendre ce satané ordi :D

bref, si quelqu'un a rencontré ce même problème et y à remédier sans passer par une déclaration direct dans le main, je suis preneur :p

merci à vous
Hors ligne Wk-gentle # Posté le 16/02/2012 à 19:02:38

Bonjour ! J'ai réussi à faire la plupart de mes exercices, même si parfois j'ai du jeter un petit coup d’œil à ce que vous avez fait :p Mais je dois avouer que là je plante un peu ! Mon problème est à l'éxercice 4.

Lorsque j'essaie de compiler j'ai un message :

main.c|72|error: invalid use of void expression|

Voici mon main :
Code : C
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
int main(int argc, char *argv[])

{
int tableau[4] = {5, 10, 15, 20}; // initialisation du tableau
int tableauCopie[4] = {0};

    afficheTableauDeBase(tableau, 4);
    sommeTableau(tableau, 4); // On demande a la fonction sommeTableau de faire son taf.
    printf("La somme du tableau est : %d\n", sommeTableau(tableau, 4)); // On demande d'afficher le résultat de cette fonction
    printf("La moyenne des valeurs du tableau est %f\n\n", moyenneTableau(tableau, 4));
    printf("On execute une copie du tableau vers le deuxieme tableau\n\n");
	copieTableau(tableau, tableauCopie, 4);
	printf("\n");
	maximumTableau(tableau, 4, 10);


Et voici ma fonction maximumTableau :
Code : C
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
void maximumTableau(int tableau[], int tailleTableau, int valeurMax)
{
    int i;
    for (i = 0 ; i < tailleTableau ; i++)
    {
        if (tableau[i] > valeurMax)

        {
            tableau[i] = 0;
        }

       printf("%d",maximumTableau(tableau,tailleTableau,valeurMax));
    }
}

****** Je tiens à préciser que l'erreur pointe sur la ligne du printf qui correspond à la ligne 12 de ma fonction ici. *****
Si vous pouviez m'aider ça serait très aimable de votre part :p
Et j'espère que mon code est clair :)
Hors ligne Ghost_anon # Posté le 17/02/2012 à 05:32:07
Avatar

Avis : Très bon

Salut WK- gentle

pour moi, c'est ton printf à la fin de ta fonction qui serait pas bon.

tu essaies d'afficher une fonction alors que , j'imagine, c'est ton tableau que tu veux afficher

tu dois passer par une boucle avec une instruction du genre :

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

voilà :p

Edit : ah, et n'oublie pas de réinitialiser ta valeur i , si tu t'en sert pour ta boucle ^^
Hors ligne Wk-gentle # Posté le 17/02/2012 à 22:15:13

Ah oui effectivement ça marche :o Merci beaucoup ^^
Hors ligne Monkey D. John # Posté le 21/02/2012 à 15:17:16
Roi Des Pirates
Avatar

Avis : Très bon

Bonjour je suis débutant et je trouve ce site super avec de bonne explication mais j'ai un problème avec l'exercice 4 quelqu'un pourrait-il m'aider? merci Code : C
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <stdio.h>//bibliotheque
#include <stdlib.h>

//prototype
void maximumTableau(int tableau[], int tailleTableau, int valeurMax);

int main()//fonction principale
{
   int tableau[5];
   tableau[0]=91;
   tableau[1]=92;
   tableau[2]=93;
   tableau[3]=94;
   tableau[4]=95;
   int valeurMax=2;
   maximumTableau(tableau,5,valeurMax);

}
void maximumTableau(int tableau[], int tailleTableau, int valeurMax)
{
    int i;
    int j;
    for(i=0;i<5;i++)
{
    printf("%d\n",tableau[i]);
}
    for(i=0;i<valeurMax;i++)
{
    printf("0\n",tableau[i]);
}
}
Hors ligne Rikikijr # Posté le 23/02/2012 à 03:32:03

Ta fonction maximumTableau n'est pas bonne.
Il faut prendre chaque case du tableau et la comparer avec valeurMax, si c'est supérieur tu affecte 0 à cette case.
Il faut donc utiliser un if dans un for.

Si jamais tu n'y arrive vraiment pas la solution est là:
Secret (cliquez pour afficher)
Code : C
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
void  maximumTableau(int tableau[], int tailleTableau, int valeurMax)
{
    int i=0;
    for(i=0;i<tailleTableau;i++)
    {
        if(tableau[i]>valeurMax)
        {
            tableau[i]=0;
        }
    }

}


Et il y a une maniére plus "esthétique" d'initialiser ton tableau :p ( tableau[] = {...} )
Hors ligne parsodark # Posté le 01/03/2012 à 02:08:37

J'ai un problème avec l'exercice de moyenne.
Peut importe les nombreux test que j'ai fait, la fonction retourne toujours la taille du tableau au lieu de la moyenne.

Voici le main:
Code : Autre
1
2
3
4
5
6
7
8
9
10
11

int main (int argc, const char * argv[])
{

    int tableau[4]={3, 5, 21, 6}, somme=0, tailleTableau=4;
    double moyenne=0;
    
    moyenne = calculMoyenne(tableau, tailleTableau);
    printf("La moyenne est de : %f\n", moyenne);
       
    return 0;
}


et la fonction calculMoyenne :

Code : Autre
1
2
3
4
5
6
7
8
9
10
11

double calculMoyenne(int tableau[], int tailleTableau)
{
    int i;
    double moyenne;
    for (i=0; i<tailleTableau; i++)
    {
        moyenne +=tableau[i];
    }
    
    return moyenne/tailleTableau;
}


Juste avant le return de la fonction, moyenne=8,75 (selon le débugger)
Mais juste après (ou juste avant le printf), moyenne=4 (toujours selon le débugger)

Le 4 retourné correspond à la taille du tableau. J'ai changé la variable tailleTableau à 3, et la fonction a retourné 3.

Est-ce quelqu'un a la réponse à ma solution ?

Note: J'utilise Xcode 4.0.2, je ne sais pas si ça peux aider ...

Merci d'avance !
Hors ligne EGP # Posté le 03/03/2012 à 02:08:23
Avatar

 voici mon programme de l'EXO 05 :)
Code : C
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <stdio.h>
#include <stdlib.h>
#include "main.h"

void main()
{
 int tab[10],i;
 for(i=0;i<10;i++)
 scanf("%d", tab+i); //remplir le tableau
 ordonner(tab);// aller a la fonction ordonner 
 printf("\n\n");
 for(i=0;i<10;i++)
 printf("%d\n",tab[i]);
}

void ordonner(int tab[])
{
    int i,j,min;
    for(i=1;i<10;i++)
       {
       for(j=i;j<10;j++)
       if (tab[j]<tab[i-1])
            {
            min=tab[j];     // teste et pérmutation en même temps 
            tab[j]=tab[i-1];
            tab[i-1]=min;
            }
       }
}
un robot qui rêve 01001100001011101011010100001011101110101110111100010111010001010111101101011110110101010101001111......... soudain 2 oO !!!!!????
 
Hors ligne Ghali-Aji # Posté le 04/03/2012 à 17:10:26
Avatar

Avis : Très bon

pour parsodark

salut , je voulais juste te dire, si tu n'as pas encore trouvé ton erreur , qu'il faudra initialiser la variable moyenne dans la seconde fonction :
moyenne=0 .
Hors ligne parsodark # Posté le 06/03/2012 à 22:54:34

C'est étrange, ça me donne encore 4. 4.000000000 pour être plus précis ...

Le nouveau code (deuxième fonction) :
Code : Autre
1
2
3
4
5
6
7
8
9
10
11
12
13

double calculMoyenne(int tableau[], int tailleTableau)
{
    int i=0;
    double moyenne=0;
    for (i=0; i<tailleTableau; i++)
    {
        moyenne +=tableau[i];
    }
    
    moyenne=moyenne/tailleTableau;
    
    return moyenne;
}
Hors ligne Jule601 # Posté le 08/03/2012 à 11:19:42

Bonjour à tous !!
Merci pour ce superbe tuto!
J'aurais une question a vous demander, pourriez vous m'expliquer un truc sur l'exercice 5?
Voici ma fonction :
Code : C
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
void ordonnerTableau(int tableau[], int tailleTableau)
{
    
    int i=0, j=0, tmp=0;

    for ( i = 0 ; i < tailleTableau ; i++)
    {
        for ( j = 0 ; j < tailleTableau ; j++)
        {
            if (tableau[j] > tableau[j+1]) 
            {
                tmp = tableau[j];
                tableau[j] = tableau[j+1];
                tableau[j+1] = tmp;
             }
     }
        printf("|%d\n", tableau[i]);

    }
    
}


Ca me classe que les trois derniers chiffres. par contre j'ai regardé un peu sur le forum, j'ai trouvé une condition et des que je change la condition de la boucle j par
Code : C
1
for (j = tailleTableau - 2; j >= 0; j--)

, cela fonctionne.
Pourriez vous m'expliquer comment et pourquoi cela fonctionne?

Merci
Hors ligne tofe69 # Posté le 08/03/2012 à 18:52:31

Jule601 ton tri ne fonctionne pas car tu ne testes pas les 1ères valeurs de ton tableau dans ta boucle J quand J>0

Ex : si tu as dans ton tableau 15 9 8 7 1
quand tu incrémentes i ton programme après 1ère boucle 9 15 8 7 1, après 2ème boucle 9 8 15 7 1, 3ème boucle 9 8 7 15 1, 4ème boucle 3 8 7 1 15
ensuite tu incrémentes i et tu recommences boucle J
et la tu ne testes pas ta première valeur à savoir si 3 est inférieur ou supérieur à 8, en effet ton premier test dans la boucle est 8 est-il inférieur ou supérieur à 7?
Avec ta méthode il aurait fallu faire une autre boucle k par exemple
De plus pour ta boucle J quand J = tailleTableau tu testes l'égalité de la dernière case de ton tableau avec quoi. Le dernier test à faire est de comparer avant dernière case avec dernière donc (J = 0; j < tailleTableau - 1; J++)

void ordonnerTableau(int table[], int taille)
{
int i=0, j=0,k=0, tmp=0;

printf("\n\nLes valeurs classees sont :\t");
for ( i = 0 ; i < taille ; i++)
{
for ( k = 0 ; k < taille ; k++)
{
for ( j = 0 ; j < taille-1-k ; j++)
{
if (table[j] > table[j+1])
{
tmp = table[j];
table[j] = table[j+1];
table[j+1] = tmp;
}
}
}
printf(" %d", table[i]);
}
}
De plus pourquoi trier à nouveau la fin de ton tableau dans 2ème boucle J puisque tu as mise plus grande valeur en dernière position de ton tableau d'où : j < taille-1-k

Ceci n'était que des explications et bien sûr il y a plus simple
Pour accéder à cette section
Connectez-vous !
connexion_rpx