You are on page 1of 20

ESTI 2008-2009 M.

Sammoud

EXERCICES DE REVISION

PROGRAMMATION I

1
ESTI 2008-2009 M. Sammoud

Les Chaînes de caractères

L’objectif de ces exercices est la manipulation des chaînes de caractères en utilisant les
fonctions offertes par la bibliothèque <string.h>

Exercice 1

a) Ecrire une fonction déterminant le nombre de lettres e (minuscules) présentes dans un


texte (supposée ne pas dépasser 132 caractères) fourni au clavier. En utilisant la
fonction strchr de string.h
b) Ecrire une procédure qui supprime toutes les lettres e (minuscules) d'un texte
(supposée ne pas dépasser 132 caractères) fourni au clavier. Le texte ainsi modifié sera
créé, en mémoire, à la place de l'ancien.
c) Ecrire une procédure qui lit au clavier un texte et qui l'affiche "à l'envers ‘‘.

Pour tester ces sous programmes on vous demande d’écrire un programme principal qui
permet de saisir un texte (supposée ne pas dépasser 132 caractères), on utilisera les tableaux
dynamiques pour la déclaration du texte et la fonction gets pour saisir le texte qui doit se
terminer par return. Quelle est la différence entre scanf et gets (pour répondre, testez
avec les deux)
Faites appel à toutes les fonctions et procédures implémentées au dessus dans votre main.

/*******************************************************
CORRECTION
AUTEUR : M. SAMMOUD
1ERE ANNEE INFORMATIQUE APPLIQUEE (ESTI)
*********************************************************/
Exercice 1

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

#define CAR 'e'


#define LGMAX 132

/* Exercice 1
a) en utilisant la fonction strchr

****Que fait strchr ?******

Find a character in a string.


char *strchr( const char *string, int c );
Return Value :
Each of these functions returns a pointer to the first occurrence of c in
string, or NULL if c is not found.*/

int compter_apparition_car (char * texte)


