Exercices langage C fonctions types simples

Exercice 1

Ecrire un programme se servant d'une fonction MOYENNE du type float pour afficher la moyenne arithmétique de deux nombres réels entrés au clavier.

Exercice 2

Ecrire deux fonctions qui calculent la valeur X^N pour une valeur réelle X (type double) et une valeur entière positive N (type int) :

a) EXP1 retourne la valeur X^N comme résultat.

b) EXP2 affecte la valeur X^N à X.

Ecrire un programme qui teste les deux fonctions à l'aide de valeurs lues au clavier.

Exercice 3

Ecrire une fonction MIN et une fonction MAX qui déterminent le minimum et le maximum de deux nombres réels.

Ecrire un programme se servant des fonctions MIN et MAX pour déterminer le minimum et le maximum de quatre nombres réels entrés au clavier.

Exercice 4

Ecrire un programme se servant d'une fonction F pour afficher la table de valeurs de la fonction définie par

f(x) = sin(x) + ln(x) -

Exercice 5

Ecrire la fonction NCHIFFRES du type int qui obtient une valeur entière N (positive ou négative) du type long comme paramètre et qui fournit le nombre de chiffres de N comme résultat.

Ecrire un petit programme qui teste la fonction NCHIFFRES:

Exemple:

Exercice 6

En mathématiques, on définit la fonction factorielle de la manière suivante:

0! = 1

n! = n*(n-1)*(n-2)* ... * 1 (pour n>0)

Ecrire une fonction FACT du type double qui reçoit la valeur N (type int) comme paramètre et qui fournit la factorielle de N comme résultat. Ecrire un petit programme qui teste la fonction FACT.

Exercice 7

Ecrire un programme qui construit et affiche le triangle de Pascal en calculant les coefficients binomiaux:

On n'utilisera pas de tableau, c.-à-d. il faudra calculer les coefficients d'après la formule ci-dessous, tout en définissant et utilisant les fonctions adéquates.

#include
main()
{
/* Prototypes des fonctions appelées */
float MOYENNE(float X, float Y);
/* Variables locales */
float A,B;
/* Traitements */
printf("Introduire deux nombres : ");
scanf("%f %f", &A, &B);
printf("La moyenne arithmétique de %.2f et %.2f est %.4f\n",
A, B, MOYENNE(A,B));
return 0;
}
float MOYENNE(float X, float Y)
{
return (X+Y)/2;
}

#include
main()
{
/* Prototypes des fonctions appelées */
double EXP1(double X, int N);
void EXP2(double *X, int N);
/* Variables locales */
double A;
int B;
/* Traitements */
printf("Introduire un réel X : ");
scanf("%lf", &A);
printf("Introduire l'exposant positif N : ");
scanf("%d", &B);
/* a */
printf("EXP1(%.2f , %d) = %f\n", A, B, EXP1(A,B));
/* b */
/* Comme la valeur initiale de A est perdue à l'appel */
/* de EXP2, il faut partager l'affichage si on veut */
/* afficher la valeur de A avant et après l'appel ! */
printf("EXP2(%.2f , %d) = ", A, B);
EXP2(&A, B);
printf("%f\n", A);
return 0;
}
double EXP1(double X, int N)
{
double RES;
for (RES=1.0; N>0; N--)
RES *= X;
return RES;
}

void EXP2(double *X, int N)
{
double AIDE;
for (AIDE=1.0; N>0; N--)
AIDE *= *X;
*X = AIDE;
}

Remarque: Cette solution de EXP2 respecte automatiquement le cas où N=0.

#include
main()
{
/* Prototypes des fonctions appelées */
double MIN(double X, double Y);
double MAX(double X, double Y);
/* Variables locales */
double A,B,C,D;
/* Traitements */
printf("Introduire 4 réels : ");
scanf("%lf %lf %lf %lf", &A, &B, &C, &D);
printf("Le minimum des 4 réels est %f \n",
MIN( MIN(A,B), MIN(C,D)) );
printf("Le maximum des 4 réels est %f \n",
MAX( MAX(A,B), MAX(C,D)) );
return 0;
}
double MIN(double X, double Y)
{
if (Xreturn X;
else
return Y;
}
double MAX(double X, double Y)
{
if (X>Y)
return X;
else
return Y;
}
/* ou bien */
/*
double MIN(double X, double Y)
{
return (X}
double MAX(double X, double Y)
{
return (X>Y) ? X : Y;
}
*/

#include
#include
main()
{
/* Prototypes des fonctions appelées */
double F(int X);
/* Variables locales */
int I;
/* Traitements */
printf("\tX\tF(X)\n");
for (I=1 ; Iprintf("\t%d\t%f\n", I, F(I));
return 0;
}
double F(int X)
{
return sin(X)+log(X)-sqrt(X);
}

#include
main()
{
/* Prototypes des fonctions appelées */
int NCHIFFRES(long N);
/* Variables locales */
long A;
/* Traitements */
printf("Introduire un nombre entier : ");
scanf("%ld", &A);
printf("Le nombre %ld a %d chiffres.\n",A ,NCHIFFRES(A));
return 0;
}
int NCHIFFRES(long N)
{
/* Comme N est transmis par valeur, N peut être */
/* modifié à l'intérieur de la fonction. */
int I;
/* Conversion du signe si N est négatif */
if (NN *= -1;
/* Compter les chiffres */
for (I=1; N>10; I++)
N /= 10;
return I;
}

#include
main()
{
/* Prototypes des fonctions appelées */
double FACT(int N);
/* Variables locales */
int N;
/* Traitements */
printf("Introduire un nombre entier N : ");
scanf("%d", &N);
printf("La factorielle de %d est %.0f \n",N , FACT(N));
return 0;
}
double FACT(int N)
{
/* Comme N est transmis par valeur, N peut être */
/* modifié à l'intérieur de la fonction. */
double RES;
for (RES=1.0 ; N>0 ; N--)
RES *= N;
return RES;
}

#include
main()
{
/* Prototypes des fonctions appelées */
void TRIANGLE(int LIGNES);
/* Variables locales */
int N;
/* Traitements */
printf("Introduire le nombre de lignes N : ");
scanf("%d", &N);
TRIANGLE(N);
return 0;
}
void TRIANGLE(int LIGNES)
{
/* Prototypes des fonctions appelées */
void LIGNEC(int P);
/* Variables locales */
int P;
/* Traitements */
for (P=0; PLIGNEC(P);
}
void LIGNEC(int P)
{
/* Prototypes des fonctions appelées */
double C(int P, int Q);
/* Variables locales */
int Q;
/* Traitements */
for (Q=0; Qprintf("%6.0f", C(P,Q));
printf("\n");
}
double C(int P, int Q)
{
/* Prototypes des fonctions appelées */
double FACT(int N);
/* Traitements */
return FACT(P)/(FACT(Q)*FACT(P-Q));
}
double FACT(int N)
{
. . .
}