Les fonctions (Correction)

Exercice 1
float moyenne;
Ecrivez une fonction factorielle() qui retourne la fac- moyenne=(a+b)/2;
torielle d’un nombre entier naturel N (N ≥ 0). Testez
la fonction. Assurez vous de fournir un entier N ≥ 0 à return moyenne;
la fonction. }
/// La fonction principale main
main()
Prototype de la fonction : {
int factorielle (int N) ;
float a,b;
printf("Donner la valeur de a : ");
Correction
scanf("%f",&a);
printf("Donner la valeur de b : ");
#include <stdio.h>
scanf("%f",&b);
#include <stdlib.h>
/// Appel de la fonction moyenne
///définition de la fonction
printf("La moyenne de a et b est : %f
int factorielle (int N)
",moyenne(a,b));
{
}
int i;
int fact=1;
Exercice 3
for(i=1; i<=N; i++)
fact=fact*i; Ecrirez une fonction min et une fonction max qui
return fact; déterminent le minimum et le maximum de deux
} nombres réels. Testez les deux fonctions.
/// La fonction principale main
main() Prototype des fonctions :
{ float max (float a,float b );
int N; float min (float a,float b );
do
{ Correction
printf("Donner un nombre entier naturel >=
0 : "); #include <stdio.h>
scanf("%d",&N); #include <stdlib.h>
} ///définition de la fonction max
while(N<0); float max (float a,float b )
///L'appel de la fonction factorielle {
printf("La factorielle de N est %d float max;
",factorielle(N)); if(a>b)
} max=a;
else
Exercice 2 max=b;

Ecrivez un programme se servant d'une fonction return max;

}
moyenne du type float (réel) pour afficher la
moyenne arithmétique de deux nombres réels entrés ///définition de la fonction min
au clavier. Testez la fonction. float min (float a,float b )
{
float min;
Prototype de la fonction : if(a<b)
float moyenne (float a,float b ) ; min=a;
else
Correction min=b;
#include <stdio.h> return min;
#include <stdlib.h> }
///définition de la fonction
float moyenne (float a,float b )
{
/// La fonction principale main Prototype de la fonction :
main() int strlen(char *S);
{
float a,b; Correction
printf("Donner la valeur de a : ");
scanf("%f",&a); #include <stdio.h>
printf("Donner la valeur de b : "); #include <stdlib.h>
scanf("%f",&b); ///définition de la fonction strlen
/// Appel de la fonction max int strlen(char *S){
printf("\nLe maximum de a et b est : %f int l;
",max(a,b)); for(l=0;*S!='\0';S++)
/// Appel de la fonction min l++;
printf("\nLe minimum de a et b est : %f
",min(a,b)); return l;
} }
/// La fonction principale main
Exercice 4 main()
{
char *chaine; ///Déclarer un pointeur au
Ecrirez une fonction exp() qui permet de calculer la lieu d'un tableau
puissance nième: du nombre réel avec un entier /// Allouer l'espace mémoire
(positif, négatif, nul). Testez la fonction. chaine=(char *)malloc(sizeof(char));
printf("Donner une chaine de caractère :
");
Prototype de la fonction :
///lire une chaine de caractère par le cla-
float exp (float x, int n );
vier
gets(chaine);
Correction
/// Appel de la fonction strlen
printf("La longueur de la chaine est :
#include <stdio.h>
%d",strlen(chaine));
#include <stdlib.h>
///Libérer l'espace mémoire alloué
///définition de la fonction exp
free(chaine);
float exp (float x, int n )
chaine=NULL;
{
}
int i;
float exp=1;
if(n>0) Exercice 6
for(i=1; i<=n; i++)
exp=exp*x; 1- Ecrivez une fonction lire_tab() qui permet de lire
if(n<0)
for(i=1; i<=-n; i++) les éléments d’un tableau à une dimension (N) de type
exp=exp*1/x; entier.
return exp; Prototype de la fonction:
} void lire_tab (int *T, int N) ;

/// La fonction principale main

main()
2- Ecrivez une fonction ecrire_tab() qui permet
{ d’afficher les éléments d’un tableau à une dimension
int n; (N) de type entier.
float x;
do
{ Prototype de la fonction:
printf("Donner l'exposant N : "); void ecrire_tab (int *T, int N) ;
scanf("%d",&n);
printf("Donner la base x : "); 3- Ecrivez une fonction somme_tab() qui permet de
scanf("%f",&x); calculer la somme des éléments d’un tableau à une
}
while(x==0 && n<0); // si x=0 et n <0 dimension (N) de type entier.
///Appel de la fonction exp
printf("%f à la puissance %d est Prototype de la fonction:
%f",x,n,exp(x,n)); int somme_tab (int *T, int N) ;
}
4- Ecrivez une fonction produit_tab() qui permet de
Exercice 5 calculer le produit des éléments d’un tableau à une
dimension (N) de type entier.
Ecrivez une fonction strlen() qui permet de calculer la
longueur d’une chaîne de caractère. Tester la fonction.
Prototype de la fonction: for(i=0; i<N; i++)
int produit_tab (int *T, int N) ; prod=prod* *(T+i);
return prod;
}
5- Ecrivez une fonction moy_tab() qui permet de cal-
///5- Calculer la moyenne des éléments du
culer la moyenne des éléments d’un tableau à une tableau
dimension (N) de type entier. float moy_tab (int *T, int N)
{
float moy;
Prototype de la fonction : moy=(float)somme_tab(T,N)/N;
float moy_tab (int *T, int N) ;
return moy;
}
6- Ecrivez une fonction inv_tab() qui permet
d’inverser les éléments d’un tableau à une dimension ///6- Inverser les éléments du tableau
void inv_tab (int *T, int N)
(N) de type entier. {
int aide,i,j;
Prototype de la fonction : for(i=0,j=N-1; i<j; i++,j--)
void inv_tab (int *T, int N) ; {
aide=*(T+i);
7- Ecrivez un programme qui fait l’appel à ces fonc- *(T+i)=*(T+j);
*(T+j)=aide;
tions pour lire, afficher, calculer la somme, la }
moyenne des valeurs d’un tableau T d’entiers de di- }
mension N (N≥3) et afficher son inverse. Utilisez /// 7- La fonction principale
main()
l’allocation dynamique de mémoire pour le tableau {
T. int *T;
int N,somme,produit;
float moyenne;
Correction do
#include <stdio.h> {
#include <stdlib.h> printf("Donner la dimension N : ");
///1- lire les éléments du tableau scanf("%d",&N);
void lire_tab(int *T, int N) }while(N<3); /// Pas de limite
{
int i; T=(int *)malloc(N*sizeof(int));
for(i=0; i<N; i++) if(T==NULL){
{ printf("Pas assez d'espace memoire...");
printf("Donner T[%d]: ",i+1); exit(-10);
scanf("%d",T+i); }
} lire_tab(T,N);
} printf("Le tableau donne est :\n");
/// 2- Afficher les éléments du tableau ecrie_tab(T,N);
void ecrie_tab(int *T, int N) somme=somme_tab(T,N);
{ produit=produit_tab(T,N);
int i; moyenne=moy_tab(T,N);
for(i=0; i<N; i++) printf("\nLa somme des elements du Tableau
{ est : %d", somme);
printf("%3d",*(T+i)); printf("\nLe produit des elements du Ta-
} bleau est : %d", produit);
} printf("\nLa moyenne des elements du Ta-
///3- Calculer la somme des éléments du ta- bleau est : %f\n", moyenne);
bleau inv_tab(T,N);
int somme_tab (int *T, int N) printf("\nLe tableau inverse est :\n");
{ ecrie_tab(T,N);
int i; free(T);
int som=0; T=NULL;
for(i=0; i<N; i++) }
som=som+ *(T+i);
return som;
}
///4- Calculer le produit des éléments du
tableau
int produit_tab (int *T, int N)
{
int i;
int prod=1;