{
char* adr=texte;

2
ESTI 2008-2009 M. Sammoud

int nbre=0;
while((adr=strchr(adr,CAR))!= NULL)
/*strchr retourne un pointeur vers la première occurrence de CAR, on teste
si c'est Différent de NULL on continu l'itération sinon on sort de la
boucle */
{
nbre++;
adr++;

return nbre;
}

// b) supprimer toutes les apparitions de CAR ('e')

void supprimer_apparition_car (char * texte)


{
char*adr=texte;
while((adr=strchr(adr,CAR))!= NULL)
strcpy(adr, adr+1); //faire le décalage en supprimant le ième CAR
}

// c) affichage à l'envers

void afficher_envers (char * texte)


{
int i;
for(i=strlen(texte);i>=0;i--)
putchar(texte[i]);
}

// programme principal

void main()
{
int cmpt=0;

char * texte=(char*)malloc(LGMAX*sizeof(char));

// Saisir le texte

printf("\n Donnez un texte termine par return \n");

gets(texte);//

// question a)

cmpt= compter_apparition_car (texte);


printf ("\n le nombre d'apparition de %c est %d \n ",CAR, cmpt) ;

//Question b)

supprimer_apparition_car (texte);
printf ("\n Voici votre texte prive des caractères %c \n ",CAR) ;
puts(texte);

3
ESTI 2008-2009 M. Sammoud

//Question c)

afficher_envers (texte);

Exercice 2
Ecrire une procédure qui lit un verbe du premier groupe et qui en affiche la conjugaison au
présent de l'indicatif, sous la forme :
Je programme
Tu programmes
Il programme
Nous programmons
Vous programmez
Ils programment

Le programme devra vérifier que le mot fourni se termine bien par ''er". On supposera qu'il ne
peut comporter plus de 26 lettres et qu'il s'agit d'un verbe régulier. Autrement dit, on
admettra que l'utilisateur ne fournira pas un verbe tel que "manger" (le programme
afficherait alors : ''nous mangons" !).
Testez cette procédure en implémentant un programme principal.
Exercice 2

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

#define LGMAX 26

/* Exercice 2*/

void conjuger( char* verbe)


{
char * adr_fin;
char * terminaison[6]={"e","es","e","ons","ez","ent"};
/*initialisation du tableau*/
char * deb[6]={"je","tu","il","nous","vous","ils"};
int i;
printf("\n indicatif present : \n");

adr_fin=verbe+strlen(verbe)-2;

for(i=0;i<6;i++)
{
strcpy(adr_fin,terminaison[i]);
printf("\n %s %s \n", deb[i], verbe);
}

void main()
{

char * verbe=(char*)malloc(LGMAX*sizeof(char));

4
ESTI 2008-2009 M. Sammoud

char *fin;

// Saisir le verbe

do
{
printf("\n Donnez un verbe du premier groupe \n");
gets(verbe);
fin=verbe+strlen(verbe)-2;

}while(strcmp(fin,"er"));

conjuger( verbe);

Exercices de l’examen 2007-2008

Exercice 2 (3 points)

Soit le programme suivant :

typedef enum boolean {FALSE, TRUE};

boolean test ( )
{
int i, nbre;
boolean Ok;
do
{
printf (" donnez un nombre entier compris entre 0 et
100") ;
scanf ("%d", &nbre) ;
}while((nbre<0)||(nbre>100)) ;
/* initialisation du traitement */

/* initialisation de l’avancement */
i=2 ;
/* initialisation de l’arret */
Ok=TRUE;
while ((i<nbre) && (Ok==TRUE))
{
if ((nbre % i) ==0) /*arret*/
Ok=FALSE;
else
i++; /* traitement et avancement*/
}
return Ok;
}

5
ESTI 2008-2009 M. Sammoud

a) Que fait la fonction test ? (1 point)


La fonction test permet de déterminer si un nombre entier compris entre 0 et 100 est
premier ou non.
b) Reprenez cette fonction en remplaçant la boucle while par la boucle for (1 point)
typedef enum boolean {FALSE, TRUE};
boolean test ( )
{
int i, nbre;
boolean Ok;
do
{
printf (" donnez un nombre entier compris entre 0 et
100") ;
scanf ("%d", &nbre) ;
}while((nbre<0)||(nbre>100)) ;
/* initialisation du traitement */
/* initialisation de l’avancement */
/* initialisation de l’arret */
Ok=TRUE;
For(i=2;i<nbre;i++)(0.25 points)
{
if ((nbre % i) ==0) /*arret*/(0.25 points)
{
Ok=FALSE; (0.25 points)
i=nbre; /*pour sortir de la boucle*/(0.25
points)
}
}
return Ok;
}
c) Reprenez cette fonction en remplaçant la boucle while par la boucle do… while (1 point)
typedef enum boolean {FALSE, TRUE};
boolean test ( )
{
int i, nbre;
boolean Ok;
do
{
printf (" donnez un nombre entier compris entre 0 et
100") ;
scanf ("%d", &nbre) ;
}while((nbre<0)||(nbre>100)) ;
/* initialisation du traitement */
/* initialisation de l’avancement */
i=2 ; (0.25 points)
/* initialisation de l’arret */
Ok=TRUE; (0.25 points)
do
{(0.25 points)
if ((nbre % i) ==0) /*arret*/
Ok=FALSE;
else
i++; /* traitement et avancement*/

6
ESTI 2008-2009 M. Sammoud

} while ((i<nbre) && (Ok==TRUE)) (0.25 points)


return Ok;
}
Exercice 3 (5 points)
Soit CH une chaine de caractère qui contiendra 50 caractères. (On rappelle qu’une chaîne de
caractère est un tableau de caractères.)
a) Proposer une déclaration de CH en utilisant les tableaux dynamiques. (0.5 point)
Char * CH ; (0.5 points)
b) Quelle est l’instruction qu’on doit ajouter après la déclaration de CH pour pouvoir la
saisir ? pourquoi ? (1 point)
CH= (char*)malloc(51 * sizeof(char)) ; (0.5 points)
Puisque la déclaration (sans malloc) nous réserve de l’espace mémoire pour
seulement une seule case celle de la première lettre de la chaîne mais avec malloc
on réserve de l’espace mémoire pour 51 cases, pour pouvoir écrire dans CH
(0.5 points)
c) Implémenter la procédure suivante :
void saisir_chaine (char * chaine) ; (0.5 point)
void saisir_chaine (char * chaine)
{
printf("veuillez saisir la chaine de caractère") ;
scanf("%s", chaine) ;
}
d) Implémenter la fonction calculer_nbre_occ qui permet de calculer le nombre
d’occurrences d’un caractère dans une chaine de caractère (sans faire la distinction entre
majuscule ou minuscule), en utilisant la boucle adéquate, cette fonction aura le prototype
suivant : (2 points)
int calculer_nbre_occ (char c, char*chaine) ;
#include<ctype.h>
int calculer_nbre_occ (char c, char*chaine)
{
int i, nbre ; (0.25 point)
nbre=0 ; (0.25 point)
for ( i=0 ; chaine[i] !=’\0’ ;i++)(0.25 point)
{
if(toupper(chaine[i])==toupper(c)) (0.75 point)
/*ou bien if(tolower(chaine[i])==tolower(c))*/
nbre++;(0.25 point)
}
return (nbre); (0.25 point)
}
e) Proposer un programme principale qui permet de saisir une chaine de caractères CH puis
d’afficher les occurrences des voyelles qui figurent dans CH (1 point)
#include<stdio.h>
#include<stdlib.h>
void main()
{
int n,i;
char tab[6]={'a','e','u','i','y','o'};0.25
char * ch=(char*)malloc(51 * sizeof(char)) ;
saisir_chaine (ch); 0.25
for(i=0;i<6;i++)
{

7
ESTI 2008-2009 M. Sammoud

n=calculer_nbre_occ (tab[i], ch);0.25


if(n !=0) 0.25
printf("L'occurrence de %c est : %d",tab[i],n) ;
}
}

