Exercice 1

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

Exercice 2

#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.

Exercice 3

#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;
}
 */

Exercice 4

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

Exercice 5

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

Exercice 6

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

Exercice 7

#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)
{
 . . .
}