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 XN pour une valeur réelle X (type double) et une valeur entière positive N (type int) :

a) EXP1 retourne la valeur XN comme résultat.

b) EXP2 affecte la valeur XN à 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) -prg-c70 
où x est un entier compris entre 1 et 10.

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:

         Introduire un nombre entier : 6457392
Le nombre 6457392 a 7 chiffres.

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:

 1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
. . .

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.

prg-c71



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>

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;
}

 

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
#include <stdio.h>

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.




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
#include <stdio.h>

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 (X<Y)
     return 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<Y) ? X : Y;
}
double MAX(double X, double Y)
{
 return (X>Y) ? X : Y;
}
 */

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <math.h>
 main()
{
 /* Prototypes des fonctions appelées */
 double F(int X);
 /* Variables locales */
 int I;
 /* Traitements */
 printf("\tX\tF(X)\n");
 for (I=1 ; I<=10 ; I++)
      printf("\t%d\t%f\n", I, F(I)); 
 return 0;
}
double F(int X)
{
 return sin(X)+log(X)-sqrt(X);
}

 

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
#include <stdio.h>
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 (N<0) 
      N *= -1;
  /* Compter les chiffres */
 for (I=1; N>10; I++)
      N /= 10;
 return I;
}

 



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <stdio.h>

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;
}

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
#include <stdio.h>

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; P<LIGNES; P++)
      LIGNEC(P);
}
void LIGNEC(int P)
{
  /* Prototypes des fonctions appelées */
 double C(int P, int Q);
 /* Variables locales */
 int Q;
 /* Traitements */
 for (Q=0; Q<=P; Q++)
      printf("%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)
{
 . . .
}