Exemple : si CH est la chaine : "chainEdecarActEre"


Le résultat de l’exécution du programme donnera :
L’occurrence de ‘a’ est : 3
L’occurrence de ‘e’ est : 4
L’occurrence de ‘i’ est : 1
Problème (9 points)

Un nombre complexe est défini par une partie réelle et une partie imaginaire. (Exemple : 3.5+5*i est
un nombre complexe) On se propose dans cet exercice d’effectuer quelques opérations sur ces
nombres.
1) Définir une structure de données en C permettant de représenter un nombre
complexe. (1 point)
Un nombre complexe peut être représenté en utilisant les enregistrements : 0.5
point
struct Complexe
{
float reel ;
float imaginaire ;
} ; 0.5 point

2) Que doit on ajouter à cette structure de données pour qu’elle devienne un type ?
On ajoute l’instruction typedef pour que complexe se comporte comme un type.
(0.5 point)
3) Pour saisir un nombre complexe on vous demande d’écrire une procédure
appelée Saisir_Complexe. En supposant qu’on a définit un type tComplex
voici des propositions de prototypes pour cette procédure, une seule est correcte
indiquez laquelle, en justifiant votre réponse et en indiquant quels sont les erreurs
dans les trois propositions fausses. (2.5 points)
a) tComplex Saisir_Complexe( ) ;
b) void Saisir_Complexe( ) ;
c) void Saisir_Complexe(tComplex C1) ;
d) void Saisir_Complexe(tComplex * C1) ;
d) void Saisir_Complexe(tComplex * C1) ;est le prototype
correcte (0.5 point), c’est une procédure et le passage de
paramètre est par adresse donc tout changement sera sauvegardé
(0.5 point)
e) tComplex Saisir_Complexe( ) ; on demande
d’implémenter une procédure et e) est une
fonction puisqu’elle a une valeur de retour (0.5
point)

8
ESTI 2008-2009 M. Sammoud

f) void Saisir_Complexe( ) ;il n’y a pas de


paramètres entrés donc la saisie ne sera pas
sauvegardée (0.5 point)
g) void Saisir_Complexe(tComplex C1) ; le passage de
paramètre est fait par valeur donc tout
changement est fait sur des copies des paramètres
donc en sortant de la fonction la valeur saisie
sera perdu (0.5 point)

4) implémenter la procédure Saisir_Complexe (2 points)

void Saisir_Complexe(tComplex * C1)


{
Printf("Donnez la partie reelle") ;
Scanf("%f",C1Æreel) ;/* ou bien
Scanf("%f",&((*C1).reel) ;*/0.5
Printf("Donnez la partie imaginaire") ;
Scanf("%f",C1Æimaginaire) ;/* ou bien Scanf("%f",&((*C1).
imaginaire) ;*/0.5

}
5) implémenter les fonctions suivantes :
a) est_reel_pure : retourne 0 (ou faux) si le complexe possède une
partie imaginaire différente de 0 (0.25 point)

int est_reel_pure (tComplex C)


{
if (C.imaginaire==0)
return 1 ;
else
return 0 ;
}/* ou bien directement return (C.imaginaire==0)*/

b) est_egale : retourne 1 (ou vrai) si C1 et C2 sont égaux avec C1 et C2


sont deux nombres complexes (0.25 point)
int est_egale (tComplex C1, tComplex C2)
{
if ((C1.imaginaire==C2.imaginaire)&&( C1.reel==C2.reel))
return 1 ;
else
return 0 ;
}
c) additionner : retourne un nombre complexe qui est C1 + C2
(0.25 point)

tComplex additionner (tComplex C1, tComplex C2)


{
tComplex Res ;
Res. Reel= C1.reel+C2.reel;

9
ESTI 2008-2009 M. Sammoud

Res. Imaginaire= C1.imaginaire+C2.imaginaire ;


return Res ;
}
d) soustraire : retourne un nombre complexe qui est C1 - C2
(0.25 point)

tComplex soustraire (tComplex C1, tComplex C2)


{
tComplex Res ;

Res. Reel= C1.reel-C2.reel;


Res. Imaginaire= C1.imaginaire-C2.imaginaire ;

return Res ;
}

6) proposez un programme principal qui testera toutes les fonctions et les procédures
décrites au dessus, on utilisera le menu suivant : (2 points)

1- Saisir un nombre complexe


2- Comparer deux nombres complexes
3- Réel pure
4- Somme
5- Soustraction
6- Quitter
DONNEZ VOTRE CHOIX :

Indication :
- utilisez la structure conditionnelle switch…case pour le menu.
- Le programme ne s’arrête que si le choix entré est 6, utilisez la boucle adéquate.

void main()
{
int choix ;
tComplex C1,C2, som, dif ;
do
{
Printf("\n 1- Saisir un nombre complexe\n
\n 2- Comparer deux nombres complexes\n
\n 3- Réel pure\n
\n 4- Somme\n
\n 5- Soustraction\n
\n 6- Quitter\n
\n \t\t\t\tDONNEZ VOTRE CHOIX : ") ;
Scanf("%d",&choix) ;0.25

switch (choix)
{

10
ESTI 2008-2009 M. Sammoud

case 1 :
Saisir_Complexe(& C1) ;
break ;
case 2 :
{
Saisir_Complexe(& C2) ;
if(est_egale(C1,C2)==1)
printf("les deux nombre complexes sont egaux") ;
else
printf("les deux nombre complexes ne sont pas egaux") ;

break ;
}
case 3 :
if(est_reel_pure(C1)==1)
printf("le nombre complexes %d + %d*i est reel pure",
C1.reel, C1.imaginaire) ;
else
printf("le nombre complexes %d + %d*i n’est pas
reel pure", C1.reel, C1.imaginaire) ;
break ;

case 4 :
som= additionner (C1,C2);
printf("la somme de (%d + %d*i) et (%d + %d*i)est (%d +
%d*i)", C1.reel, C1.imaginaire, C2.reel,C2.imaginaire, som.reel,
som.imaginaire) ;
break ;
case 5 :
dif=soustraire (C1,C2);
printf("la soustraction de (%d + %d*i) et (%d + %d*i)est
(%d + %d*i)", C1.reel, C1.imaginaire, C2.reel, C2.imaginaire,
som.reel, som.imaginaire) ;
break ;

default : printf("choix erronné") ;

}
}while(choix !=6) ;0.25
}

11
ESTI 2008-2009 M. Sammoud

Les Tableaux
Exercice 1 :
Ecrire une fonction qui permet de rechercher le nombre le plus proche d'un nombre donné x
dans un tableau de 20 entiers donné tab.
Correction :
#include<stdlib>
#define MAX 20
int chercher ( int x, int tab [ MAX])
{
int i, buff,diff;

diff =abs(x-tab[0]);
for( i=1;i<MAX;i++)
{
if ( abs(x-tab[i])<= diff)
{
diff= abs(x-tab[i]);
buff=tab[i];
}
}
return buff;
}

Exercice 2
Afficher les entiers n'apparaissant qu'une fois dans un tableau d'entiers donné tab de
longueur ltab (1000 ≥ ltab ≥ 1).

#define MAX 1000


int nbre_occ( int val, int tab[], int n)/// fct qui calcule le nbre d’apparition d’un entier ds un tab
{
int i, nbre=0 ;
for (i=0 ;i<n ;i++)
if (tab[i] = = val)
nbre++ ;
return nbre ;
}

void saisir(int * tab, int n)


{
for (i=0 ;i<n ;i++)
scanf(“%d”, tab+i);
}
void main( )
{
int n, nbre,i ;
int * tab ;

12
ESTI 2008-2009 M. Sammoud

do
{
Printf(″donnez la taille du tableau″) ;
Scanf(″%d″,&n) ;
}while ((n>1000)||(n<1)) ;

tab= (int *)malloc( n* sizeof(int));


saisir (tab,n);
for (i=0 ;i<n ;i++)
if(nbre_occ(tab[i], tab,n) = = 1)
printf(“%d”,tab[i]);
}

Exercice 3
Ecrire une fonction permettant de vérifier l'équivalence de deux tableaux d'entiers (mêmes val
suivant le même ordre)

typedef enum {faux,vrai} boolean;


boolean equivalence ( int * t1, int *t2)
{
int i=0 ;
boolean equi=faux ;
while (t1[i] = = t2[i])
{
equi=vrai ;
i++ ;
}
Return equi ;
}

Exercice 4

Soit t un tableau de 6 nombres entiers, initialisé avec le mois et l’année de VOTRE date de
naissance (mmaaaa). Par exemple, si vous êtes n´e(e) en avril 1995, le tableau t contient :
0 4 1 9 9 5.
On suppose :
- que la fonction afficher(t,n) affiche sur une même ligne les n éléments du tableau t séparés
par un espace ;
- que la fonction permuter(t,i,j) permute les éléments d’indices i et j du tableau t ;
- que les variables i, j, k représentent des nombres entiers.
Rappel : si i et j sont deux entiers, la valeur de i%j est le reste de la division entière de i par j.
Décrire les affichages produits lorsque l’on exécute les instructions suivantes :
afficher(t,6) ;
for (i=0;i<6;i++) t[i] = t[i]%4 ;
afficher(t,6) ;
for (i=0 ; i<5 ; i++)
{
k=i;
for (j=i+1 ; j<6 ; j++)

13
ESTI 2008-2009 M. Sammoud

{
if (t[j] > t[k])
k=j;
}
permuter (t,i,k) ;
afficher(t,6) ;
}

Calcul de l'écart entre deux dates

A partir de deux dates la fonction Diff calcul le nombre de jours qui séparent ces deux dates,
en tenant compte des années bissextiles.

/* l'année est-elle bissextile*/


int Bissextile (int A)
{
return ((A % 4 == 0) && (A % 100 != 0 || A % 400 == 0));
}
/*combien de jours se sont écoules depuis le début de l'année donnée*/
int Nb_Jours (int J, int M, int A)
{
int i, D = 0;
const int Mois[12]= {31,28,31,30,31,30,31,31,30,31,30,31};

if (M == 1)
{
D = J;
}
else
{
for (i = 0; i < (M-1); i++)
{
D += Mois[i];
}
D+=J;
}
if ((M > 2) && (Bissextile(A)))
{
D++;
}
return D;
}
/*la fonction diff proprement dite*/
int Diff (int j1, int m1, int a1, int j2, int m2, int a2)
{
int NJ = 0, NJ1, NJ2, i;

NJ1 = Nb_Jours (j1, m1, a1);


NJ2 = Nb_Jours (j2, m2, a2);
if (a2 == a1)
{
NJ = NJ2 - NJ1;
}
else
{
for (i = 0; i < (a2-a1); i++)
{
NJ += 364;

14
ESTI 2008-2009 M. Sammoud

if (Bissextile (a1+i))
{
NJ++;
}
}
NJ -= NJ1;
NJ += NJ2+1;
}
return NJ;
}

15
ESTI 2008-2009 M. Sammoud

Comparateur de dates

Cette fonction permet de comparer deux dates sous forme de chaînes de caractères

/** Positif si DateToCompare > Reference. Precision = 16 par defaut


(resultat a la milliseconde pres). Pour utiliser la valeur par defaut,
mettre 0 ou une valeur négative. */

double CompareDates (char *Reference, char *DateToCompare, int Precision)


{
int i, Longueur, Puissance;
double d;

if ((Reference != NULL) && (DateToCompare != NULL))


{
Longueur = strlen(DateToCompare);

d = 0.0;

if (Precision <= 0)
Puissance = 16;
else
Puissance = Precision;

for ( i = 0 ; i < Longueur ; i++ )


{
if ( (int)DateToCompare[i] != (int)Reference[i] )
{
d = pow(10.0,(double)(Puissance - i)) ;
d = d * (double)((int)DateToCompare[i] - (int)Reference[i]) ;

break ;
}
}
}

return d;
}

16
ESTI 2008-2009 M. Sammoud

Modifier la casse d'une chaîne de caractère


Le fichier d'entête ctype.h propose les fonctions tolower et toupper pour
mettre un caractère respectivement en minuscule et en majuscule, il est
intéressant de proposer la même chose mais pour une chaîne de caractères

#include <stdlib.h>
#include <string.h>
#include <ctype.h>

char *str_tolower (const char *ct)


{
char *s = NULL;

if (ct)
{
int i;

s = malloc (sizeof (*s) * (strlen (ct) + 1));


if (s)
{
for (i = 0; ct[i]; i++)
{
s[i] = tolower (ct[i]);
}
s[i] = '\0';
}
}
return s;
}

char *str_toupper (const char *ct)


{
char *s = NULL;

if (ct)
{
int i;

s = malloc (sizeof (*s) * (strlen (ct) + 1));


if (s)
{
for (i = 0; ct[i]; i++)
{
s[i] = toupper (ct[i]);
}
s[i] = '\0';
}
}
return s;
}

17
ESTI 2008-2009 M. Sammoud

Comment savoir si un nombre est premier ?


Ressemblant à un hybride entre le crible d'Eratosthène et la méthode classique, cette solution
utilise les nombres premiers en dessous de 100 pour savoir si un nombre est premier ou non. Si
jamais on a fini le parcours, on utilise la méthode classique...
On suppose que nbr >= 1

#include <stdio.h>
#include <math.h>

int estPremier (int nbr)


{
/*Les nombres premiers < 100*/
static int prems[] = {2,3,5,7,11,13,17,19,23,29,31,37,41,
43,47,53,59,61,67,71,73,79,83,89,97};
int i, n;
double d;

/* On suppose que 1 est premier */


if (nbr == 1)
{
return 1;
}

n = sizeof (prems) / sizeof (*prems);

/* D'abord on regarde si n est divisible par les nombres premiers


dans le tableau */
for (i = 0; i < n; i++)
{
if (nbr == prems[i])
{
return 1;
}
if (nbr % prems[i] == 0)
{
return 0;
}
}

/* Ensuite, on doit regarder a partir du dernier element du


tableau+2 jusqu'a sqrt(nbr)... */
d = sqrt (nbr) + 0.5; /* Le 0.5 permet de tester si c'est un carre
parfait... */
i = prems[i-1] + 2;

while (i < d)
{
if (nbr % i == 0)
{
return 0;
}
i += 2;
}
return 1;
}

18
ESTI 2008-2009 M. Sammoud

int main(void)
{
int i;

for (i = 101; i < 500; i++)


{
if (estPremier (i))
{
printf ("%d\n",i);
}
}
return 0;
}

Calcul du plus grand diviseur commun de deux entiers relatifs


Cette fonction renvoie le PGCD (plus grand diviseur commun) de deux entiers relatifs, selon
l'algorithme d'Euclide.

La division euclidienne s'écrit comme suit :


dividende = diviseur * quotient + reste
avec
0 <= reste < diviseur

Exemple :
Division euclidienne de 20 par 3
20 = 3 * 6 + 2
avec
0 <= 2< 3

En utilisant des divisions euclidiennes successives, on peut trouver le PGCD de deux entiers
relatifs.
unsigned long pgcd(long a, long b, int voirAlgorithme)
{
long dividende = labs(a); /* le dividende contient la valeur
absolue de a */
long diviseur = labs(b); /* le diviseur contient la valeur
absolue de b */
long quotient;
long reste;

int fin = 0;

/*
* on ne calcule le pgcd de deux nombres que s'ils sont différents
de zéro
*/
if(a != 0 && b != 0)
{
while(!fin)
{
/* On applique la division euclidienne */
reste = dividende % diviseur;

19
ESTI 2008-2009 M. Sammoud

quotient = (dividende - reste) / diviseur;

/*
* Si l'affichage de l'algorithme est souhaité,
* on affiche chaque ligne
*/
if (voirAlgorithme)
{
printf (
"%ld = %ld * %ld + %ld\n",
dividende, diviseur, quotient, reste
);
}

/* Si le reste est différent de 0, on continue l'algorithme


*/
if(reste !=0)
{
dividende = diviseur;
diviseur = reste;
}
else
{
fin = 1;
}
}
}
else
{
/* Erreur ... */
diviseur = 0;
}

return diviseur;
}

20