PROGRAMMATION EN C EXERCICES RESOLUS

Wafae SABBAR

SOMMAIRE
1 . NOTIONS DE BASE 2 . TYPES DE BASE, OPERATEURS ET EXPRESSIONS 3 . LIRE ET ÉCRIRE DES DONNÉES 4 . LA STRUCTURE ALTERNATIVE 5 . LA STRUCTURE REPETITIVE 6 . LES TABLEAUX 7 . LES CHAÎNES DE CARACTÈRES 8 . LES POINTEURS 9 . LES FONCTIONS 10 . LES FICHIERS SEQUENTIELS

1 . NOTIONS DE BASE

Exercice 1.1 Comparez la syntaxe de la définition d'une fonction en C avec celle des fonctions et des procédures dans Pascal. Exercice 1.2 Lesquels des identificateurs suivants sont acceptés par C ? fonction-1 _ Exercice 1.3 Modifiez le programme 'hello world' de façon à obtenir le même résultat sur l'écran en utilisant plusieurs fois la fonction printf. HELLO_WORLD en C _MOYENNE_du_MOIS_ 3e_jour __A_ 3 a

limite_inf. lim_supérieure

#include <stdio.h> |main() |/* Notre premier programme en C */ |{ | printf("hello, world\n"); | return 0; |} Exercice 1.4 Expérimentez avec les séquences d'échappement que vous trouvez dans le tableau ci-dessous et complétez les colonnes vides. séq. d'échapp. descr. anglaise descr. française \n \t \b \r \" \\ \0 \a Exercice 1.5 Ci-dessous, vous trouvez un simple programme en C. Essayez de distinguer et de classifier autant que possible les éléments qui composent ce programme (commentaires, variables, déclarations, instructions, etc.) new line passage à la ligne

3

WAFAE SABBAR

/* Lecture des données */ while (COMPTEUR < 4) { /* Lire la valeur du nombre suivant */ printf("Entrez un nombre entier :"). scanf("%i". } /* Impression du résultat */ printf("La somme est: %i \n". return 0. /* Incrémenter le compteur */ COMPTEUR++. /* Initialisation des variables */ SOMME = 0. SOMME). */ main() { int NOMBRE.h> /* Ce programme calcule la somme de 4 nombres entiers introduits au clavier. /* Ajouter le nombre au résultat */ SOMME += NOMBRE. SOMME. COMPTEUR = 0. } 4 WAFAE SABBAR . &NOMBRE).#include <stdio. COMPTEUR.

150075} {-12 . 326} {-1280 .122212 0 -12 Traduisez les déclarations suivantes en C.... binaire 01770 8100 0XAAAA 1001001001 1100101011111110 10000 0234 5 WAFAE SABBAR . TYPES DE BASE. 47} {0 .. sans perdre en précision...1 Quel(s) type(s) numérique(s) pouvez-vous utiliser pour les groupes de nombres suivants? Dressez un tableau et marquez le choix le plus économique: (1) (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12) 1 12 4 0 -125 1 12 -4 0 250 1 12 4 0 250 1 12 -4 0..BASE..3 Complétez le tableau suivant: base décimale base octale base hexadécimale représ. 104} {0. faux} Exercice 2...Y MESURE SURFACE1 SURFACE2 N1 N2 N3 N4 TROUVE {0 ........0001 (13) Exercice 2. 100} {-10 .. OPERATEURS ET EXPRESSIONS Exercice 2.14159265 1015 2*107 10000001 2*10-7 10000001 -1... 300} {-120 ..5} {0 .05*1050 0. 210} {-47 .... (1) (2) (3) (4) (5) (6) (7) (8) (9) (10) entier entier entier réel réel entier entier entier entier booléen COMPTEUR X.. Choisissez les types les plus économiques....... 2....5 125 -220 32000 0 -3000005.5 .. 1285} {vrai. 1500750.2 305. sachant que vous travaillerez dans les ensembles de nombres indiqués..000000001 410 50000 2 410 50000 -2 3.

4 0123l 40000 o \r 345LU '\n' 40000u '\0' 01001 34. double RES. * la valeur arrondie (en moins) de A/B.0e-1 1e1f 'O' 0XEUL Exercice 2. * la valeur arrondie (en moins) à trois positions derrière la virgule de A/B.5 Evaluer les expressions suivantes en supposant a=20 b=5 c=-10 d=2 x=12 y=15 Notez chaque fois la valeur rendue comme résultat de l'expression et les valeurs des variables dont le contenu a changé.6 Eliminer les parenthèses superflues dans les expressions de l'exercice 3.h> main() { double A. scanf("%lf".7 Essayez le programme suivant et modifiez-le de façon à ce qu'il affiche: *A . &A). (1) (5*X)+2*((3*B)+4) (2) (5*(X+2)*3)*(B+4) (3) A == (B=5) (4) A += (X+5) (5) A != (C *= (-D)) (6) A *= C+(X-D) (7) A %= D++ (8) A %= ++D (9) (X++)*(A+C) (10) A = X*(B<C)+Y*!(B<C) (11) !(X-D+C)||D (12) A&&B||!0&&C&&!D (13) ((A&&B)||(!0&&C))&&!D (14) ((A&&B)||!0)&&(C&&(!D)) Exercice 2.5L 1. #include <stdio. * l'hypoténuse d'un triangle rectangle de côtés A et B. B 6 WAFAE SABBAR .4 Pour les constantes correctement définies. trouvez les types et les valeurs numériques décimales: 12332 0xeba 0FE0 '0' 67e0 23.Exercice 2. Exercice 2. * la tangente de A en n'utilisant que les fonctions sin et cos.0l -1. /* Saisie de A et B */ printf("Introduire la valeur pour A : ").23ul 70000u 0 0.0 -1.5. double B.

} Exercice 2. /* Calcul */ RES = A*A. short C = 10. /* code ASCII : 65 */ Quels sont le type et la valeur de chacune des expressions: (1) (2) (3) (4) (5) (6) C B C 3 2 2 + + + * * * 3 1 B C + 2 * B B + (A + 10) / C B + (A + 10. &B). /* Affichage du résultat */ printf("Le carré de B est %f \n". RES). /* Calcul */ RES = B*B.8 Soient les déclarations: long A = 15. /* Affichage du résultat */ printf("Le carré de A est %f \n".0) / C 7 WAFAE SABBAR . char B = 'A'. RES). scanf("%lf".printf("Introduire la valeur pour B : "). return 0.

N=5. 0. Q=10. N. N). ("I : %x %x\n". N. P.2. P. P. N = 5. Q = ++N == 3 && ++P == 3. Q). b) Vérifiez vos résultats à l'aide de l'ordinateur. char C='S'. Q = N++ < P || P++ != 3. N. Essayez d'introduire des nombres de différents formats et différentes grandeurs. Exercice 3. Exemple: Introduisez la date (jour mois année): 11 11 1991 données jour : mois : année : reçues : 3 11 11 1991 * Testez les réactions du programme à vos entrées. P=5. printf printf printf return ("G : %c %c\n". N). C.2 En vous référant aux exemples du chapitre 3. Q = ++N == 6 && ++P == 3. Q). Q = N++ > P || P++ != 3. * Changez la partie format du programme de façon à séparer les différentes données par le symbole '-' . printf ("C : N=%d P=%d Q=%d\n". LIRE ET ÉCRIRE DES DONNÉES Exercice 3.3 .h> main() { int N=10. Exercice 3. C. trouvez et notez les résultats du programme ci-dessus. P = 2. R. printf ("E : N=%d P=%d Q=%d\n". Q). } a) Sans utiliser l'ordinateur. Q). printf ("F : N=%d P=%d Q=%d\n". écrivez un programme qui lit la date du clavier et écrit les données ainsi que le nombre de données correctement reçues sur l'écran. P.3 Ecrire un programme qui lit un caractère au clavier et affiche le caractère ainsi que son code numérique: 8 WAFAE SABBAR . N = 5. P=2. P = 2. printf ("D : N=%d P=%d Q=%d\n". C.1 #include <stdio. ("H : %d %d\n". N = 5. N). N. P = 2. N=C.

.si les résistances sont branchées en série: Rsér = R1+R2+R3 .a) en employant getchar et printf. 9 WAFAE SABBAR . a) en se servant de 5 variables (mémorisation des valeurs entrées) b) en se servant de 2 variables (perte des valeurs entrées) Exercice 3. Exercice 3.7 Ecrire un programme qui calcule et affiche l'aire d'un triangle dont il faut entrer les longueurs des trois côtés. B. C ==> A Exercice 3.si les résistances sont branchées en parallèle: Exercice 3. C de type entier qui sont entrées au clavier : A ==> B .4 Ecrire un programme qui permute et affiche les valeurs de trois variables A. B ==> C . R3 (type double). b) en employant getch et printf.5 Ecrire un programme qui affiche le quotient et le reste de la division entière de deux nombres entiers entrés au clavier ainsi que le quotient rationnel de ces nombres.8 Ecrire un programme qui calcule la somme de quatre nombres du type int entrés au clavier. B. Exercice 3.9 a) Ecrire un programme qui calcule le prix TTC (type double) d'un article à partir du prix net (type int) et du pourcentage de TVA (type int) à ajouter. C sont les longueurs des trois côtés (type int) et P le demi-périmètre du triangle. Utilisez la formule : S = P(P-A)(P-B)(P-C) où A.6 Ecrire un programme qui affiche la résistance équivalente à trois résistances R1. Exercice 3. R2. Utilisez la formule suivante en faisant attention aux priorités et aux conversions automatiques de type: 2 b) Ecrire un programme qui calcule le prix net d'un article (type double) à partir du prix TTC (type double) et du pourcentage de TVA (type int) qui a été ajoutée.

10 Ecrire un programme qui calcule et affiche la distance DIST (type double) entre deux points A et B du plan dont les coordonnées (XA. 10 WAFAE SABBAR .(Déduisez la formule du calcul de celle indiquée ci-dessus) Exercice 3. YB) sont entrées au clavier comme entiers. YA) et (XB.

4 . else printf ("quatrième choix \n").2 Considérez la séquence d'instructions suivante: if (A>B) if (A>10) printf ("premier choix \n")..A=20 et B=20 Exercice 4. LA STRUCTURE ALTERNATIVE Exercice 4.. en utilisant: a) if . Exercice 4.A=10 et B=5 .A=10 et B=10 . if (B<10) printf ("troisième choix \n").A=20 et B=10 .A=5 et B=10 . else printf ("quatrième choix \n").else appartenant ensemble. deuxième choix. else if (B<10) printf ("deuxième choix \n"). else if (A>10) printf ("deuxième choix \n"). b) Pour quelles valeurs de A et B obtient-on les résultats: premier choix. B et C) au clavier et qui affiche la plus grande des trois valeurs. . a) Copiez la séquence d'instructions en utilisant des tabulateurs pour marquer les blocs if .3 Ecrivez un programme qui lit trois valeurs entières (A. sur l'écran? c) Pour quelles valeurs de A et B n'obtient-on pas de réponse sur l'écran? d) Notez vos réponses et choisissez vous-mêmes des valeurs pour A et B pour les vérifier l'aide de l'ordinateur. b) Déterminez les réponses du programme pour chacun des couples de nombres suivants et vérifiez à l'aide de l'ordinateur. else if (A==B) printf ("troisième choix \n").A=5 et B=5 .else et une variable d'aide MAX 11 WAFAE SABBAR . . a) Copiez la séquence d'instructions en utilisant des tabulateurs pour marquer les blocs if .1 Considérez la séquence d'instructions suivante: if (A>B) printf ("premier choix \n").else appartenant ensemble.

else if .else sans variable d'aide c) les opérateurs conditionnels et une variable d'aide MAX d) les opérateurs conditionnels sans variable d'aide Exercice 4. Triez les valeurs A. pour A et B.4 Ecrivez un programme qui lit trois valeurs entières (A. Exercice 4.b) if . B et C) au clavier. Affichez les résultats et les messages nécessaires sur l'écran.. deux ou aucune solution réelle. Utilisez des variables du type int pour A. si l'équation a une. Exercice 4. 2 12 WAFAE SABBAR .. Exercice 4.7 Ecrivez un programme qui calcule les solutions réelles d'une équation du second degré ax +bx+c = 0 en discutant la formule: 2 Utilisez une variable d'aide D pour la valeur du discriminant b -4ac et décidez à l'aide de D. pour A.5 Ecrivez un programme qui lit deux valeurs entières (A et B) au clavier et qui affiche le signe du produit de A et B sans faire la multiplication.. B et C. . Considérez aussi les cas où l'utilisateur entre des valeurs nulles pour A.6 Ecrivez un programme qui lit deux valeurs entières (A et B) au clavier et qui affiche le signe de la somme de A et B sans faire l'addition. B et C par échanges successifs de manière à obtenir : val(A) val(B) val(C) Affichez les trois valeurs. B et C. Utilisez la fonction fabs de la bibliothèque <math>.

7 Calculez la somme. leur produit et leur moyenne.. 9) lors de l'entrée des données et effectuez un signal sonore si les données sortent de ce domaine.5 . Résolvez ce problème. 1 . a) en utilisant while. c) en utilisant for. LA STRUCTURE REPETITIVE Exercice 5.8 N 13 WAFAE SABBAR .5 Calculez par multiplications successives X de deux entiers naturels X et N entrés au clavier. le produit et la moyenne d'une suite de chiffres non nuls entrés au clavier.while. Retenez seulement les chiffres (0. Exercice 5. + 1/N Exercice 5. b) Utilisez for. Le nombre N est à entrer au clavier.1 Ecrivez un programme qui lit N nombres entiers au clavier et qui affiche leur somme. Exercice 5.. Choisissez un type approprié pour les valeurs à afficher.3 Calculez par des soustractions successives le quotient entier et le reste de la division entière de deux entiers entrés au clavier.. sachant que la suite est terminée par zéro.2 Complétez la 'meilleure' des trois versions de l'exercice 5.. Exercice 5..(N-1)N d'un entier naturel N en respectant que 0!=1.1 : Répétez l'introduction du nombre N jusqu'à ce que N ait une valeur entre 1 et 15.4 Calculez la factorielle N! = 123. b) en utilisant do . a) Utilisez while. Exercice 5. d) Laquelle des trois variantes est la plus naturelle pour ce problème? Exercice 5. Quelle structure répétitive utilisez-vous? Pourquoi? Exercice 5.6 Calculez la somme des N premiers termes de la série harmonique : 1 + 1/2 + 1/3 + ..

le type long ..le type int .le type double . des coefficients An.9 Calculez le nombre lu à rebours d'un nombre positif entré au clavier en supposant que le fichier d'entrée standard contient le nombre à inverser.C.13 a) Calculez la racine carrée X d'un nombre réel positif A par approximations successives en utilisant la relation de récurrence suivante: XJ+1 = (XJ + A/XJ) / 2 X1 = A La précision du calcul J est à entrer par l'utilisateur. Exemple: Entrée: 1234 Affichage: 4321 Exercice 5.le type long double Exercice 5.12 Calculez le N-ième terme UN de la suite de FIBONACCI qui est donnée par la relation de récurrence: U1=1 U2=1 UN=UN-1 + UN-2 (pour N>2) Déterminez le rang N et la valeur UN du terme maximal que l'on peut calculer si on utilise pour UN : ..G. .Calculez le nombre lu à rebours d'un nombre positif entré au clavier en supposant que le fichier d'entrée standard contient une suite de chiffres non nuls. 14 WAFAE SABBAR .11 Calculez le P. A0 et de X seront entrées au clavier. terminée par zéro (Contrôlez s'il s'agit vraiment de chiffres). Exemple: Entrée: 1 2 3 4 0 Affichage: 4321 Exercice 5. + A1X + A0 Les valeurs de n. Utilisez le schéma de Horner qui évite les opérations d'exponentiation lors du calcul: Exercice 5. de deux entiers naturels entrés au clavier en utilisant l'algorithme d'EUCLIDE.10 Calculez pour une valeur X donnée du type float la valeur numérique d'un polynôme de degré n: P(X) = AnX + An-1X n n-1 + .D.. . Exercice 5..

c) Affichez lors du calcul toutes les approximations calculées : La 1ère approximation de la racine carrée de . est . est . .14 Affichez un triangle isocèle formé d'étoiles de N lignes (N est fourni au clavier): Nombre de lignes : 8 * *** ***** ******* ********* *********** ************* *************** Exercice 5.b) Assurez-vous lors de l'introduction des données que la valeur pour A est un réel positif et que J est un entier naturel positif.. est ..... La 3e approximation de la racine carrée de ....15 Affiche la table des produits pour N variant de 1 à 10 : X*Y I 0 1 2 3 4 5 6 7 8 9 10 -------------------------------------------------0 I 0 0 0 0 0 0 0 0 0 0 0 1 I 0 1 2 3 4 5 6 7 8 9 10 2 I 0 2 4 6 8 10 12 14 16 18 20 3 I 0 3 6 9 12 15 18 21 24 27 30 4 I 0 4 8 12 16 20 24 28 32 36 40 5 I 0 5 10 15 20 25 30 35 40 45 50 6 I 0 6 12 18 24 30 36 42 48 54 60 7 I 0 7 14 21 28 35 42 49 56 63 70 8 I 0 8 16 24 32 40 48 56 64 72 80 9 I 0 9 18 27 36 45 54 63 72 81 90 10 I 0 10 20 30 40 50 60 70 80 90 100 15 WAFAE SABBAR . Exercice 5. La 2e approximation de la racine carrée de . . plus petit que 50.... ..

Exercice 6. Afficher les tableaux TPOS et TNEG. Exercice 6.2 Ecrire un programme qui lit la dimension N d'un tableau T du type int (dimension maximale: 50 composantes). remplit le tableau par des valeurs entrées au clavier et affiche le tableau. Afficher le tableau résultant. remplit le tableau par des valeurs entrées au clavier et affiche le tableau. Exemple: 16 WAFAE SABBAR . Exercice 6. LES TABLEAUX Exercice 6.4 Ecrire un programme qui lit la dimension N d'un tableau T du type int (dimension maximale: 50 composantes).1 Ecrire un programme qui lit la dimension N d'un tableau T du type int (dimension maximale: 50 composantes).6 Ecrire un programme qui lit les dimensions L et C d'un tableau T à deux dimensions du type int (dimensions maximales: 50 lignes et 50 colonnes).6 . Remplir le tableau par des valeurs entrées au clavier et afficher le tableau ainsi que la somme de chaque ligne et de chaque colonne en n'utilisant qu'une variable d'aide pour la somme. remplit le tableau par des valeurs entrées au clavier et affiche le tableau.5 Ecrire un programme qui lit les dimensions L et C d'un tableau T à deux dimensions du type int (dimensions maximales: 50 lignes et 50 colonnes). Exercice 6. Idée: Echanger les éléments du tableau à l'aide de deux indices qui parcourent le tableau en commençant respectivement au début et à la fin du tableau et qui se rencontrent en son milieu.3 Ecrire un programme qui lit la dimension N d'un tableau T du type int (dimension maximale: 50 composantes). Exercice 6. Effacer ensuite toutes les occurrences de la valeur 0 dans le tableau T et tasser les éléments restants.7 Ecrire un programme qui transfère un tableau M à deux dimensions L et C (dimensions maximales: 10 lignes et 10 colonnes) dans un tableau V à une dimension L*C. remplit le tableau par des valeurs entrées au clavier et affiche le tableau. Calculer et afficher ensuite la somme des éléments du tableau. Exercice 6. Afficher le tableau résultant. Remplir le tableau par des valeurs entrées au clavier et afficher le tableau ainsi que la somme de tous ses éléments. Copiez ensuite toutes les composantes strictement positives dans un deuxième tableau TPOS et toutes les valeurs strictement négatives dans un troisième tableau TNEG. Ranger ensuite les éléments du tableau T dans l'ordre inverse sans utiliser de tableau d'aide.

. Afficher ensuite la valeur et la position du maximum et du minimum. le programme retiendra la position du premier maximum ou minimum rencontré..10 Maximum et minimum des valeurs d'un tableau Ecrire un programme qui détermine la plus grande et la plus petite valeur dans un tableau d'entiers A.. ./ \ | a b c d | | e f g h | | i j k l | \ / Exercice 6. Insérer une valeur VAL donnée au clavier dans le tableau A de manière à obtenir un tableau de N+1 valeurs triées. la (N+1) indéfinie. Exemple: / | 3 \ \ / -4 | * | 2 / \ \ 5 | = 3*2+2*(-3)+(-4)*5 = -20 / 2 -3 Exercice 6. Si le tableau contient plusieurs maxima ou minima.8 ==> / \ | a b c d e f g h i j k l | \ / Produit scalaire de deux vecteurs Ecrire un programme qui calcule le produit scalaire de deux vecteurs d'entiers U et V (de même dimension). Exercice 6. ième 17 WAFAE SABBAR . a) Utilisez la fonction pow() pour le calcul.11 Insérer une valeur dans un tableau trié valeur est Un tableau A de dimension N+1 contient N valeurs entières triées par ordre croissant.9 Calcul d'un polynôme de degré N Calculer pour une valeur X donnée du type float la valeur numérique d'un polynôme de degré n: P(X) = AnX + An-1X n n-1 + . A0 seront entrées au clavier et mémorisées dans un tableau A de type float et de dimension n+1. . + A1X + A0 Les valeurs des coefficients An. b) Utilisez le schéma de Horner qui évite les opérations d'exponentiation: Exercice 6..

. IB et IFUS.s'il y a égalité ou si le tableau est épuisé. Méthode: Parcourir le tableau de gauche à droite à l'aide de l'indice I. aura la valeur -1 aussi longtemps que VAL n'a pas été trouvée. Exercice 6. triés par ordre croissant. Exemple: 18 WAFAE SABBAR . continuer la recherche dans le demi-tableau à gauche de la position actuelle. 'binary search') Condition: Le tableau A doit être trié Comparer le nombre recherché à la valeur au milieu du tableau.si la valeur recherchée suit la valeur actuelle du tableau. continuer la recherche dans le demi-tableau à droite de la position actuelle. avancer dans le tableau FUS et dans le tableau qui a contribué son élément. . Fusionner les éléments de A et B dans un troisième tableau FUS trié par ordre croissant. Méthode: Utiliser trois indices IA. il suffit de recopier les éléments restants de l'autre tableau dans le tableau FUS. arrêter le traitement avec un message correspondant. Exercice 6. Question: Quel est l'avantage de la recherche dichotomique? Expliquer brièvement. sinon afficher un message correspondant. remplacer FUS[IFUS] par le plus petit des deux éléments. déterminer la position PMAX du (premier) maximum à droite de A[I] et échanger A[I] et A[PMAX]. Ecrire le programme pour le cas où le tableau A est trié par ordre croissant. Lorsque l'un des deux tableaux A ou B est épuisé. b) La recherche dichotomique ('recherche binaire'.Exercice 6. Comparer A[IA] et B[IB]. . Implémenter deux versions: a) La recherche séquentielle Comparer successivement les valeurs du tableau avec la valeur donnée. La valeur POS qui est utilisée pour mémoriser la position de la valeur dans le tableau. Pour chaque élément A[I] du tableau.12 Recherche d'une valeur dans un tableau Problème: Rechercher dans un tableau d'entiers A une valeur VAL entrée au clavier.13 Fusion de deux tableaux triés Problème: On dispose de deux tableaux A et B (de dimensions respectives N et M).si la valeur recherchée précède la valeur actuelle du tableau.14 Tri par sélection du maximum Problème: Classer les éléments d'un tableau A par ordre décroissant. Afficher la position de VAL si elle se trouve dans le tableau.

19 WAFAE SABBAR . le plus grand élément du tableau vers la fin du tableau (comme une bulle qui remonte à la surface d'un liquide). par permutations successives.15 Tri par propagation (bubble sort) Problème: Classer les éléments d'un tableau A par ordre croissant.Exercice 6. Méthode: En recommençant chaque fois au début du tableau. le tableau est trié. * Si aucune permutation n'a eu lieu. on effectue à plusieurs reprises le traitement suivant: On propage. Exemple: Implémenter l'algorithme en considérant que: * La partie du tableau (à droite) où il n'y a pas eu de permutations est triée.

Exercice 6.16 Statistique des notes Ecrire un programme qui lit les points de N élèves d'une classe dans un devoir et les mémorise dans un tableau POINTS de dimension N. * Rechercher et afficher: - la note maximale, - la note minimale, - la moyenne des notes. * A partir des POINTS des élèves, établir un tableau NOTES de dimension 7 qui est composé de la façon suivante: NOTES[6] contient le nombre de notes 60 NOTES[5] contient le nombre de notes de 50 à 59 NOTES[4] contient le nombre de notes de 40 à 49 ... NOTES[0] contient le nombre de notes de 0 à 9 Etablir un graphique de barreaux représentant le tableau NOTES. Utilisez les symboles ####### pour la représentation des barreaux et affichez le domaine des notes en dessous du graphique. Idée: Déterminer la valeur maximale MAXN dans le tableau NOTES et afficher autant de lignes sur l'écran. (Dans l'exemple ci-dessous, MAXN = 6). Exemple: La note maximale est 58 La note minimale est 13 La moyenne des notes est 37.250000

6 5 4 3 2 1

> > > > > >

####### ####### ####### ####### ####### ####### ####### ####### ####### ####### ####### ####### ####### ####### ####### ####### ####### ####### ####### ####### +-------+-------+-------+-------+-------+-------+-------+ I 0 - 9 I 10-19 I 20-29 I 30-39 I 40-49 I 50-59 I 60 I

Exercice 6.17 Mise à zéro de la diagonale principale d'une matrice Ecrire un programme qui met à zéro les éléments de la diagonale principale d'une matrice carrée A donnée. Exercice 6.18

20

WAFAE SABBAR

Matrice unitaire Ecrire un programme qui construit et affiche une matrice carrée unitaire U de dimension N. Une matrice unitaire est une matrice, telle que: / 1 si i=j =| \ 0 si ij

uij

Exercice 6.19 Transposition d'une matrice Ecrire un programme qui effectue la transposition tA d'une matrice A de dimensions N et M en une matrice de dimensions M et N. a) La matrice transposée sera mémorisée dans une deuxième matrice B qui sera ensuite affichée. b) La matrice A sera transposée par permutation des éléments. Rappel: / \ t | a b c d | | e f g h | | i j k l | \ / / | | | | \ \ | | | | /

tA =

=

a b c d

e f g h

i j k l

Exercice 6.20 Multiplication d'une matrice par un réel Ecrire un programme qui réalise la multiplication d'une matrice A par un réel X. Rappel: / \ / \ | a b c d | | X*a X*b X*c X*d | X * | e f g h | = | X*e X*f X*g X*h | | i j k l | | X*i X*j X*k X*l | \ / \ / a) Le résultat de la multiplication sera mémorisé dans une deuxième matrice A qui sera ensuite affichée. b) Les éléments de la matrice A seront multipliés par X. Exercice 6.21 Addition de deux matrices Ecrire un programme qui réalise l'addition de deux matrices A et B de mêmes dimensions N et M. Rappel: / \ / \ | a b c d | | a' b' c' d' | | e f g h | + | e' f' g' h' | | i j k l | | i' j' k' l' | \ / \ / / \ | a+a' b+b' c+c' d+d' | | e+e' f+f' g+g' h+h' | | i+i' j+j' k+k' l+l' | \ /

=

21

WAFAE SABBAR

a) Le résultat de l'addition sera mémorisé dans une troisième matrice C qui sera ensuite affichée. b) La matrice B est ajoutée à A. Exercice 6.22 Multiplication de deux matrices En multipliant une matrice A de dimensions N et M avec une matrice B de dimensions M et P on obtient une matrice C de dimensions N et P: A(N,M) * B(M,P) = C(N,P) La multiplication de deux matrices se fait en multipliant les composantes des deux matrices lignes par colonnes:

Rappel: / | | | | \ \ | | | | / / \ | p q | | r s | | t u | \ / / | | | | \ \ | | | | /

a e h k

b f i l

c g j m

*

=

a*p e*p h*p k*p

+ + + +

b*r f*r i*r l*r

+ + + +

c*t g*t j*t m*t

a*q e*q h*q k*q

+ + + +

b*s f*s i*s l*s

+ + + +

c*u g*u j*u m*u

Ecrire un programme qui effectue la multiplication de deux matrices A et B. Le résultat de la multiplication sera mémorisé dans une troisième matrice C qui sera ensuite affichée. Exercice 6.23 Triangle de Pascal Ecrire un programme qui construit le triangle de PASCAL de degré N et le mémorise dans une matrice carrée P de dimension N+1. Exemple: Triangle de Pascal de degré 6: n=0 n=1 n=2 n=3 n=4 n=5 n=6 1 1 1 1 1 1 1

1 2 3 4 5 6

1 3 6 10 15

1 4 1 10 5 1 20 15 6 1

Méthode: Calculer et afficher seulement les valeurs jusqu'à la diagonale principale (incluse). Limiter le degré à entrer par l'utilisateur à 13. Construire le triangle ligne par ligne: - Initialiser le premier élément et l'élément de la diagonale à 1.

22

WAFAE SABBAR

Afficher les positions et les valeurs de tous les points-cols trouvés. Exemples: Les éléments soulignés sont des points-cols: / \ / \ / \ / \ | 1 8 3 4 0 | | 4 5 8 9 | | 3 5 6 7 7 | | 1 2 3 | | | | 3 8 9 3 | | 4 2 2 8 9 | | 4 5 6 | | 6 7 2 7 0 | | 3 4 9 3 | | 6 3 2 9 7 | | 7 8 9 | \ / \ / \ / \ / Méthode: Etablir deux matrices d'aide MAX et MIN de même dimensions que A.j] = | sur la ligne i \ 0 sinon / 1 si A[i.j] = | sur la colonne j \ 0 sinon 23 WAFAE SABBAR ..j + Pi-1. telles que: / 1 si A[i.j-1 Exercice 6. Ces éléments sont appelés des points-cols.j] est un minimum MIN[i.j = Pi-1.24 Recherche de 'points-cols' Rechercher dans une matrice donnée A les éléments qui sont à la fois un maximum sur leur ligne et un minimum sur leur colonne.j] est un maximum MAX[i.Calculer les valeurs entre les éléments initialisés de gauche à droite en utilisant la relation: Pi.

b) le nombre de 'e' contenus dans le texte..1. f) char f[] = "Cette " "phrase" "est coupée". . Lesquelles des chaînes suivantes sont initialisées correctement ? Corrigez les déclarations fausses et indiquez pour chaque chaîne de caractères le nombre d'octets qui sera réservé en mémoire. 'c'}. mais dans l'ordre inverse. c) toute variable TXT. sans changer le contenu de la d) toute la caractères dans TXT: phrase à rebours.5 24 WAFAE SABBAR . d) char d[10] = 'x'. Exercice 7.3 Ecrire un programme qui lit une ligne de texte (ne dépassant pas 200 caractères) la mémorise dans une variable TXT et affiche ensuite: a) la longueur L de la chaîne. e) char e[5] = "cinq". g) char g[2] = {'a'.7 . c) char c[] = 'abcdefg'. après avoir inversé l'ordre des voici une petite phrase ! ! esarhp etitep enu iciov Exercice 7. Les modifications se feront dans la même variable TXT. séparés par des espaces et qui les affiche ensuite dans une ligne. h) char h[4] = {'a'. la phrase à rebours. a) char a[] = "un\ndeux\ntrois\n". b) char b[12] = "un deux trois". Les mots sont mémorisés dans 5 variables M1.M5. Exemple: Cette ligne contient quelques lettres e. 'b'.2 Ecrire un programme qui lit 5 mots. Exemple voici une petite phrase ! ! phrase petite une voici Exercice 7..4 Ecrire un programme qui lit un texte TXT (de moins de 200 caractères) et qui enlève toutes les apparitions du charactère 'e' en tassant les éléments restants. Exercice 7. i) char i[4] = "'o'". Ctt lign contint qulqus lttrs . '\0'}. . LES CHAÎNES DE CARACTÈRES Exercice 7.

atoi(STR)). %f \n". atol(STR)). %d \n". 25 WAFAE SABBAR . Employer la fonction strlen. Contrôlez s'il s'agit bien d'un verbe en "er" avant de conjuguer. %ld \n". strcat et strlen. a) Utiliser les fonctions spéciales de <string>. Exercice 7. Afficher le résultat.9 Soient les instructions: char STR[200].8 Ecrire un programme qui lit un verbe régulier en "er" au clavier et qui en affiche la conjugaison au présent de l'indicatif de ce verbe. Exemple: Introduisez votre nom et votre prénom: Mickey Mouse Bonjour Mickey Mouse ! Votre nom est composé de 11 lettres. les compare lexicographiquement et affiche le résultat: Exemple: Introduisez la première chaîne: ABC Introduisez la deuxième chaîne: abc "ABC" précède "abc" Exercice 7. b) Utiliser uniquement les fonctions gets et puts. Utiliser les fonctions gets. = = = = %s \n". puts("Entrez un gets(STR). Exemple: Verbe : fêter je fête tu fêtes il fête nous fêtons vous fêtez ils fêtent Exercice 7. puts.Ecrire un programme qui demande l'introduction du nom et du prénom de l'utilisateur et qui affiche alors la longueur totale du nom sans compter les espaces. atof(STR)).7 Ecrire un programme qui lit deux chaînes de caractères CH1 et CH2 et qui copie la première moitié de CH1 et la première moitié de CH2 dans une troisième chaîne CH3. Exercice 7. STR). printf("Entrée printf("integer printf("long printf("double nombre :").6 Ecrire un programme qui lit deux chaînes de caractères CH1 et CH2.

3. 33 byte est la base pour la conversion (2 . Conversion de nombres en chaînes de caractères itoa (<n_int>. Syntaxe: sprintf( <chaîne cible>.12 26 WAFAE SABBAR . La conversion se fait dans la base <b>. ) Exercice 7.14). Utilisez la méthode de tri par sélection directe (voir Exercice 6. . . .45 e) 12E3 f) 1234f5 g) -1234567 h) 123e-02 i) -0.. 36) Remarque avancée En ANSI-C il existe la possibilité d'employer la fonction sprintf pour copier des données formatées dans une variable de la même façon que printf les imprime à l'écran. <b>) Chacune de ces trois procédures convertit son premier argument en une chaîne de caractères qui sera ensuite attribuée à <s>. <b>) ultoa (<n_uns_long>. ltoa et ultoa qui convertissent des entiers en chaînes de caractères.Quelles sont les valeurs affichées si on entre les chaînes de caractères suivantes: a) 123 b) -123 c) . Exercice 7..1234 Nombre --> Chaîne Le standard ANSI-C ne contient pas de fonctions pour convertir des nombres en chaînes de caractères. Trier les 10 mots lexicographiquement en utilisant les fonctions strcmp et strcpy. <s>.10 Ecrivez un petit programme utilisant la fonction ltoa qui sert à contrôler les résultats de l'exercice 3.11 Ecrire un programme qui lit 10 mots et les mémorise dans un tableau de chaînes de caractères.123 d) 123. <s>. <expr1>. <n_int> <n_long> <n_uns_long> <s> <b> est un nombre du type int est un nombre du type long est un nombre du type unsigned long est une chaîne de caractères longueur maximale de la chaîne: 17 resp. Si on se limite aux systèmes fonctionnant sous DOS. <expr2>. Afficher le tableau trié. <s>. <chaîne de formatage>. <b>) ltoa (<n_long>. Exercice 7. on peut quand même utiliser les fonctions itoa.

Ecrire un programme qui lit un nombre entre 1 et 7 et qui affiche le nom du jour de la semaine correspondant: pour 1 pour 2 ... ... "dimanche" pour 7 "lundi" "mardi" Utiliser le premier élément du tableau pour mémoriser un petit message d'erreur. Exercice 7.13 Ecrire un programme qui lit 5 mots, séparés par des espaces et qui les affiche ensuite dans une ligne, mais dans l'ordre inverse. Les mots sont mémorisés dans un tableau de chaînes de caractères. Exemple voici une petite phrase ! ! phrase petite une voici Exercice 7.14 Refaire l'exercice 7.8 (Conjugaison des verbes réguliers en "er") en utilisant deux tableaux de chaînes de caractères: SUJ pour les sujets TERM pour les terminaisons Employez les fonctions printf, scanf, strlen. Exercice 7.15 Ecrire un programme qui lit deux chaînes de caractères, et qui indique leur précédence lexicographique dans le code de caractères de la machine (ici: code ASCII). Testez votre programme à l'aide des exemples du chapitre 7.5. Exercice 7.16 Ecrire un programme qui lit une chaîne de caractères CH et qui convertit toutes les majuscules dans des minuscules et vice-versa. Le résultat sera mémorisé dans la même variable CH et affiché après la conversion. Exercice 7.17 Ecrire une procédure qui lit une chaîne de caractères et l'interprète comme un entier positif dans la base décimale. Pour la conversion, utiliser les fonctions de <ctype> et la précédence alphabétique des caractères de '0' à '9'. Mémoriser le résultat dans une variable du type long. La conversion s'arrête à la rencontre du premier caractère qui ne représente pas de chiffre décimal. Utiliser un indicateur logique OK qui précise si la chaîne représente correctement une valeur entière et positive. Exercice 7.18 Ecrire une procédure qui lit une chaîne de caractères et l'interprète comme un entier positif dans la base hexadécimale. Pour la conversion, utiliser les fonctions de <ctype> et la précédence alphabétique des caractères. La conversion ignore les caractères qui ne représentent pas de chiffre hexadécimal et s'arrête à la fin de la chaîne de caractères. Le résultat sera mémorisé dans une variable du type long et affiché dans les bases hexadécimale et décimale.

27

WAFAE SABBAR

Exercice 7.19 En se basant sur l'exercice 7.17, écrire un programme qui lit une chaîne de caractères et l'interprète comme un nombre rationnel positif ou négatif introduit en notation décimale. Mémoriser le résultat dans une variable du type double. Si le nombre a été introduit correctement, la valeur du résultat sera affichée, sinon le programme affichera un message d'erreur. Méthode: Utiliser une variable SIG pour mémoriser le signe de la valeur. Convertir tous les caractères numériques (avant et derrière le point décimal) en une valeur entière N. Compter les décimales (c.-à-d.: les positions derrière le point décimal) à l'aide d'une variable DEC et calculer la valeur rationnelle comme suit: N = N * SIG / pow(10, DEC) -1234.23400 Exemples: -1234.234 -123 45 Erreur! 123.23. Erreur! +00123.0123 123.012300 Exercice 7.20 En se basant sur l'exercice 7.19, écrire un programme qui lit une chaîne de caractères et l'interprète comme un nombre rationnel positif ou négatif introduit en notation exponentielle. Mémoriser le résultat dans une variable du type double. Si le nombre a été introduit correctement, la valeur du résultat sera affichée, sinon le programme affichera un message d'erreur. Méthode: Utiliser une variable SIGE pour mémoriser le signe de l'exposant. Utiliser une variable EXP pour la valeur de l'exposant. Calculer la valeur de l'exposant à l'aide de SIGE, DEC et EXP. Calculer ensuite la valeur exacte de N à l'aide d'une formule analogue à celle de l'exercice ci-dessus. Exemples: -1234.234 -1234. 234 123E+02 123E-02 123.4e -12.1234e02 123.4e3.4 12.12E1 12.12 E1 Exercice 7.21 Ecrire un programme qui supprime la première occurrence d'une chaîne de caractères OBJ dans une chaîne de caractères SUJ. Exemples: PHON ALPHONSE EI PIERRE T TOTALEMENT HELLO Exercice 7.22 Ecrire un programme qui remplace la première occurrence d'une chaîne de caractères CH1 par la chaîne CH2 dans une chaîne de caractères SUJ. Utiliser une chaîne de sauvegarde FIN pendant le remplacement. ALSE PIERRE OTALEMENT HELLO -1234.234000 Erreur! 123400.000000 1.230000 123.400000 -1212.340000 Erreur! 121.200000 Erreur!

28

WAFAE SABBAR

Exemples: PHON IE IE EI TOT

OY EI ARTE IE FIN TTT

ALPHONSE PIERRE PIERRE PIERRE TOTALEMENT HELLO

ALOYSE PEIRRE PARTERRE PIERRE FINALEMENT HELLO

Exercice 7.23 Ecrire un programme qui remplace toutes les occurrences d'une chaîne de caractères CH1 par la chaîne CH2 dans une chaîne de caractères SUJ. Utiliser une chaîne de sauvegarde FIN pendant le remplacement. Exemples: PHON OY ALPHONSE AN ONT BANANE T Y TOTALEMENT TTT HELLO L HELLO ALOYSE BONTONTE YOYALEMENY HELLO HEO

29

WAFAE SABBAR

P1=&A.1 main() { int A = 1. A=++*P2**P1.3 Pourquoi les créateurs du standard ANSI-C ont-ils décidé de légaliser les pointeurs sur le premier élément derrière un tableau? Donner un exemple. Exercice 8. Exercice 8.4 1 2 3 / / 1 2 3 &A / 30 WAFAE SABBAR . P1=&A. int C = 3.2 Ecrire un programme qui lit deux tableaux A et B et leurs dimensions N et M au clavier et qui ajoute les éléments de B à la fin de A. int *P1. *P1-=*P2. P1=P2. *P1=(*P2)++. P2=&B. int B = 2. P2=&C. A B C P1 P2 Init. *P2. return 0.8 . LES POINTEURS Exercice 8. *P2=*P1/=*P2. Utiliser le formalisme pointeur à chaque fois que cela est possible. *P1*=*P2. } Copiez le tableau suivant et complétez-le pour chaque instruction du programme ci-dessus. ++*P2. P1=&A P2=&C *P1=(*P2)++ P1=P2 P2=&B *P1-=*P2 ++*P2 *P1*=*P2 A=++*P2**P1 P1=&A *P2=*P1/=*P2 Exercice 8.

6 Ecrire un programme qui range les éléments d'un tableau A du type int dans l'ordre inverse.Soit P un pointeur qui 'pointe' sur un tableau A: int A[] = {12. 78. Quelles valeurs ou adresses fournissent ces expressions: a) b) c) d) e) f) g) h) Exercice 8. Le programme n'utilisera pas de variables numériques. 67. une variable logique. Exercice 8. Exercice 8.8 Ecrire de deux façons différentes. int *P. 34. 45. 23. Le programme utilisera les pointeurs P1 et P2 pour parcourir le tableau.5 Ecrire un programme qui lit un entier X et un tableau A du type int au clavier et élimine toutes les occurrences de X dans A en tassant les éléments restants. 90}. la fonction isspace et une variable numérique N qui contiendra le nombre des mots. si une chaîne CH introduite au clavier est un palindrome: a) en utilisant uniquement le formalisme tableau b) en utilisant des pointeurs au lieu des indices numériques Rappel: Un palindrome est un mot qui reste le même qu'on le lise de gauche à droite ou de droite à gauche: Exemples: PIERRE ==> n'est pas un palindrome OTTO ==> est un palindrome 23432 ==> est un palindrome Exercice 8.9 Ecrire un programme qui lit une chaîne de caractères CH et détermine la longueur de la chaîne à l'aide d'un pointeur P. 89.7 Ecrire un programme qui lit deux tableaux d'entiers A et B et leurs dimensions N et M au clavier et qui ajoute les éléments de B à la fin de A. Utiliser deux pointeurs PA et PB pour le transfer et afficher le tableau résultant A. Utiliser un pointeur P. Exercice 8. *P+2 *(P+2) &P+1 &A[4]-3 A+3 &A[7]-P P+(*P-10) *(P+*(P+8)-A[7]) 31 WAFAE SABBAR . Exercice 8.10 Ecrire un programme qui lit une chaîne de caractères CH et détermine le nombre de mots contenus dans la chaîne. Le programme utilisera des pointeurs P1 et P2 et une variable numérique AIDE pour la permutation des éléments. P = A. un programme qui vérifie sans utiliser une fonction de <string>. 56.

Ensuite toutes les occurrences de C dans CH seront éliminées.13 Ecrire un programme qui lit deux chaînes de caractères CH1 et CH2 au clavier et élimine toutes les lettres de CH1 qui apparaissent aussi dans CH2. Le reste des caractères dans CH sera tassé à l'aide d'un pointeur et de la fonction strcpy.15 Ecrire un programme qui lit une matrice A de dimensions N et M au clavier et affiche les données suivantes en utilisant le formalisme pointeur à chaque fois que cela est possible: a) la matrice A b) la transposée de A c) la matrice A interprétée comme tableau unidimensionnel Exercice 8. une variable logique TROUVE et la fonction strcpy. Exemples: Bonjour Bravo ==> njou Bonjour bravo ==> Bnjou abacab aa ==> bcab Exercice 8.Exercice 8. Utiliser un tableau ABC de dimension 26 pour mémoriser le résultat et un pointeur PCH pour parcourir la chaîne CH et un pointeur PABC pour parcourir ABC. Exercice 8. Utiliser deux pointeurs P1 et P2.16 32 WAFAE SABBAR .12 Ecrire un programme qui lit un caractère C et une chaîne de caractères CH au clavier. Utiliser uniquement des pointeurs. une variable logique TROUVE et la fonction strcpy. Exemples: Alphonse phon ==> Alse totalement t ==> otalement abacab aa ==> abacab texte (max. 100 caractères) : contient : 'A' 'E' 'J' 'N' Exercice 8.11 Ecrire un programme qui lit une chaîne de caractères CH au clavier et qui compte les occurrences des lettres de l'alphabet en ne distinguant pas les majuscules et les minuscules. Exemple: Entrez un ligne de Jeanne La chaîne "Jeanne" 1 fois la lettre 2 fois la lettre 1 fois la lettre 3 fois la lettre Exercice 8. Afficher seulement le nombre des lettres qui apparaissent au mois une fois dans le texte.14 Ecrire un programme qui lit deux chaînes de caractères CH1 et CH2 au clavier et supprime la première occurrence de CH2 dans CH1.

Afficher les mots. "Paul". den 2. "Jean-Marie". En supposant que vous utilisez le même algorithme de tri pour les deux programmes. le mois et l'année d'une date au clavier et qui affiche la date en français et en allemand.22 33 WAFAE SABBAR .17 Ecrire un programme qui lit 5 mots d'une longueur maximale de 50 caractères et les mémorise dans un tableau de chaînes de caractères TABCH.20 Ecrire un programme qui lit 10 phrases d'une longueur maximale de 200 caractères au clavier et qui les mémorise dans un tableau de pointeurs sur char en réservant dynamiquement l'emplacement en mémoire pour les chaînes. qui sera ensuite affichée. le 1er avril 1993 Luxemburg. April 1993 Exercice 8. "Claude" }.Ecrire un programme qui lit deux matrices A et B de dimensions N et M respectivement M et P au clavier et qui effectue la multiplication des deux matrices. char NOM2[][16] = {"Marc". Exercice 8.21 Ecrire un programme qui lit 10 mots au clavier (longueur maximale: 50 caractères) et attribue leurs adresses à un tableau de pointeurs MOT. Le résultat de la multiplication sera affecté à la matrice C. "François-Xavier". "Paul". April 1993 Introduisez la date: 2 4 1993 Luxembourg. "Jean-Marie". La première composante de chaque tableau contiendra un message d'erreur qui sera affiché lors de l'introduction d'une donnée illégale. lequel des deux programmes sera probablement le plus rapide? Exercice 8. Inverser l'ordre des caractères à l'intérieur des 5 mots à l'aide de deux pointeurs P1 et P2. "François-Xavier". "Claude" }. Afficher à chaque fois les mots restants en attendant la confirmation de l'utilisateur (par 'Enter'). l'ordre des phrases est inversé en modifiant les pointeurs et le tableau résultant est affiché. Ensuite. den 1. Exercice 8. b) Imaginez que vous devez écrire un programme pour chacun des deux tableaux qui trie les chaînes selon l'ordre lexicographique.18 Considérez les déclarations de NOM1 et NOM2: char *NOM1[] = {"Marc". Exemples: Introduisez la date: 1 4 1993 Luxembourg. Utiliser le formalisme pointeur à chaque fois que cela est possible. le 2 avril 1993 Luxemburg. Exercice 8. en suivant l'ordre lexicographique et en libérant leur espace en mémoire. MFRAN et MDEUT que vous initialisez avec les noms des mois dans les deux langues. a) Représenter graphiquement la mémorisation des deux variables NOM1 et NOM2. Utiliser deux tableaux de pointeurs. Effacer les 10 mots un à un. Exercice 8.19 Ecrire un programme qui lit le jour.

Ecrire un programme qui lit 10 mots au clavier (longueur maximale: 50 caractères) et attribue leurs adresses à un tableau de pointeurs MOT. Utiliser les fonctions de <string>.décrite dans l'exercice 7. Réserver l'espace nécessaire à la PHRASE avant de copier les mots.23 Ecrire un programme qui lit 10 phrases au clavier (longueur maximale: 50 caractères) et attribue leurs adresses à un tableau de pointeurs MOT. Trier les phrases lexicographiquement en n'échangeant que les pointeurs. Exercice 8. Copier les mots selon l'ordre lexicographique en une seule 'phrase' dont l'adresse est affectée à un pointeur PHRASE. Libérer la mémoire occupée par chaque mot après l'avoir copié. 34 WAFAE SABBAR . Utiliser la méthode de tri par propagation (méthode de la bulle .15). Réserver dynamiquement l'emplacement en mémoire pour les mots.

scanf("%lf". } double SURFACE(double RAYON) { return PI()*RAYON*RAYON. PI et SURFACE définies par: #include <stdio. b) Définir les fonctions d'après les trois méthodes décrites ci-dessus en ajoutant les déclarations manquantes. Implémenter le programme ensuite en C.2 Exécuter le programme suivant et construire les grilles correspondantes. &R).3 35 WAFAE SABBAR . programme PARAMETRES | entier A. SURFACE(R)).h> main() { double R. } a) Etablir la hiérarchie des appels pour les trois fonctions.9 .1 Soient les fonctions main.B | en A ranger 0 | en B ranger 0 | P(A.14159265.Y fprocédure (* fin P *) Exercice 9. c) Quels messages fournit le compilateur lorsqu'une fonction n'est pas définie ou déclarée avant son appel? Comment peut-on expliquer ces messages? Exercice 9. LES FONCTIONS Exercice 9. printf("Introduire le rayon du cercle : ").Y) | donnée: entier X | résultat: entier Y | en X ranger X+1 | en Y ranger Y+1 | écrire X.B) | écrire A. return 0. } double PI(void) { return 3. printf("La surface du cercle est %f. \n".B fprogramme (* fin PARAMETRES *) procédure P(X.

C | MANIPULER(A.C | MODIFIER(A.B.Z) | donnée: entier X | résultat: entier Y. Implémenter le programme ensuite en C. programme TRUC | entier A | en A ranger 2 | écrire A | MACHIN(A) | écrire A fprogramme (* fin TRUC *) procédure MACHIN(X) | donnée: entier X | écrire X | en X ranger 1000 | écrire X fprocédure (* fin MACHIN *) Exercice 9.Y.C fprogramme (* fin CALCUL *) procédure MODIFIER(X.Z) | donnée: entier X. programme CALCUL | entier A.C fprogramme (* fin MANIPULATION *) procédure MANIPULER(X.B.B.5 Exécuter le programme suivant et construire les grilles correspondantes.Z | entier T | en T ranger X | en X ranger Y | en Y ranger Z | en Z ranger T fprocédure (* fin MODIFIER *) Exercice 9.Y.Y | résultat: entier Z | écrire X. Implémenter le programme ensuite en C.Exécuter le programme suivant et construire les grilles correspondantes.B.B.Z | en X ranger X divent 2 | en Y ranger Y*2 36 WAFAE SABBAR .B.B.Y. Implémenter le programme ensuite en C.C | en A ranger 208 | en B ranger 5 | en C ranger -34 | écrire A.C) | écrire A.B.4 Exécuter le programme suivant et construire les grilles correspondantes. programme MANIPULATION | entier A.C | en A ranger 3 | en B ranger -8 | en C ranger 12 | écrire A.C) | écrire A.

Exercice 9.9 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) où x est un entier compris entre 1 et 10. Exercice 9.11 En mathématiques.Z fprocédure (* fin MANIPULER *) Exercice 9. b) EXP2 affecte la valeur X à X.| en Z ranger X+Y | écrire X.. Exercice 9.Y. Exercice 9. Exercice 9. 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.6 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. on définit la fonction factorielle de la manière suivante: 0! = 1 n! = n*(n-1)*(n-2)* . Ecrire un programme qui teste les deux fonctions à l'aide de valeurs lues au clavier.. N N N Ecrire un petit programme qui teste la fonction NCHIFFRES: Exemple: Introduire un nombre entier : 6457392 Le nombre 6457392 a 7 chiffres.7 Ecrire deux fonctions qui calculent la valeur X pour une valeur réelle X (type double) et une valeur entière positive N (type int) : a) EXP1 retourne la valeur X comme résultat. * 1 (pour n>0) 37 WAFAE SABBAR .8 Ecrire une fonction MIN et une fonction MAX qui déterminent le minimum et le maximum de deux nombres réels.10 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.

Exemple: Le tableau T lu dans l'exemple ci-dessus sera affiché par l'appel : ECRIRE_TAB(T. Implémenter la fonction LIRE_TAB en choisissant bien le type des paramètres. tout en définissant et utilisant les fonctions adéquates.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. il faudra calculer les coefficients d'après la formule ci-dessous.10): 4 43 55 67 79 38 WAFAE SABBAR . N). N et NMAX lit la dimension N et les composantes d'un tableau TAB du type int.14 Ecrire la fonction ECRIRE_TAB à deux paramètres TAB et N qui affiche N composantes du tableau TAB du type int. et sera présenté comme suit: 43 55 67 79 Exercice 9. Ecrire un petit programme qui teste la fonction FACT. 10). Exercice 9.12 Ecrire un programme qui construit et affiche le triangle de Pascal en calculant les coefficients binomiaux: 1 1 1 1 1 1 2 3 4 1 3 1 6 4 .10): 11 tableau (max. . .15 tableau (max.13 La fonction LIRE_TAB à trois paramètres TAB. &N. La dimension N doit être inférieure à NMAX. c. Exemple: Pour un appel par LIRE_TAB(T. 1 On n'utilisera pas de tableau. la fonction se comportera comme suit: Dimension du Dimension du Elément[0] : Elément[1] : Elément[2] : Elément[3] : Exercice 9. Exercice 9.-à-d.

Ecrire la fonction SOMME_TAB qui calcule la somme des N éléments d'un tableau TAB du type int. N et TAB sont fournis comme paramètres; la somme est retournée comme résultat du type long. Exercice 9.16 A l'aide des fonctions des exercices précédents, écrire un programme qui lit un tableau A d'une dimension inférieure ou égale à 100 et affiche le tableau et la somme des éléments du tableau. Exercice 9.17 Tri de Shell Traduire la fonction TRI_SHELL définie ci-dessous en C. Utiliser la fonction PERMUTER définie dans le cours. Ecrire un programme profitant des fonctions définies dans les exercices précédents pour tester la fonction TRI_SHELL. procédure TRI_SHELL(T,N) | (* Trie un tableau T d'ordre N par la méthode | de Shell en ordre croissant. *) | résultat: entier tableau T[100] | donnée: entier N | entier SAUT, M, K | booléen TERMINE | en SAUT ranger N | tant que (SAUT>1) faire | | en SAUT ranger SAUT divent 2 | | répéter | | | en TERMINE ranger vrai | | | pour M variant de 1 à N-SAUT faire | | | | en K ranger M+SAUT | | | | si (T[M]>T[K]) alors | | | | | PERMUTER(T[M],T[K]) | | | | | en TERMINE ranger faux | | | | fsi | | | fpour | | jusqu'à TERMINE | ftant (* SAUT <= 1 *) fprocédure (* fin TRI_SHELL *) Remarque: L'algorithme a été développé par D.L.Shell en 1959. En comparant d'abord des éléments très éloignés, l'algorithme a tendance à éliminer rapidement les grandes perturbations dans l'ordre des éléments. La distance entre les éléments qui sont comparés est peu à peu réduite jusqu'à 1. A la fin du tri, les éléments voisins sont arrangés. Exercice 9.18 Déterminer le maximum de N éléments d'un tableau TAB d'entiers de trois façons différentes: a) la fonction MAX1 retourne la valeur maximale b) la fonction MAX2 retourne l'indice de l'élément maximal c) la fonction MAX3 retourne l'adresse de l'élément maximal Ecrire un programme pour tester les trois fonctions. Exercice 9.19 Tri par sélection Ecrire la fonction TRI_SELECTION qui trie un tableau de N entiers par la méthode de sélection directe du maximum (voir exercice 7.14). La fonction fera appel à la fonction PERMUTER (définie dans le cours) et à la fonction MAX3 (définie dans l'exercice précédent).

39

WAFAE SABBAR

Ecrire un programme pour tester la fonction TRI_SELECTION. Exercice 9.20 Ecrire la fonction INSERER qui place un élément X à l'intérieur d'un tableau qui contient N éléments triés par ordre croissant, de façon à obtenir un tableau à N+1 éléments triés par ordre croissant. La dimension du tableau est incrémentée dans la fonction INSERER. Ecrire un programme profitant des fonctions définies plus haut pour tester la fonction INSERER. Exercice 9.21 Tri par insertion Ecrire la fonction TRI_INSERTION qui utilise la fonction INSERER pour trier par ordre croissant les éléments d'un tableau à N éléments. Ecrire un programme pour tester la fonction TRI_INSERTION. Méthode: Trier le tableau de gauche à droite en insérant à chaque fois l'élément I+1 dans le tableau (déjà trié) des I premiers éléments.

Exercice 9.22 Ecrire la fonction RANGER qui arrange le contenu de ses deux paramètres X et Y de façon à ce que le contenu de X soit plus petit que celui de Y. RANGER retourne la valeur logique 1 si un échange a eu lieu, sinon 0. Exercice 9.23 Tri par propagation Ecrire la fonction TRI_BULLE qui trie un tableau de N éléments entiers par ordre croissant en appliquant la méthode de la bulle (tri par propagation - voir exercice 7.15). Employer la fonction RANGER de l'exercice cidessus. Ecrire un programme pour tester la fonction TRI_BULLE. Exercice 9.24 Fusion de tableaux triés Ecrire la fonction FUSION qui construit un tableau FUS trié par ordre croissant avec les éléments de deux tableaux A et B triés par ordre croissant. Pour deux tableaux de dimensions N et M, le tableau FUS aura la dimension N+M. (Méthode: voir exercice 7.13)

40

WAFAE SABBAR

Ecrire un programme qui teste la fonction FUSION à l'aide de deux tableaux lus au clavier et triés à l'aide de TRI_BULLE. Exercice 9.25 Ecrire la fonction LONG_CH qui retourne la longueur d'une chaîne de caractères CH comme résultat. Implémentez LONG_CH sans utiliser de variable d'aide numérique. Exercice 9.26 Ecrire la fonction MAJ_CH qui convertit toutes les lettres d'une chaîne en majuscules, sans utiliser de variable d'aide. Exercice 9.27 Ecrire la fonction AJOUTE_CH à deux paramètres CH1 et CH2 qui copie la chaîne de caractères CH2 à la fin de la chaîne CH1 sans utiliser de variable d'aide. Exercice 9.28 Ecrire la fonction INVERSER_CH qui inverse l'ordre des caractères d'une chaîne CH. Utiliser la fonction LONG_CH (définie plus haut) et définir une fonction d'aide PERMUTER_CH qui échange les valeurs de deux variables du type char. Exercice 9.29 Ecrire la fonction NMOTS_CH qui retourne comme résultat le nombre de mots contenus dans une chaîne de caractères CH. Utiliser une variable logique, la fonction isspace et une variable d'aide N. Exercice 9.30 Ecrire la fonction MOT_CH qui retourne un pointeur sur le N-ième mot d'une chaîne CH s'il existe, sinon un pointeur sur le symbole de fin de chaîne. Exercice 9.31 Ecrire la fonction EGAL_N_CH qui retourne la valeur 1 si les N premiers caractères de CH1 et CH2 sont égaux, sinon la valeur 0. (Si N est plus grand que la longueur de CH1 ou de CH2, le résultat peut être 1 ou 0). Exercice 9.32 Utiliser la fonction EGAL_N_CH et LONG_CH pour écrire la fonction CHERCHE_CH qui retourne un pointeur sur la première apparition de CH1 dans CH2, sinon un pointeur sur le symbole de fin de chaîne. Exercice 9.33 Ecrire la fonction CH_ENTIER qui retourne la valeur numérique d'une chaîne de caractères représentant un entier (positif ou négatif) du type long. Si la chaîne ne représente pas une valeur entière correcte, la fonction arrête la conversion et fournit la valeur qu'elle a su reconnaître jusqu'à ce point. Exercice 9.34 Ecrire la fonction CH_DOUBLE qui retourne la valeur numérique d'une chaîne de caractères représentant un réel en notation décimale. Si la chaîne ne représente pas une valeur décimale correcte, la fonction arrête la conversion et fournit la valeur qu'elle a su reconnaître jusqu'à ce point. (Méthode: voir exercice 8.18.) Exercice 9.35

41

WAFAE SABBAR

43 4 42 WAFAE SABBAR . LMAX. L.37 a) Ecrire la fonction LIRE_DIM à quatre paramètres L. L. C et CMAX qui affiche les composantes de la matrice de dimensions L et C. TRANSPO_MATRICE retourne une valeur logique qui indique si les dimensions de la matrice sont telles que la transposition a pu être effectuée. C. Choisir les paramètres nécessaires. Utiliser la fonction INVERSER_CH définie plus haut.36 Ecrire la fonction DOUBLE_CH qui construit une chaîne de caractères CH qui représente un nombre réel N avec 4 positions derrière la virgule. Exercice 9. CMAX qui lit les dimensions L et C d'une matrice à deux dimensions. CMAX qui effectue la transposition de la matrice MAT en utilisant la fonction PERMUTER. C. Représenter schématiquement la hiérarchie des appels des fonctions utilisées.42 Ecrire la fonction TRANSPO_MATRICE à cinq paramètres MAT.38 Ecrire la fonction ECRIRE_MATRICE à quatre paramètres MAT. Ecrire un petit programme qui teste la fonction TRANSPO_MATRICE. L. Exercice 9. Exercice 9. et CMAX qui lit les composantes d'une matrice MAT du type int et de dimensions L et C. C.Ecrire la fonction ENTIER_CH qui construit une chaîne de caractères CH qui représente un nombre entier N du type long. Idée pour la conversion : Multiplier N par 10 et utiliser ENTIER_CH. Ecrire un petit programme qui teste la fonction SOMME_MATRICE. b) Ecrire la fonction LIRE_MATRICE à quatre paramètres MAT. Exercice 9. Exercice 9. Implémenter les fonctions en choisissant bien le type des paramètres et utiliser un dialogue semblable à celui de LIRE_TAB.39 Ecrire la fonction SOMME_MATRICE du type long qui calcule la somme des éléments d'une matrice MAT du type int. Exercice 9. Les dimensions L et C doivent être inférieures à LMAX respectivement CMAX.41 Ecrire la fonction MULTI_MATRICE qui effectue la multiplication de la matrice MAT1 par un entier X: MAT1 = X * MAT1 Choisir les paramètres nécessaires et écrire un petit programme qui teste la fonction MULTI_MATRICE. N et CH sont les paramètres de la fonction DOUBLE_CH. Exercice 9. Exercice 9. LMAX. N et CH sont les paramètres de la fonction ENTIER_CH.40 Ecrire la fonction ADDITION_MATRICE qui effectue l'addition des matrices suivante: MAT1 = MAT1 + MAT2 Choisir les paramètres nécessaires et écrire un petit programme qui teste la fonction ADDITION_MATRICE.

(Méthode de calcul: voir exercice 7.22.Ecrire la fonction MULTI_2_MATRICES qui effectue la multiplication de deux matrices MAT1 (dimensions N et M) et MAT2 (dimensions M et P) en une troisième matrice MAT3 (dimensions N et P): MAT3 = MAT1 * MAT2 Supposez que les dimensions maximales des trois matrices soient toutes égales à 30 lignes et 30 colonnes. Ecrire un petit programme qui teste la fonction MULTI_2_MATRICES.) 43 WAFAE SABBAR .

6 Créer sur disquette puis afficher à l'écran le fichier FAMILLE. Exercice 10.4 Insérer un nouvel enregistrement dans INFORM.TXT.10 .3 Ajouter un nouvel enregistrement (entré au clavier) à la fin de INFORM.TXT.TXT qui est la copie exacte (enregistrement par enregistrement) du fichier INFORM. Exercice 10.1 Créer sur disquette puis afficher à l'écran le fichier INFORM. Exercice 10. Définir une fonction d'aide PALI qui fournit le résultat 1 si la chaîne transmise comme paramètre est un palindrome.TXT en supposant que le fichier est trié relativement à la rubrique NOM et sauver le nouveau fichier sous le nom INFBIS.2 Ecrire un programme qui crée sur disquette un fichier INFBIS.5 Supprimer dans INFORM.TXT et sauver le nouveau fichier sous le nom INFBIS. LES FICHIERS SEQUENTIELS Exercice 10. sinon la valeur zéro.TXT. Sauver le nouveau fichier à chaque fois sous le nom INFBIS. Exercice 10.TXT dont les informations sont structurées de la manière suivante: Numéro de matricule (entier) Nom (chaîne de caractères) Prénom (chaîne de caractères) Le nombre d'enregistrements à créer est à entrer au clavier par l'utilisateur. Exercice 10.TXT dont les informations sont structurées de la manière suivante: Nom de famille Prénom du père Prénom de la mère Nombre d'enfants 44 WAFAE SABBAR .TXT tous les enregistrements: a) dont le numéro de matricule se termine par 8 b) dont le prénom est "Paul" (utiliser strcmp) c) dont le nom est un palindrome.TXT.

.11 Ecrire un programme qui remplace. Les noms des fichiers source et destination sont entrés au clavier. Utiliser une fonction d'aide FIN_PHRASE qui décide si un caractère transmis comme paramètre est un des séparateurs mentionnés ci-dessus. 45 WAFAE SABBAR .TXT qui contient une liste de nombres entiers. '!' ou '?' et 0 dans le cas contraire. les retours à la ligne par des espaces. . Exercice 10.TXT. Exercice 10. leur somme et leur moyenne. le nombre de palindromes ainsi que la longueur moyenne des mots contenus dans le fichier MOTS. un point d'interrogation ou un point d'exclamation.le nombre de chacune des lettres de l'alphabet (sans distinguer les majuscules et les minuscules).TXT sur la disquette.8 Ecrire un programme qui affiche le nombre de mots.le nombre de mots.TXT dans la mémoire centrale. seulement le premier sera remplacé. chaque nombre doit être suivi par un retour à la ligne.15) et les écrit dans un deuxième fichier MOTS_TRI.7 Ecrire un programme qui crée sur disquette le fichier MOTS. dans un fichier contenant un texte. Exercice 10.12 Ecrire un programme qui détermine dans un fichier un texte dont le nom est entré au clavier. Attention: Le nombre de rubriques des enregistrements varie avec le nombre d'enfants ! Exercice 10.TXT contenant une série de 50 mots au maximum (longueur maximale d'un mot: 50 caractères). La saisie des mots se terminera à l'introduction du symbole '*' qui ne sera pas écrit dans le fichier.le nombre de paragraphes (c.voir exercice 7.10 A l'aide d'un éditeur de textes. Exercice 10. . FIN_PHRASE retourne la valeur (logique) 1 si le caractère est égal à '.Prénoms des enfants Le nombre d'enregistrements à créer est entré au clavier. créer un fichier NOMBRES. Les mots seront mémorisés à l'aide d'un tableau de pointeurs sur char et la mémoire nécessaire sera réservée de façon dynamique. Exercice 10. Exercice 10. Dans le fichier.-à-d.'. le nombre de phrases terminées par un point.: des retours à la ligne).le nombre de caractères qu'il contient. Ecrire un programme qui affiche les nombres du fichier. les trie d'après la méthode par propagation (méthode de la bulle .9 Ecrire un programme qui charge les mots du fichier MOTS.13 Ecrire un programme qui détermine dans un fichier un texte dont le nom est entré au clavier: . Si plusieurs retours à la ligne se suivent.

3 fois la lettre z et 470 autres caractères Exercice 10.si le reste de la division par 97 est zéro et la valeur de contrôle est 97. SEPA utilise un tableau qui contient les séparateurs à détecter. . Exemple: Nombre de CCP 15742-28 : Nombre de CCP 72270-5 : Nombre de CCP 22610-10 : Nombre de CCP 50537-0 : 15742 modulo 97 = 28 72270 modulo 97 = 5 22610 modulo 97 = 9 50537 modulo 97 = 0 nombre incorrect. Utiliser la fonction getchar.si le reste de la division entière de la valeur devant le séparateur '-' par 97 est différent de zéro et égal à la valeur de contrôle. car la valeur de contrôle devrait être 97.guillemets: " .Les retours à la ligne ne devront pas être comptabilisés dans les caractères. Nombre de CCP 50537-97 : 50537 modulo 97 = 0 correct correct incorrect correct WAFAE SABBAR 46 . .15 Ecrire un programme qui vérifie la validité d'une série de numéros de CCP mémorisés dans un fichier. Exemple: Nom du fichier texte : A:LITTERA.espace . Un numéro de CCP est correct: .ponctuation: . un séparateur '-' et un numéro de contrôle. . On admettra que deux mots sont toujours séparés par un ou plusieurs des caractères suivants: .apostrophe: ' Utiliser une fonction d'aide SEPA qui décide si un caractère transmis comme paramètre est l'un des séparateurs mentionnés ci-dessus.TXT Votre fichier contient: 12 paragraphes 571 mots 4186 caractères dont 279 fois la lettre a 56 fois la lettre b . Exercice 10.fin de ligne .parenthèses: ( ) . SEPA restituera la valeur (logique) 1 si le caractère est un séparateur et 0 dans le cas contraire. . ? ! .14 Ecrire un programme qui affiche le contenu d'un fichier texte sur un écran de 25 lignes et 80 colonnes en attendant la confirmation de l'utilisateur (par 'Enter') après chaque page d'écran. Un numéro de CCP est composé de trois parties: un numéro de compte. : .

Pour tester le programme. TABB et TFUS dont les nombres d'éléments sont inconnus.TXT qui contient les numéros ci-dessus. suivis par des retours à la ligne. Ecrire un programme qui copie le contenu de FA et FB respectivement dans les tableaux TABA et TABB dans la mémoire centrale.Utiliser une fonction CCP_TEST qui obtient comme paramètres les deux parties numériques d'un nombre de CCP et qui affiche alors un message indiquant si le numéro de CCP est valide ou non. est réservée dynamiquement après que les longueurs des fichiers FA et FB ont été détectées. la tableau TABC est sauvé dans un fichier FC dont le nom est à entrer au clavier. Exercice 10. Les tableaux TABA et TABB sont fusionnés dans un troisième tableau trié en ordre croissant TABC. créer à l'aide d'un éditeur de texte un fichier CCP. Après la fusion.16 Deux fichiers FA et FB dont les noms sont à entrer au clavier contiennent des nombres entiers triés dans l'ordre croissant. La mémoire pour TABA. 47 WAFAE SABBAR .

SOLUTIONS SOLUTIONS 48 WAFAE SABBAR .

.. } les points-virgules séparent les instructions simples à l'intérieur d'un bloc d'instructions /* .. il existe seulement des fonctions.1 . française \n \t \b new line tabulator passage à la ligne tabulation curseur arrière back 49 WAFAE SABBAR ..1 En Pascal. NOTIONS DE BASE Exercice 1.. *) ou { . ").. anglaise descr. descr. end les commentaires sont délimités par { . (Les fonctions fournissant le résultat void correspondent aux procédures de Pascal. return 0. printf("world"). */ Exercice 1. d'échapp. } Exercice 1. il existe des fonctions et des procédures En C.3 Voici une des solutions possibles: #include <stdio.h> /* Notre premier programme en C */ main() { printf("hello..) il existe une structure spéciale program pour la fonction principale main est exécutée automatiquement la définition du programme principal lors de l'appel du programme les blocs d'instructions sont délimités par les blocs d'instructions sont délimités par begin ..' ) pas accepté (contient le caractère spécial 'é' ) accepté accepté accepté pas accepté (chiffre au début de l'identificateur) Exercice 1. } les commentaires sont délimités par (* ..2 fonction-1 pas accepté (contient le caractère spécial '-' ) _MOYENNE_du_MOIS_ accepté 3e_jour pas accepté (chiffre au début de l'identificateur) limite_inf. printf("\n").4 séq. lim_supérieure __A_ _ a 3 pas accepté (contient le caractère spécial '..

. . scanf de la bibliothèque <stdio>. } Solution: .Variables utilisées: NOMBRE. */ main() { int NOMBRE. COMPTEUR. /* Ajouter le nombre au résultat */ SOMME += NOMBRE.Commentaires (mis en italique). &NOMBRE).5 #include <stdio. SOMME.Fonction main n'a pas de paramètres (la liste des paramètres est vide) et fournit par défaut un résultat du type int (à l'environnement).Commande au compilateur: #include<stdio.\r \" \\ \0 \a return back-slash NUL attention (bell) retour au début de la ligne trait oblique fin de chaîne signal acoustique quotation marks guillemets Exercice 1.Fonctions utilisées: printf. .h> /* Ce programme calcule la somme de 4 nombres entiers introduits au clavier. /* Initialisation des variables */ SOMME = 0. /* Lecture des données */ while (COMPTEUR < 4) { /* Lire la valeur du nombre suivant */ printf("Entrez un nombre entier :"). COMPTEUR = 0. SOMME. /* Incrémenter le compteur */ COMPTEUR++. . } /* Impression du résultat */ printf("La somme est: %i \n". SOMME).h> pour pouvoir utiliser les fonctions printf et scanf. return 0. scanf("%i". . COMPTEUR déclarées comme entiers (type int).Opérateurs: 50 WAFAE SABBAR .

la fonction printf est appelée avec un respectivement avec deux paramètres: le premier paramètre est une chaîne de caractères.la fonction scanf est appelée avec deux paramètres: le format de saisie de la donnée (ici: "%i" pour lire un entier du type int) l'adresse de la variable destination (ici: l'adresse de NOMBRE)..L'instruction return 0. retourne la valeur zéro comme code d'erreur à l'environnement après l'exécution du programme Ajoutes : . (ici: SOMME) 51 WAFAE SABBAR . } répète le bloc d'instructions aussi longtemps que la <condition> est remplie. .Structure de contrôle: while(<condition>) { . .. les paramètres qui suivent la chaîne de caractères indiquent les noms des variables à afficher.+= ++ < = opérateur arithmétique d'affectation opérateur arithmétique opérateur de comparaison opérateur d'affectation . qui peut contenir une information pour le format d'affichage des variables indiquées dans la suite (ici: "%i" pour afficher la valeur du type int contenue dans SOMME).

.... entier N3 {0 .2 Traduisez les déclarations suivantes en C. réel SURFACE2 entier N1 int N1... 326} = {0 .. OPERATEURS ET EXPRESSIONS Exercice 2...5} {0 .. réel SURFACE1 float SURFACE1.... 8 positions significatives 52 WAFAE SABBAR . entier X.. 47} = {-16384 .. TYPES DE BASE. 16384} {0 .1 signed No: 1 2 3 4 5 6 7 8 9 10 11 12 13 X choix possible !X! meilleur choix !X! X X !X! !X! !X! X X X X X !X! X !X! !X! !X! !X! !X! X char !X! short int long X !X! X X !X! X X X X !X! X X X unsigned char short int long float double long double X X X !X! X X X X X X X X X X X !X! X X X X X X X Exercice 2.5 . 1 073 741 824} double SURFACE2. 1500750. 1024} {-47 .. entier N2 int N2.... Solution: (1) (2) (3) (4) (5) (6) (7) (8) entier COMPTEUR int COMPTEUR.... sans perdre en précision....OPERATEURS 2.... Choisissez les types les plus économiques......... 100} {-10 .. 150075} 6 positions significatives {-12 . entier MESURE int MESURE. 300} {-120 . sachant que vous travaillerez dans les ensembles de nombres indiqués.Y. 104} {0. 210} = {0 .....Y char X....

4*1010} 11 positions significatives {vrai. binaire 1016 8100 43690 585 51966 10000 156 01770 017644 0125252 01111 0145376 023420 0234 0X3F8 0X1FA4 0XAAAA 0X249 0XCAFE 0X2710 0X9C 1111111000 1111110100100 1010101010101010 1001001001 1100101011111110 10011100010000 10011100 Exercice 2. 3.1 0 => octal.. 'FE' seulement pour hexa. faux} par convention Exercice 2.0 0xeba 0123l '\n' 1. {-1280 .0e-1 double unsigned long 70000 53 WAFAE SABBAR .4 345lu 34.. (9) entier N4 double N4. dépend de la machine (ASCII: 10) 'unsigned' seulement pour des entiers -0..5L -1....5 -1.. 1285} = {-1 . dépend de la machine (ASCII: 79) 67 apostrophes manquent 1+0*8+0*64+1*512 = 513 -1.23ul 0FE0 40000 40000u 70000u 1e1f '0' o '\0' 0 'O' 67e0 \r 01001 int double long double double int long char long unsigned int float char char int char double int 12332 23.long N3.4 Donnée Type (si correct) Valeur / Erreur 12332 23. dépend de la machine (ASCII: 48) apostrophes manquent valeur en général zéro valeur zéro val.0 10+11*16+14*256 = 3770 3+2*8+1*64 = 83 val. 40000 40000 10 val. (10) booléen TROUVE int TROUVE.3 base décimale base octale base hexadécimale représ..4 déclaration correcte: 345ul 34.

0l 0XEUL long double 0 unsigned long 14 Exercice 2.h> #include <math.7 #include <stdio.0.5 Evaluer les expressions suivantes en supposant A=20 B=5 C=-10 D=2 X=12 Y=15 (1) (2) (3) (4) (5) (6) (7) (8) (9) (5*X)+2*((3*B)+4) (5*(X+2)*3)*(B+4) A == (B=5) A += (X+5) A != (C *= (-D)) A *= C+(X-D) A %= D++ A %= ++D (X++)*(A+C) -> 98 -> 1890 -> 0 -> 37 -> 0 -> 0 -> 0 -> 2 -> 120 -> 0+15 = 15 -> !0||1 = 1 -> 1||1&&1&&0 = 1 -> (1||1)&&0 = 0 / / B=5 A=37 C=20 A=0 D=3 A=0 D=3 A=2 X=13 A=15 / / / (10) A = X*(B<C)+Y*!(B<C) (11) !(X-D+C)||D (12) A&&B||!0&&C&&!D (13) ((A&&B)||(!0&&C))&&!D (14) ((A&&B)||!0)&&(C&&(!D)) -> (1||1)&&(1&&0) = 0 / Exercice 2.h> 54 WAFAE SABBAR .6 (1) (2) (3) (4) (5) (6) (7) (8) (9) (5*X) + 2*((3*B)+4) (5*(X+2)*3)*(B+4) A == (B=5) A += (X+5) A != (C *= (-D)) A *= C + (X-D) A %= D++ A %= ++D (X++) * (A+C) <=> 5*X + 2*(3*B+4) <=> 5*(X+2)*3*(B+4) / <=> A += X+5 <=> A != (C *= -D) <=> A *= C + X-D / / <=> X++ * (A+C) / / / <=> (A&&B||!0&&C)&&!D (10) A = X*(B<C) + Y*!(B<C) (11) !(X-D+C)||D (12) A&&B||!0&&C&&!D (13) ((A&&B)||(!0&&C))&&!D (14) ((A&&B)||!0)&&(C&&(!D)) <=> (A&&B||!0)&&C&&!D Exercice 2.

RES).main() { double A. /* Affichage du résultat */ printf("A exposant B est %f \n". /* Affichage du résultat */ printf("La valeur arrondie en moins de A/B est %f \n". /* Calcul */ RES = floor(A/B). scanf("%lf". /* Saisie de A et B */ printf("Introduire la valeur pour A : "). Expression /* code ASCII : 65 */ Type Valeur (1) C + 3 (2) B + 1 (3) C + C (4) 3 * C + 2 * B (5) 2 * B + (A + 10) / C int int int int long 13 66 75 160 132 (6) 2 * B + (A + 10.2)). double B. /* Affichage du résultat */ printf("La valeur A/B arrondie à trois décimales: %f \n". /* Calcul */ RES = sqrt(pow(A. /* Calcul */ RES = floor(1000*(A/B))/1000. /* Affichage du résultat */ printf("La tangente de A est %f \n". short C = 10. &B).5 55 WAFAE SABBAR . /* Calcul */ RES = pow(A. } Exercice 2. /* Affichage du résultat */ printf("L'hypoténuse du triangle rectangle est %f \n". RES). return 0. RES). double RES. RES). scanf("%lf". RES).2)+pow(B. &A). printf("Introduire la valeur pour B : ").0) / C double 132.B).8 Soient les déclarations: long A = 15. /* Calcul */ RES = sin(A)/cos(A). char B = 'A'.

#include <stdio. &MOIS.3 Ecrire un programme qui lit un caractère au clavier et affiche le caractère ainsi que son code numérique : a) en employant getchar et printf. .2 #include <stdio. RECU=scanf("%i %i %i". MOIS. . } b) en employant getch et printf. Exercice 3. JOUR. . &MOIS. printf("Introduisez la date (JOUR. MOIS. . &ANNEE). } Changez la partie format du programme de façon à séparer les différentes données par le symbole '-'.h> 56 WAFAE SABBAR . return 0. C. printf("Le caractère %c a le code ASCII %d\n". printf("\ndonnées reçues : %i\njour : %i\nmois : %i\nannee : %i\n". Solution: . ANNéE) : "). return 0.1 Voici les résultats du programme : C D E F G H I : : : : : : : n=6 p=2 n=6 p=3 n=6 p=2 n=6 p=3 S S 83 83 53 53 q=1 q=1 q=0 q=1 Exercice 3. &ANNEE). C). LIRE ET ÉCRIRE DES DONNÉES Exercice 3. C = getchar(). RECU. . #include <stdio. &JOUR.3 . printf("Introduire un caractère suivi de 'Enter'\n"). &JOUR. MOIS. RECU.h> main() { int C. ANNEE. ANNEE).h> main() { int JOUR. RECU=scanf("%i-%i-%i".

return 0. B. B. &A. (float)A/B). C) : "). printf("Quotient rationnel : %f\n". A/B). Le résultat de la division est du type float et doit être représenté par le spécificateur de format %f (ou %e). alors la valeur de la deuxième opérande B est convertie automatiquement en float. scanf("%i %i %i".h> main() { int A. C). C=B. A. C. A%B). B. } Exercice 4. il faut qu'au moins l'une des deux opérandes soit d'un type rationnel. &B. } Exercice 3. printf("Introduire un caractère \n"). printf("Division entiere : %i\n".4 Solution: #include <stdio. &A. Si nous convertissons la valeur de l'opérande A en float à l'aide de l'opérateur de conversion forcée. C). B. B=AIDE. Remarquez bien que la conversion forcée concerne uniquement la valeur de la variable A ! La valeur de B est convertie automatiquement.#include <conio. C = getch(). scanf("%i %i". &B).h> main() { int C. printf("Introduisez trois nombres (A. &C). A=C. D'autre part. return 0. si nous écrivions: (float)(A/B) nous n'obtiendrions pas le résultat désiré. printf("Reste : %i\n". printf("Introduisez deux nombres entiers : ").5 #include <stdio. B. } Remarque: Conversion des types Pour obtenir un résultat rationnel. return 0. /* Affichage à l'aide de tabulations */ printf("A = %i\tB = %i\tC = %i\n".h> main() { int A. AIDE. C. printf("A = %i\tB = %i\tC = %i\n". parce que la conversion se ferait seulement après la division ! 57 WAFAE SABBAR . printf("Le caractère %c a le code ASCII %d\n". AIDE=A. A. C).

R3.h> main() { double R1. return 0.7 #include <stdio. scanf("%lf %lf %lf". R2. */ 58 WAFAE SABBAR . printf("Resistance resultante parallele : %f\n". /* ou bien: float P. les autres opérandes */ /* sont converties automatiquement. &R2. */ printf("Introduisez les valeurs pour A. R2 et R3 : "). &R2. printf("Resistance resultante serielle : %f\n". scanf("%i %i %i".8 a) en se servant de 5 variables (mémorisation des valeurs entrées) #include <stdio. &R1. printf("Surface du triangle S = %f\n". } Exercice 3. &R3). C. */ /* déclarons P comme rationnel.h> main() { double R1. RRES). } En affichant immédiatement le résultat du calcul. */ int A. nous n'avons pas besoin de la variable d'aide RRES: #include <stdio. &R1. B et C : ").h> main() { /* Pour ne pas perdre de précision lors de la division. return 0. RRES). RRES=R1+R2+R3. printf("Introduisez les valeurs pour R1. RRES=(R1*R2*R3)/(R1*R2+R1*R3+R2*R3).h> #include <math. printf("Resistance resultante serielle : %f\n". R2 et R3 : "). R3. RRES. */ P=((double)A+B+C)/2. printf("Resistance resultante parallele : %f\n".h> main() { /* Pour être sûrs de ne pas dépasser le domaine de la */ /* variable. sqrt(P*(P-A)*(P-B)*(P-C))). (R1*R2*R3)/(R1*R2+R1*R3+R2*R3)). B. &R3). scanf("%lf %lf %lf". /* En forçant la conversion de A. &C). } Exercice 3. nous choisissons le type long pour la somme. R1+R2+R3). return 0. R2.6 #include <stdio. printf("Introduisez les valeurs pour R1. &B. double P.Exercice 3. &A.

return 0. B. A. printf("Entrez le quatrième scanf("%d". SOM = 0. &A). SOM+=A. nombre : "). } nombre : "). SOM). } Exercice 3. scanf("%d".9 a) #include <stdio. SOM+=A. scanf("%d". printf("Entrez le prix net de l'article : "). printf("Entrez le quatrième nombre : "). SOM+=A. printf("Entrez le troisième scanf("%d". printf(" %d + %d + %d + %d return 0. &A). printf("Entrez le deuxième nombre : "). long SOM.h> main() { int PNET. } 59 WAFAE SABBAR . SOM). = %ld\n". printf("La somme des nombres entrés est %ld\n". D.PTTC). &TVA). printf("Entrez le premier scanf("%d". printf("Entrez le deuxième scanf("%d". D. SOM = (long)A+B+C+D. &A). printf("Entrez le troisième nombre : "). */ int A. scanf("%d". printf("Le prix TTC est %. printf("Entrez le taux de la TVA (en %) : "). &A).2lf Francs\n". &C). scanf("%d". B. nombre : "). scanf("%d". return 0. nombre : "). scanf("%d". &B). C. printf("Entrez le premier nombre : "). &PNET). &A). SOM+=A. C. double PTTC.int A. b) en se servant de 2 variables (perte des valeurs entrées) main() { /* Pour être sûrs de ne pas dépasser le domaine de la */ /* variable. nous choisissons le type long pour la somme. &D). TVA. PTTC = PNET+(double)PNET*TVA/100. long SOM.

&TVA). suite . /* donnée et résultat du type double */ printf("Entrez le prix TTC de l'article : "). Un simple remède aux confusions serait ici l'utilisation de la constante 100. Il ne suffirait donc pas d'écrire: PTTC = (double)PNET+PNET*TVA/100. printf("Entrez le taux de la TVA (en %) : ").-à-d. . c. La première opérande de la division est donc du type double et le résultat de l'addition est automatiquement converti en double avant la division.0+TVA)).utiliser la conversion (double) lors des premières opérations effectuées: PTTC = PNET+(double)PNET*TVA/100.0.h> main() { int TVA. PNET et PTTC sont du type double. scanf("%lf".déclarer PNET et/ou TVA comme double : double PNET. Il existe plusieurs possibilités de résoudre ce problème: . PTTC. Comme l'évaluation des opérateurs binaires * et / se fait en passant de gauche à droite. PTTC. TVA. il faut forcer l'utilisation du type double.0) pour être multipliée avec PTTC. scanf("%d".2lf Francs\n". Parce que la multiplication et la division ont la priorité sur l'addition. pas de forçage de type nécessaire */ PNET = PTTC*100/(100+TVA). la conversion se ferait trop tard.utiliser une constante du type double lors de la division: PTTC = PNET+PNET*TVA/100. } Remarque: Conversion de types et priorités Ici. b) #include <stdio. 60 WAFAE SABBAR . &PTTC).Remarque: Conversion des types et priorités Lors du calcul de PTTC (type double). nous divisons le produit du PNET (type int) et de la TVA (type int) par 100. /* Calcul: Ici. return 0.: à la fin du calcul.0 à la place de 100 : PNET = PTTC*100. il faut respecter la suite de l'évaluation de l'expression. double PNET. printf("Le prix net est %. la valeur 100 est d'abord convertie en double (valeur 100. . En utilisant l'opérateur de la conversion forcée. PNET). Pour ne pas perdre de la précision lors de la division et pour éviter un dépassage du domaine lors du calcul du produit. . .0/(100.

h> #include <math.2)+pow(YA-YB. &XB. scanf("%d. DIST). &YA). &YB). &XA.%d". } 61 WAFAE SABBAR . */ printf("Entrez les coordonnées du point A : XA.% d) et B(%d. XB.h> main() { int XA.2f\n".YB ").10 #include <stdio. YA. double DIST. DIST=sqrt(pow(XA-XB. XA. YA.%d". XB. %d) est %. /* Attention: La chaîne de format que nous utilisons */ /* s'attend à ce que les données soient séparées par */ /* une virgule lors de l'entrée. printf("La distance entre A(%d. scanf("%d.Exercice 3. return 0.YA "). printf("Entrez les coordonnées du point B : XB.2)). YB. YB.

else if (A>10) printf ("deuxième choix \n"). b) Déterminez les réponses du programme pour chacun des couples de nombres suivants et vérifiez à l'aide de l'ordinateur.4 . if (A>B) printf ("premier choix \n"). else printf ("quatrième choix \n"). if (B<10) printf ("troisième choix \n").else appartenant ensemble. else printf ("quatrième choix \n").else appartenant ensemble.2 Considérez la séquence d'instructions suivante: if (A>B) if (A>10) printf ("premier choix \n").1 if (A>B) printf ("premier choix \n"). if (B<10) printf ("troisième choix \n"). else if (B<10) printf ("deuxième choix \n"). a) Copiez la séquence d'instructions en utilisant des tabulateurs pour marquer les blocs if . A=10 et B=5 : A=5 et B=5 : A=5 et B=10 : premier choix troisième choix troisième choix quatrième choix A=10 et B=10 : quatrième choix A=20 et B=10 : premier choix quatrième choix A=20 et B=20 : deuxième choix quatrième choix Exercice 4. else if (B<10) 62 WAFAE SABBAR . LA STRUCTURE ALTERNATIVE Exercice 4. else printf ("quatrième choix \n"). else if (A>10) printf ("deuxième choix \n"). a) Copiez la séquence d'instructions en utilisant des tabulateurs pour marquer les blocs if . if (A>B) if (A>10) printf ("premier choix \n"). else if (A==B) printf ("troisième choix \n").

scanf("%i %i %i".. else MAX=B. B. return 0. &B. if (A>B) MAX=A. 63 WAFAE SABBAR . Si (A>B) alors la construction if .else garantit que toutes les combinations sont traitées et fournissent un résultat Exercice 4. &B..else sans variable d'aide int A. C..C). else printf ("quatrième choix \n"). printf("La valeur maximale est %i\n"..printf ("deuxième choix \n"). &A.else if .h> main() { int A. else printf("%i\n".3 a) if .A). b) Le résultat: "premier choix" apparaît pour (A>B) et (A>10) "deuxième choix" apparaît pour (10 A>B) "troisième choix" apparaît pour (10 A>B 10) et (A=B) 10>10 impossible A>B et A=B impossible => "troisième choix" n'apparaît jamais "quatrième choix" apparaît pour (10 A>B 10) et (A B) 10>10 impossible => "quatrième choix" n'apparaît jamais c) On n'obtient pas de réponses pour (A B). printf("Introduisez trois nombres entiers :"). else if (B>C) printf("%i\n".. } b) if . B. if (A>B && A>C) printf("%i\n". MAX). int MAX. printf("Introduisez trois nombres entiers :").else et une variable d'aide MAX #include <stdio. else if (A==B) printf ("troisième choix \n"). &A. printf("La valeur maximale est "). &C). . . if (C>MAX) MAX=C. &C).. scanf("%i %i %i". C.else if .B).

A = C. &A. MAX = (MAX>C) ? MAX : C. printf("Introduisez trois nombres entiers :"). C. &A. MAX). C. &B. C).5 #include <stdio. printf("Introduisez trois nombres entiers :"). scanf("%i %i %i". A. &C). printf("La valeur maximale est %i\n". scanf("%i %i %i". B = AIDE. C. C = AIDE. &A. AIDE. printf("Avant le tri : \tA = %i\tB = %i\tC = %i\n". } if (A<C) { AIDE = A. B. &B. A.h> main() { /* Afficher le signe du produit de deux entiers sans 64 WAFAE SABBAR . d) opérateurs conditionnels sans variable d'aide int A. scanf("%i %i %i". /* Valeur maximale -> A */ if (A<B) { AIDE = A. int MAX. Exercice 4. return 0. B. B. } Exercice 4. C).h> main() { /* Tri par ordre décroissant de trois entiers en échangeant les valeurs */ int A. printf("La valeur maximale est %i\n". B.c) opérateurs conditionnels et une variable d'aide MAX int A. A = B. &C). } printf("Après le tri : \tA = %i\tB = %i\tC = %i\n". B = C.4 #include <stdio. C = AIDE. &B. (A>((B>C)?B:C)) ? A : ((B>C)?B:C)). printf("Introduisez trois nombres entiers :"). &C). } /* trier B et C */ if (B<C) { AIDE = B. MAX = (A>B) ? A : B. B.

\n"). else printf("Le produit %i * %i est zéro\n". else printf("La somme %i + %i est zéro\n". A. printf("degré de la forme ax^2 + bx + c = 0 \n\n"). &B. else if ((A<0 && B<0) || (A<0 && B>0 && fabs(A)>fabs(B)) || (A>0 && B<0 && fabs(A)<fabs(B))) printf("Le signe de la somme %i + %i est négatif\n". A. &A. /* Distinction des différents cas */ if (A==0 && B==0 && C==0) /* 0x = 0 */ printf("Tout réel est une solution de cette équation. B. 65 WAFAE SABBAR . else if (A==0 && B==0) /* Contradiction: c # 0 et c = 0 */ printf("Cette équation ne possède pas de solutions. /* Calcul du discriminant b^2-4ac */ D = pow(B.7 #include <stdio. return 0. } Exercice 4.4. if ((A>0 && B>0) || (A<0 && B>0 && fabs(A)<fabs(B)) || (A>0 && B<0 && fabs(A)>fabs(B))) printf("Le signe de la somme %i + %i est positif\n". &B).A. double D.2) .faire la multiplication */ int A. printf("Introduisez deux nombres entiers :").\n"). return 0.h> main() { /* Calcul des solutions réelles d'une équation du second degré */ int A.6 #include <stdio. B. A. else if ((A<0 && B>0) || (A>0 && B<0)) printf("Le signe du produit %i * %i est négatif\n". et c : "). scanf("%i %i". printf("Introduisez les valeurs pour a. B). B).h> main() { /* Afficher le signe de la somme de deux entiers sans faire l'addition */ int A. &B). &C). b.h> #include <math.B). A. B. B). } Exercice 4. scanf("%i %i %i". scanf("%i %i".B).0*A*C. B). printf("Introduisez deux nombres entiers :"). &A. /* Discriminant */ printf("Calcul des solutions réelles d'une équation du second \n"). &A. C. if ((A>0 && B>0) || (A<0 && B<0)) printf("Le signe du produit %i * %i est positif\n".h> #include <math.A.

(-B-sqrt(D))/(2*A)). } else if (D<0) /* b^2-4ac < 0 */ printf("Cette équation n'a pas de solutions réelles. printf(" x = %.4f\n". printf(" x = %.4f\n".4f\n". printf(" x2 = %. } else /* b^2-4ac > 0 */ { printf("Les solutions réelles de cette équation sont :\n"). } return 0. printf(" x1 = %. (double)C/B).4f\n". (-B+sqrt(D))/(2*A)). } 66 WAFAE SABBAR .else if (A==0) /* bx + c = 0 */ { printf("La solution de cette équation du premier degré est :\n"). else if (D==0) /* b^2-4ac = 0 */ { printf("Cette équation a une seule solution réelle :\n").\n"). (double)-B/(2*A)).

LA STRUCTURE REPETITIVE Exercice 5.while. } printf("La somme des %d nombres est %ld \n". I). PROD *= NOMB. N. /* nombre de données */ int NOMB. } while(I<=N). &NOMB). PROD=1. } b) en utilisant do . I). nombre : ". /* nombre courant */ int I. nombre : ". I++. /* la somme des nombres entrés */ double PROD. 67 WAFAE SABBAR . PROD *= NOMB. return 0. SOM). do { printf("%d. scanf("%d". scanf("%d".h> main() { int N. /* compteur */ long SOM. I++. (float)SOM/N). Remplacez le bloc de traitement (en gras) de (a) par : SOM=0. PROD). I=1. while(I<=N) { printf("%d. scanf("%d".1 a) en utilisant while. SOM += NOMB. &NOMB). &N). /* le produit des nombres entrés */ printf("Nombre de données : "). SOM += NOMB. PROD=1. I=1.0f\n".4f\n". N.5 . printf("Le produit des %d nombres est %. c) en utilisant for. #include <stdio. SOM=0. N. printf("La moyenne des %d nombres est %.

&N).3 #include <stdio. scanf("%d". elle permet d'intégrer très confortablement l'initialisation et l'incrémentation des variables dans la structure. DIV++. } while(N<1 || N>15). } d) Laquelle des trois variantes est la plus naturelle pour ce problème? La structure for est la plus compacte et celle qui exprime le mieux l'idée de l'algorithme. nombre : ". &DEN). D'autre part. Comme l'introduction du nombre de données doit toujours être exécuté (au moins une fois). I=1 . par do { printf("Nombre de données : "). PROD *= NOMB. I<=N . scanf("%d". DIV=0. /* reste de la division entière */ printf("Introduisez le numérateur : "). printf("Introduisez le dénominateur : "). scanf("%d".Remplacez le bloc de traitement (en gras) de (a) par : for (SOM=0. le plus naturel sera l'utilisation de la structure do . &NUM). while(RES>=DEN) { RES-=DEN.while. /* dénominateur de la division entière */ int DIV. Exercice 5. /* numérateur de la division entière */ int DEN. /* résultat de la division entière */ int RES. 68 WAFAE SABBAR . SOM += NOMB. scanf("%d". Exercice 5. nous avons le choix entre while et do while. Quelle structure répétitive utilisez-vous? Pourquoi? Comme il n'y pas d'initialisation ni de réinitialisation de variables. RES=NUM. I). PROD=1. scanf("%d". &N). I++) { printf("%d.h> main() { int NUM.2 Remplacer les lignes printf("Nombre de données : "). &NOMB).

RES). I++) FACT*=I. */ printf ("%d! = %. /* La factorielle N! . le résultat sera automatiquement 0!=1 */ I=1. DIV. &N). */ printf(" %d divisé par %d est %d reste %d\n". I<=N . le résultat sera automatiquement 0!=1 */ /* for (FACT=1. scanf("%d".h> main() { 69 WAFAE SABBAR .4 Solution combinée : (Essayez l'une ou l'autre des solutions en déplaçant les marques des commentaires !) #include <stdio. DEN. DIV++) RES-=DEN.} /* ou mieux encore : */ /* for (RES=NUM. /* Le compteur */ double FACT. } Exercice 5.0. while (I<=N) { FACT*=I. I++. } while (N<0).Type double à */ /* cause de la grandeur du résultat. FACT=1. return 0. } Exercice 5. N. return 0. } /* b */ /* Pour N=0.0f\n". I=1 . NUM. FACT). /* a */ /* Pour N=0.5 #include <stdio.h> main() { int N. */ do { printf("Entrez un entier naturel : "). /* La donnée */ int I. DIV=0 . RES>=DEN .

*/ printf("Entrez l'entier naturel X : "). N.h> main() { int X. I++) RESU*=X. return 0. /* Les données int I.int X. scanf("%d".6 #include <stdio. } while (N<1).0. /* compteur pour la boucle */ float SOM. else printf("Résultat : %d ^ %d = %. 0^0 n'est pas défini */ if (N==0 && X==0) printf("zéro exposant zéro n'est pas défini !\n"). } while (X<0). N. return 0. /* Le compteur double RESU.0f\n". printf("La somme des %d premiers termes est %f \n". N. for (SOM=0. SOM). /* Type double /* grandeur du do { */ */ à cause de la */ résultat. &N). I<=N . I++) SOM += (float)1/I. /* Type float à cause de la précision du résultat. } while (N<0). le résultat sera automatiquement X^0=1 */ for (RESU=1. /* nombre de termes à calculer */ int I. scanf("%d". do { printf("Entrez l'exposant N : "). /* Attention: Pour X=0 et N=0 . scanf ("%d". /* Le compteur des données */ 70 WAFAE SABBAR . RESU). /* Pour N=0. } Exercice 5. &X). X.0.7 Solution (une de plusieurs solutions possibles) : #include <stdio. do { printf ("Nombre de termes: ").h> main() { int N. I=1 . /* Le chiffre courant */ int N=0. &N). I=1 . I<=N . } */ Exercice 5.

return 0. NOMB). */ */ do { /* Saisie des données (pour perfectionnistes) */ printf("Entrez le %d%s chiffre : ". (N)?"e":"er"). SOM+=X. &X). } else printf("La valeur du nombre renversé est %ld\n".8 #include <stdio. if (X<0||X>9) printf("\a"). return 0. } else if (!X && N>0) {/* Seulement si au moins un chiffre a été accepté */ printf("La somme des chiffres est %d \n". /* Le nombre résultat */ do { printf("Entrez le %d%s chiffre : ". else if (X) { NOMB += VALD*X. /* Le chiffre courant */ int N=0. } 71 WAFAE SABBAR . SOM).int SOM=0. (float)SOM/N). scanf("%d". } } while (X). (N+1). /* Le produit actuel . PROD*=X. VALD *= 10. (N)?"e":"er"). printf("La moyenne des chiffres est %f \n".h> main() { int X. else if (X) { N++. if (X<0||X>9) printf("\a"). printf("Le produit des chiffres est %ld\n". N++. &X). (N+1). PROD). } Exercice 5. } while (X). scanf("%d". /* La somme actuelle */ long PROD=1. /* Valeur de la position décimale courante */ long NOMB=0. /* Le compteur des décimales */ long VALD=1.Type long à */ /* cause de la grandeur du résultat.

} /* Autre possibilité : */ /* for (NINV=0 .10 #include <stdio. */ do { printf("Entrez un nombre positif (<10000) : ". while(NOMB>0) { NINV *= 10..Remarque : En remplaçant la ligne NOMB += VALD*X. NINV). Il faut cependant inclure les fonctions de la bibliothèque <math>. /* degré du polynôme */ float X. /* coefficients successifs du polynôme */ float P. /* Le nombre inversé */ /* Attention: en utilisant le type int. il est impossible */ /* d'inverser correctement des nombres comme 10033 . NINV += NOMB%10. &NOMB).h> main() { int NOMB. NINV=0. } Exercice 5. return 0. NOMB>0 . */ printf("Le nombre 'inversé' est : %d\n". N D'autre part.h> main() { int N. scanf("%d". par NOMB += pow(10. /* argument */ float A. on n'a plus besoin de la variable VALD. cette variante est plus lente et plus volumineuse que la première. N)*X. Finalement. Exercice 5. /* Le nombre à inverser */ int NINV.. /* coefficient courant du terme Horner */ printf("Entrer le degré N du polynôme : "). WAFAE SABBAR 72 . NOMB). NOMB /= 10.9 #include <stdio. NOMB/=10) NINV = NINV*10 + NOMB%10. } while (NOMB<0 || NOMB>9999). le calcul de 10 serait alors répété à chaque exécution de la boucle.

/* rang du terme demandé */ int I. scanf("%d". P = P*X + A. } Exercice 5. &B). RESTE. /* Initialisation des deux premiers termes */ if (N==1) 73 WAFAE SABBAR . /* pour parcourir la suite */ int N. N>=0 . d'aide pour l'algorithme d'Euclide */ do { printf("Entrer l'entier A (non nul) : "). printf("Le PGCD de %d et de %d est %d\n". scanf("%d". } printf("Valeur du polynôme pour X = %. N--) { printf("Entrer le coefficient A%d : ". RESTE . do { printf("Entrer l'entier B (non nul) : ").h> main() { int A. /* données */ int X. &N). P).scanf("%d".0 . printf("Entrer la valeur X de l'argument : "). X. X=A. } while(N<1). UN. /* var. X=Y. B. U1=U2=1. scanf("%d". A. &X). scanf("%f". } while(!B). return 0. for(P=0.h> main() { int U1. N).12 #include <stdio. B. for (RESTE=A. scanf("%f". Y=B . &A).11 #include <stdio. &A). Y=RESTE) RESTE = X%Y.2f : %. /* compteur pour la boucle */ do { printf("Rang du terme demandé : "). return 0. Y. } while(!A). U2. &N). X). } Exercice 5.2f\n".

I<=N .UN=U1.306989e 4931 U23601 = 9.h> main() { double A. UN. de format : %d) (spéc. /* approximation de la racine carrée de A */ int N. } while(N<=0 || N>=50). else if (N==2) UN=U2. U2. scanf("%d". J<=N . de format : %ld) (spéc. &N). de format : %e) (spéc. } 74 WAFAE SABBAR . J++) { X = (X + A/X) / 2. } while(A<0). &A). UN. U2 = UN.2f est %. (spéc. U2. /* donnée */ double X. for(X=A.2f\n". } } printf("Valeur du terme de rang %d : %d\n". U2. J.13 #include <stdio. else { for (I=3 . A. return 0. UN. UN. /* degré/précision de l'approximation */ int J. long double U1. printf("La %2d%s approximation de la racine carrée" " de %. N. J=1 . scanf("%lf". U1 = U2. (J==1)?"ère":"e". } return 0. double U1. do { printf("Entrer le degré de l'approximation : "). /* degré de l'approximation courante */ do { printf("Entrer le réel positif A : "). I++) { UN = U1+U2. } Rang et terme maximal calculable en utilisant les déclarations : int U1.285655e Exercice 5. de format : %Le) U23 = 28657 U46 = 1836311903 308 U1476 = 1. X). U2. UN). long U1.

I++) { printf("%3d I". J<=MAX . scanf("%d". I++) putchar('*'). printf("\n"). putchar('\n').h> main() { const int MAX = 10. /* compteur des caractères do { printf("Nombres de lignes : "). L<LIG . I<2*L+1 .h> main() { int LIG. /* compteur des colonnes */ /* Affichage de l'en-tête */ printf(" X*Y I").14 #include <stdio. J++) printf("----"). } 75 WAFAE SABBAR . /* Affichage du tableau */ for (I=0 .Exercice 5. I++) putchar(' '). } while (LIG<1 || LIG>20). for (J=0 . printf("------").15 #include <stdio. I<=MAX . /* compteur des lignes int ESP. for (J=0 . /* compteur des lignes */ int J. printf("\n"). for (J=0 . J). /* nombre de lignes et de colonnes */ int I. J<=MAX . I<ESP . } return 0. J<=MAX . for (I=0 . printf("\n"). for (L=0 . J++) printf("%4d". for (I=0 . } return 0. /* nombre de lignes int L. I*J). } */ */ */ */ Exercice 5. /* nombre d'espaces int I. L++) { ESP = LIG-L-1. J++) printf("%4d". &LIG). I).

I++) printf("%d ".type long à cause */ /* de la grandeur prévisible du résultat.J. I). LES TABLEAUX Exercice 6. I++) printf("%d ". I<N. /* somme des éléments . I<N. &N ). I++) { printf("Elément %d : ". for (I=0. /* tableau donné */ int N. /* Edition du résultat */ printf("Somme de éléments : %ld\n". */ /* Saisie des données */ printf("Dimension du tableau (max. /* indices courants */ /* Saisie des données */ printf("Dimension du tableau (max.6 . /* Calcul de la somme */ for (SOM=0. /* dimension */ int I. } Exercice 6. &T[I]).50) : "). I++) { printf("Elément %d : ".h> main() { /* Déclarations */ int T[50]. I<N. scanf("%d". &N ). printf("\n"). T[I]).1 #include <stdio. scanf("%d". SOM). } /* Affichage du tableau */ printf("Tableau donné : \n"). for (I=0.2 #include <stdio. T[I]). /* dimension */ int I. } /* Affichage du tableau */ printf("Tableau donné :\n"). I=0. for (I=0. 76 WAFAE SABBAR . I<N. scanf("%d".h> main() { /* Déclarations */ int T[50]. /* indice courant */ long SOM. I<N. scanf("%d". I). return 0. /* tableau donné */ int N. for (I=0.50) : "). I++) SOM += T[I]. &T[I]).

I++) { T[J] = T[I]. /* pour l'échange */ /* Saisie des données */ printf("Dimension du tableau (max. I++) { printf("Elément %d : ". } /* Edition des résultats */ printf("Tableau résultat :\n"). scanf("%d". for (I=0. I<N.h> main() { /* Déclarations */ int T[50]. */ for (I=0. I++) printf("%d ". I<N. return 0. &N ). printf("\n"). I++) printf("%d ". scanf("%d". if (T[I]) J++. for (I=0.J--) /* Echange de T[I] et T[J] */ { AIDE = T[I]. /* indices courants */ int AIDE. } 77 WAFAE SABBAR . /* Effacer les zéros et comprimer : */ /* Copier tous les éléments de I vers J et */ /* augmenter J pour les éléments non nuls.50) : ").3 #include <stdio. for (I=0. /* Inverser le tableau */ for (I=0. T[J] = AIDE. for (I=0. return 0. T[I]). printf("\n"). J=N-1 . } Exercice 6. printf("\n"). T[I] = T[J]. /* dimension */ int I. &T[I]). } /* Affichage du tableau */ printf("Tableau donné : \n"). I). /* tableau donné */ int N. I++) printf("%d ". I++. } /* Nouvelle dimension du tableau ! */ N = J. J=0 . I<N.printf("\n").J. T[I]). I<N. I<J . /* Edition des résultats */ printf("Tableau résultat :\n"). I<N . T[I]).

NNEG. NNEG=0.h> main() { /* Déclarations */ int T[50][50]. } } /* Edition du résultat */ printf("Tableau TPOS :\n"). TNEG[I]). } if (T[I]<0) { TNEG[NNEG]=T[I]. /* dimensions */ int I. I<NNEG.5 #include <stdio. NPOS.Exercice 6. I<N. J. /* somme des éléments .h> main() { /* Déclarations */ /* Les tableaux et leurs dimensions */ int T[50]. for (I=0. TPOS[I]). /* indices courants */ long SOM. TPOS[50]. C. I). NNEG++. for (I=0.type long à cause */ 78 WAFAE SABBAR . NPOS++. printf("\n"). for (I=0. T[I]). return 0. I++) { if (T[I]>0) { TPOS[NPOS]=T[I]. I++) { printf("Elément %d : ". I++) printf("%d ".50) : "). } Exercice 6. } /* Affichage du tableau */ printf("Tableau donné :\n"). I<NPOS. I++) printf("%d ". printf("\n"). I<N.4 #include <stdio. /* Transfer des données */ for (I=0. /* Initialisation des dimensions de TPOS et TNEG */ NPOS=0. scanf("%d". printf("Tableau TNEG :\n"). &T[I]). /* indice courant */ /* Saisie des données */ printf("Dimension du tableau (max. printf("\n"). for (I=0. &N ). int I. scanf("%d". I++) printf("%d ". TNEG[50]. /* tableau donné */ int L. I<N. int N.

50) : "). I++) for (J=0. scanf("%d". I++) for (J=0. I<L. SOM). C. J++) { printf("Elément[%d][%d] : ". J++) printf("%7d". &C ). I++) for (J=0. J<C. /* dimensions */ int I.I. J<C. &C ). for (I=0. for (I=0. /* Edition du résultat */ printf("Somme des éléments : %ld\n". T[I][J]).type long à cause */ /* de la grandeur prévisible des résultats. return 0. */ /* Saisie des données */ printf("Nombre de lignes (max.J). /* tableau donné */ int L. for (I=0. &T[I][J]). */ /* Saisie des données */ printf("Nombre de lignes (max. /* indices courants */ long SOM. I<L. &L ). I<L. for (I=0.50) : ").I. J.50) : "). scanf("%d". J++) { printf("Elément[%d][%d] : ". printf("Nombre de colonnes (max. J<C. J++) SOM += T[I][J].h> main() { /* Déclarations */ int T[50][50]. T[I][J]). &T[I][J]). } /* Affichage du tableau */ printf("Tableau donné :\n"). } Exercice 6. I<L. /* somme des éléments . 79 WAFAE SABBAR .50) : "). J<C. printf("\n"). J++) printf("%7d". &L ). I<L. I=0. } /* Affichage du tableau */ printf("Tableau donné :\n"). scanf("%d"./* de la grandeur prévisible du résultat. scanf("%d". } /* Calcul de la somme */ for (SOM=0. scanf("%d".J). J<C. I++) { for (J=0. scanf("%d".6 #include <stdio. I++) { for (J=0. printf("Nombre de colonnes (max.

} Exercice 6. I<L. J++) SOM += T[I][J]. for (I=0. for (I=0.colonne %d : %ld\n". } return 0. J<C. I++) printf("%d ". I++) { for (SOM=0. J<C.I.J). printf("\n"). /* dimensions */ int I. } /* Affichage du tableau 2-dim */ printf("Tableau donné :\n").printf("\n"). J++) { printf("Elément[%d][%d] : ". I<L. I<L. scanf("%d". /* Affichage du tableau 1-dim */ printf("Tableau résultat : "). J. J<C.SOM).h> main() { /* Déclarations */ int M[10][10]. I<L*C. J++) printf("%7d". I=0.J.10) : "). J<C. return 0. J<C. } /* Calcul et affichage de la somme des colonnes */ for (J=0. for (I=0. J=0. 80 WAFAE SABBAR . I<L. J++) V[I*C+J] = M[I][J].I. scanf("%d". printf("Somme . } /* Transfer des éléments ligne par ligne */ for (I=0. C. } /* Calcul et affichage de la somme des lignes */ for (I=0. printf("\n").SOM). I++) for (J=0. printf("Somme . scanf("%d". J++) { for (SOM=0. &L ). I<L. &M[I][J]). /* tableau à 2 dimensions */ int V[100].10) : "). M[I][J]). I++) for (J=0. /* tableau à 1 dimension */ int L. &C ).7 #include <stdio. I++) { for (J=0. /* indices courants */ /* Saisie des données */ printf("Nombre de lignes (max. printf("Nombre de colonnes (max. V[I]).ligne %d : %ld\n". I++) SOM += T[I][J].

I++) PS += (long)U[I]*V[I]. for (I=0. for (I=0. I). } /* Calcul du produit scalaire */ for (PS=0. scanf("%f". I<=N .h> main() { /* Déclarations */ int U[50]. 81 WAFAE SABBAR . I++) { printf("Elément %d : ". /* Edition du résultat */ printf("Produit scalaire : %ld\n". I<N. I). scanf("%d". &N )./* tableau des coefficients de P */ int I. scanf("%f". /* indice courant */ long PS. /* dimension */ int I.h> main() { float A[20]. /* tableaux donnés */ int N. &V[I]). I++) { printf("Elément %d : ". V[50]. /* Saisie des coefficients */ for (I=0 .9 Calcul d'un polynôme de degré N Solution combinée: #include <stdio.} Exercice 6.50) : "). } printf("** Deuxième tableau **\n"). /* résultat */ /* Saisie du degré N et de l'argument X */ printf("Entrer le degré N du polynôme (max.20) : "). /* indice courant */ int N. I=0. &N). return 0. /* produit scalaire */ /* Saisie des données */ printf("Dimension des tableaux (max. &X). I<N.8 Produit scalaire de deux vecteurs #include <stdio. scanf("%d". /* degré du polynôme */ float X. /* argument */ float P. I<N. PS). } Exercice 6. printf("** Premier tableau **\n"). I++) { printf("Entrer le coefficient A%d : ". &A[I]). printf("Entrer la valeur X de l'argument : "). I). &U[I]). scanf("%d".h> #include <math. scanf("%d".

printf("Position du maximum : %d\n".*/ . scanf("%d". I=0 . } /* Affichage du tableau */ printf("Tableau donné :\n"). I++) { if(A[I]>A[MAX]) MAX=I. I=0 P = P*X + */ Horner */ calcul avec le dernier coefficient.50) : "). MAX=0. &N ). scanf("%d".0. A[I]). /* Recherche du maximum et du minimum */ MIN=0. MAX).. /* indice courant */ int MIN. I<N. I++) { printf("Elément %d : ". /* dimension */ int I. /* position du maximum */ /* Saisie des données */ printf("Dimension du tableau (max.I). /* tableau donné */ int N. MIN). printf("Valeur du maximum : %d\n". printf("Valeur du minimum : %d\n".0. X.. printf("\n"). &A[I]). I<=N .11 Insérer une valeur dans un tableau trié #include <stdio. for (I=0. if(A[I]<A[MIN]) MIN=I. I++) printf("%d ". return 0. I++) A[N-I]. I<N. A[MIN]). I<=N . A[MAX]). /* Edition du résultat */ printf("Valeur du polynôme pour X = %. I++) P += A[I]*pow(X. /* b) Calcul de /* commencer le for (P=0.h> main() { /* Déclarations */ int A[50]. /* position du minimum */ int MAX. } Exercice 6. } /* Edition du résultat */ printf("Position du minimum : %d\n".} /* a) Calcul à l'aide de pow for (P=0. for (I=0.2f : %.h> main() 82 WAFAE SABBAR .10 Maximum et minimum des valeurs d'un tableau #include <stdio.2f\n". I). P). I<N. for (I=0. } Exercice 6. return 0.

/* Edition des résultats */ printf("Tableau résultat :\n"). I++) printf("%d ".12 Recherche d'une valeur dans un tableau a) La recherche séquentielle Comparer successivement les valeurs du tableau avec la valeur donnée. 83 WAFAE SABBAR . for (I=0. scanf("%d". I). A[I]). scanf("%d".50) : "). for (I=0. /* valeur à rechercher */ int POS. } printf("Elément à insérer : "). I--) A[I]=A[I-1]. A[I]). /* VAL est copié à la position du dernier */ /* élément déplacé. /* position de la valeur */ int N. I<N. &VAL ). /* tableau donné int VAL. I++) printf("%d ". /* Affichage du tableau */ printf("Tableau donné : \n"). } Exercice 6.{ /* Déclarations */ int A[50]. for (I=0. /* Déplacer les éléments plus grands que */ /* VAL d'une position vers l'arrière. &A[I]).h> main() { /* Déclarations */ int A[50]. /* dimension */ int I. I<N.50) : "). /* tableau donné */ int VAL. /* Nouvelle dimension du tableau ! */ N++. /* dimension int I. /* indice courant */ /* Saisie des données */ printf("Dimension du tableau (max. (I>0)&&(A[I-1]>VAL) . &N ). /* indice courant */ */ */ */ /* Saisie des données */ printf("Dimension N du tableau initial (max. return 0. printf("\n"). scanf("%d". I++) { printf("Elément %d : ". */ A[I]=VAL. scanf("%d". */ for (I=N . &N ). #include <stdio. printf("\n"). I<N. /* valeur à insérer int N.

/* indice courant */ int INF. I++) printf("%d ". MIL. POS). scanf("%d". /* position de la valeur */ int N. return 0. scanf("%d". /* tableau donné */ int VAL. I<N. /* limites du champ de recherche */ /* Saisie des données */ printf("Dimension du tableau (max. /* Recherche de la position de la valeur */ POS = -1. &A[I]). /* Edition du résultat */ if (POS==-1) printf("La valeur recherchée ne se trouve pas " "dans le tableau. scanf("%d". /* Affichage du tableau */ printf("Tableau donné : \n"). &N ). I). /* valeur à rechercher */ int POS. scanf("%d". printf("\n"). /* Recherche de la position de la valeur */ 84 WAFAE SABBAR . SUP=N-1.\n"). I<N. I++) printf("%d ". scanf("%d". } printf("Elément à rechercher : "). I++) { printf("Elément %d : ". for (I=0. VAL. I<N. (I<N)&&(POS==-1) . } b) La recherche dichotomique ('recherche binaire'. } printf("Elément à rechercher : "). &VAL ). /* dimension */ int I. I). &VAL ).h> main() { /* Déclarations */ int A[50]. 'binary search') #include <stdio. &A[I]). /* Initialisation des limites du domaine de recherche */ INF=0. for (I=0. for (I=0 . else printf("La valeur %d se trouve à la position %d. I++) { printf("Elément %d : ".50) : "). I<N. I++) if (A[I]==VAL) POS=I. A[I]). /* Affichage du tableau */ printf("Tableau donné : \n"). for (I=0. printf("\n"). A[I]). \n".for (I=0. SUP.

int IA.13 Fusion de deux tableaux triés #include <stdio. else if (VAL > A[MIL]) INF=MIL+1. Ainsi. Lors de la recherche dans un tableau de 1 048 576 éléments: . on élimine la moitié des éléments du tableau à chaque exécution de la boucle. FUS[100]. . Exercice 6. POS). .h> main() { /* Déclarations */ /* Les tableaux et leurs dimensions */ int A[50].le pire des cas pour la recherche séquentielle peut entraîner 1024 exécutions de la boucle. IFUS. La recherche dichotomique devient extrêmement avantageuse pour la recherche dans de grands tableaux (triés) : L'avantage de la recherche dichotomique par rapport à la recherche séquentielle monte alors exponentiellement avec la grandeur du tableau à trier. while ((INF<=SUP) && (POS==-1)) { MIL=(SUP+INF)/2. B[50].le pire des cas pour la recherche dichotomique peut entraîner 10 exécutions de la boucle.POS=-1. return 0. Exemple: Lors de la recherche dans un tableau de 1024 éléments: . else POS=MIL. Lors de la recherche dichotomique. /* indices courants */ 85 WAFAE SABBAR . il faut traverser tout le tableau avant de trouver la valeur ou avant d'être sûr qu'une valeur ne se trouve pas dans le tableau. VAL. if (VAL < A[MIL]) SUP=MIL-1. la recherche se termine beaucoup plus rapidement. IB. \n". M.le pire des cas pour la recherche dichotomique peut entraîner 20 exécutions de la boucle. } Question: Quel est l'avantage de la recherche dichotomique? Dans le pire des cas d'une recherche séquentielle.le pire des cas pour la recherche séquentielle peut entraîner 1 048 576 exécutions de la boucle. else printf("La valeur %d se trouve à la position %d.\n"). } /* Edition du résultat */ if (POS==-1) printf("La valeur recherchée ne se trouve pas " "dans le tableau. int N.

IA++. */ IA=0. (max. IB<M. IA<N. IFUS++. A dans l'ordre croissant :\n"). IB<M. printf("Tableau B :\n"). } /* Si IA ou IB sont arrivés à la fin de leur tableau. IFUS=0./* Saisie des données */ printf("Dimension du tableau A scanf("%d". B dans l'ordre croissant :\n").50) : "). printf("Entrer les éléments de for (IB=0. &M ). &N ). } /* Edition du résultat */ 86 WAFAE SABBAR . printf("\n"). IFUS++. */ /* alors copier le reste de l'autre tableau. IFUS++. */ while (IA<N) { FUS[IFUS]=A[IA]. scanf("%d". IA++. } printf("Dimension du tableau B scanf("%d". while ((IA<N) && (IB<M)) if(A[IA]<B[IB]) { FUS[IFUS]=A[IA].50) : "). IA<N. } /* Affichage des tableaux A et printf("Tableau A :\n"). IFUS++. IA++) printf("%d ". IB++. IB++) { printf("Elément B[%d] : ". } while (IB<M) { FUS[IFUS]=B[IB]. A[IA]). IB). printf("Entrer les éléments de for (IA=0. &A[IA]). scanf("%d". B[IB]). (max. printf("\n"). IB++. for (IA=0. &B[IB]). IB++) printf("%d ". for (IB=0. } else { FUS[IFUS]=B[IB]. IA). IB=0. IA++) { printf("Elément A[%d] : ". B */ /* Fusion des éléments de A et B dans FUS */ /* de façon à ce que FUS soit aussi trié.

for (IFUS=0. /* rang à partir duquel A n'est pas trié */ int J. &A[J]). } Exercice 6.h> main() { /* Déclarations */ int A[50]. printf("\n"). A[J]). IFUS<N+M. J<N. J). } /* Edition du résultat */ printf("Tableau trié :\n"). J++) if (A[J]>A[PMAX]) PMAX=J. printf("\n").50) : "). /* Tri du tableau par sélection directe du maximum.printf("Tableau FUS :\n"). A[J]). J++) { printf("Elément %d : ". J++) printf("%d ". J<N. A[I]=A[PMAX]. J<N. printf("\n"). return 0. J<N. for (J=0. I++) { /* Recherche du maximum à droite de A[I] */ PMAX=I. A[PMAX]=AIDE. for (J=0. I<N-1. } /* Affichage du tableau */ printf("Tableau donné :\n"). */ for (I=0. &N ). IFUS++) printf("%d ". J++) printf("%d ". scanf("%d". /* indique la position de l'élément */ /* maximal à droite de A[I] */ /* Saisie des données */ printf("Dimension du tableau (max. } Exercice 6. for (J=0. /* dimension */ int I. /* indice courant */ int AIDE. scanf("%d". FUS[IFUS]).15 Tri par propagation (bubble sort) #include <stdio. /* tableau donné */ int N. return 0.h> main() 87 WAFAE SABBAR . /* Echange de A[I] avec le maximum */ AIDE=A[I].14 Tri par sélection du maximum #include <stdio. /* pour la permutation */ int PMAX. for (J=I+1.

I=FIN) { FIN=0. J++) if (A[J]>A[J+1]) { FIN=J. /* Tri du tableau par propagation de l'élément maximal. /* tableau des points */ tableau des notes */ nombre d'élèves */ compteurs d'aide */ somme des points */ maximum. J<N. for (J=0. /* int MAXN. return 0. &A[J]). /* indice courant */ int AIDE. A[J+1]=AIDE.{ /* Déclarations */ int A[50]. J<N. */ /* Saisie des données */ printf("Dimension du tableau (max. /* int N. scanf("%d". A[J]). } } /* Edition du résultat */ printf("Tableau trié :\n"). for (J=0. J<N. MIN. scanf("%d". /* tableau donné */ int N. printf("\n").h> main() { int POINTS[50]. J<I. /* int MAX.16 Statistique des notes #include <stdio. /* dimension */ int I. /* int SOM.50) : "). } /* Affichage du tableau */ printf("Tableau donné :\n"). AIDE=A[J]. printf("\n"). A[J]). /* rang à partir duquel A est trié */ int J. for (J=0. /* int NOTES[7]. IN. */ /* permet de ne pas trier un sous-ensemble déjà trié. J++) { printf("Elément %d : ". A[J]=A[J+1]. /* position où la dernière permutation a eu lieu. /* pour la permutation */ int FIN. minimum de points */ nombre de lignes du graphique */ 88 WAFAE SABBAR . for (J=0. &N ). I>0 . */ for (I=N-1 . J++) printf("%d ". J++) printf("%d ". /* int I. } Exercice 6. J).

/* Recherche du maximum MAXN dans NOTES */ for (MAXN=0. /* Calcul et affichage de la moyenne des points */ for (SOM=0.IN=0 . if (POINTS[I] < MIN) MIN=POINTS[I]. I<N . printf("La note minimale est %d \n". I>0. printf("\n I 0 . I++) NOTES[POINTS[I]/10]++. return 0. for (IN=0. IN<7. IN++) if (NOTES[IN] > MAXN) MAXN = NOTES[IN].50) : "). (float)SOM/N). I). else printf(" "). } Exercice 6. /* Etablissement du tableau NOTES */ for (IN=0 .9 I 10-19 I 20-29 " "I 30-39 I 40-49 I 50-59 I 60 I\n"). &N). I++) {if (POINTS[I] > MAX) MAX=POINTS[I]. IN++) { if (NOTES[IN]>=I) printf(" #######"). I<N. } printf("La note maximale est %d \n". } printf("\n"). MIN=60. I++) {printf("Elève %d:"./* Saisie des données */ printf("Entrez le nombre d'élèves (max. MIN). printf("Entrez les points des élèves:\n"). scanf("%d". for (IN=0. } } /* Affichage du domaine des notes */ printf("\n +"). /* Calcul et affichage du maximum et du minimum des points */ for (MAX=0. IN<7. IN<7 .h> 89 WAFAE SABBAR . printf("La moyenne des notes est %f \n". &POINTS[I]). I<N. IN++) NOTES[IN] = 0. I--) { printf("\n %2d >".I=0 . MAX). I++) SOM += POINTS[I]. I<N. for (I=0. IN++) printf("-------+"). /* Affichage du graphique de barreaux */ /* Représentation de MAXN lignes */ for (I=MAXN. IN<7 . I=0. scanf("%d". for (I=0.17 Mise à zéro de la diagonale principale d'une matrice #include <stdio. I+1).

printf("\n"). A[I][J]). for (I=0. /* matrice unitaire */ int N. I<N. J++) if (I==J) U[I][J]=1. J. &N). &N). scanf("%d". 90 WAFAE SABBAR . &A[I][J]). J++) printf("%7d".50) : ").h> main() { /* Déclarations */ int U[50][50]. I<N. } /* Affichage de la matrice */ printf("Matrice donnée :\n").18 Matrice unitaire #include <stdio. J<N. /* indices courants */ /* Saisie des données */ printf("Dimension de la matrice carrée (max. J++) printf("%7d". I++) for (J=0. } return 0.I. /* Construction de la matrice carrée unitaire */ for (I=0. scanf("%d". J<N. printf("\n"). } /* Mise à zéro de la diagonale principale */ for (I=0. /* indices courants */ /* Saisie des données */ printf("Dimension de la matrice carrée (max. /* matrice carrée */ int N. J. I++) for (J=0. /* Edition du résultat */ printf("Matrice résultat :\n").main() { /* Déclarations */ int A[50][50]. I<N. for (I=0. J<N. J<N. A[I][J]). scanf("%d". I++) A[I][I]=0. I<N. J++) { printf("Elément[%d][%d] : ". /* dimension de la matrice unitaire */ int I.50) : "). } Exercice 6. I++) { for (J=0.J). /* dimension de la matrice carrée */ int I. I++) { for (J=0. I<N. for (I=0.

else U[I][J]=0.h> main() { /* Déclarations */ int A[50][50]. I<N. /* int N. for (I=0.50) : "). #include <stdio. &A[I][J]). J++) printf("%7d". A[I][J]). &N ).19 Transposition d'une matrice a) La matrice transposée sera mémorisée dans une deuxième matrice B qui sera ensuite affichée. J<N. I++) { for (J=0. N). for (I=0. J<M. 91 WAFAE SABBAR . printf("\n"). &M ). I++) { for (J=0. /* Edition du résultat */ printf("Matrice unitaire de dimension %d :\n". I<N. printf("\n"). } return 0.50) : "). J. peut être simplifiée par: U[I][J] = (I==J). scanf("%d". /* matrice initiale */ matrice résultat */ dimensions des matrices */ indices courants */ /* Saisie des données */ printf("Nombre de lignes (max. scanf("%d".I. printf("Nombre de colonnes (max. J++) printf("%7d".else U[I][J]=0. } Remarque: L'opération: if (I==J) U[I][J]=1. /* int I. J++) { printf("Elément[%d][%d] : ". M. for (I=0. /* int B[50][50]. U[I][J]).J). scanf("%d". J<M. I++) for (J=0. } /* Affichage de la matrice */ printf("Matrice donnée :\n"). Exercice 6. I<N.

printf("Nombre de colonnes (max.} /* Affectation de la matrice transposée à B */ for (I=0. */ printf("Matrice résultat :\n"). scanf("%d". I++) { for (J=0. J++) printf("%7d". M. } 92 WAFAE SABBAR . &A[I][J]). /* Edition du résultat */ /* Attention: maintenant le rôle de N et M est inversé. J++) printf("%7d". */ DMAX = (N>M) ? N : M. I++) for (J=0. scanf("%d".I. J<M. I<N. I<DMAX. for (I=0. printf("\n"). /* int N. I<M. I<N. I<N.h> main() { /* Déclarations */ int A[50][50]. I++) { for (J=0. /* int DMAX. for (I=0. for (I=0. for (I=0. J. } return 0. printf("\n"). B[I][J]). /* int I.J). J<M.50) : "). J<I. } /* Transposition de la matrice A par permutation des */ /* éléments [I][J] à gauche de la diagonale principale */ /* avec les éléments [J][I] à droite de la diagonale. J++) { AIDE = A[I][J]. /* int AIDE. } b) La matrice A sera transposée par permutation des éléments. /* matrice donnée */ dimensions de la matrice */ indices courants */ pour la permutation */ la plus grande des deux dimensions */ /* Saisie des données */ printf("Nombre de lignes (max. &N ). J<M. J++) B[J][I]=A[I][J]. J++) { printf("Elément[%d][%d] : ". J<N. &M ). } /* Affichage de la matrice */ printf("Matrice donnée :\n"). A[I][J] = A[J][I]. I++) for (J=0. #include <stdio. A[J][I] = AIDE. scanf("%d".50) : "). I++) for (J=0. A[I][J]).

I++) for (J=0. J<M. J<M. &X ). J.I. A[I][J]). &A[I][J]). I++) { for (J=0. &N ). } /* Affectation du résultat de la multiplication à B */ for (I=0. /* multiplicateur */ /* Saisie des données */ printf("Nombre de lignes (max. printf("Nombre de colonnes (max. scanf("%f". M. I<M. I<N. J++) printf("%7d". J<M./* Edition du résultat */ /* Attention: maintenant le rôle de N et M est inversé.h> main() { /* Déclarations */ float A[50][50]. /* indices courants */ float X. I<N. A[I][J]). J++) printf("%10. printf("\n"). I++) for (J=0. /* matrice résultat */ int N. } Exercice 6. */ printf("Matrice résultat :\n"). J++) B[I][J] = X*A[I][J]. /* Affichage de la matrice */ printf("Matrice donnée :\n"). for (I=0. J<M. } 93 WAFAE SABBAR . I<N.20 Multiplication d'une matrice par un réel a) Le résultat de la multiplication sera mémorisé dans une deuxième matrice A qui sera ensuite affichée. scanf("%f". /* matrice donnée */ float B[50][50]. J++) { printf("Elément[%d][%d] : ". B[I][J]). J++) printf("%10. J<N. I<N. for (I=0. I++) { for (J=0.50) : "). for (I=0. /* dimensions des matrices */ int I. scanf("%d". scanf("%d".50) : "). } return 0. #include <stdio. for (I=0. } printf("Multiplicateur X : ").2f".J). printf("\n"). printf("\n"). /* Edition du résultat */ printf("Matrice résultat :\n").2f". &M ). I++) { for (J=0.

scanf("%d". I++) for (J=0. I<N.h> main() { /* Déclarations */ 94 WAFAE SABBAR . /* matrice donnée */ dimensions de la matrice */ indices courants */ multiplicateur */ /* Saisie des données */ printf("Nombre de lignes (max.h> main() { /* Déclarations */ float A[50][50]. /* Affichage de la matrice */ printf("Matrice donnée :\n"). printf("\n"). J++) printf("%10. I++) for (J=0. /* Edition du résultat */ printf("Matrice résultat :\n"). /* int N. J<M. &X). } /* Multiplication des éléments de A par X */ for (I=0. A[I][J]).21 Addition de deux matrices a) Le résultat de l'addition sera mémorisé dans une troisième matrice C qui sera ensuite affichée. for (I=0. } return 0. scanf("%d". I++) { for (J=0. J++) A[I][J] *= X. for (I=0.50) : "). &A[I][J]).50) : "). #include <stdio. A[I][J]).2f". I++) { for (J=0. } b) Les éléments de la matrice A seront multipliés par X. J<M. I<N. } Exercice 6.2f". scanf("%f". J++) printf("%10.J). for (I=0. #include <stdio. J.return 0. } printf("Multiplicateur X : "). J<M. /* float X. printf("\n"). J++) { printf("Elément[%d][%d] : ". scanf("%f".I. &M ). I<N. J<M. /* int I. I<N. M. &N ). printf("Nombre de colonnes (max.

J<M. I<N. J<M. I<N. &B[I][J]). for (I=0. B[50][50]. scanf("%d".int int int int int A[50][50]. A[I][J]). J<M. I++) for (J=0. I. } printf("Matrice donnée B :\n"). J. for (I=0. J++) C[I][J] = A[I][J]+B[I][J]. J++) { printf("Elément[%d][%d] : ". I++) { for (J=0. printf("\n"). for (I=0. printf("*** Matrice A ***\n").J). I<N.h> 95 WAFAE SABBAR . M. printf("\n"). J++) printf("%7d". #include <stdio. /* Edition du résultat */ printf("Matrice résultat C :\n"). for (I=0. I++) { for (J=0. scanf("%d". I<N.50) : "). N. } b) La matrice B est ajoutée à A. &A[I][J]). J++) printf("%7d". scanf("%d". for (I=0. I<N. &N ). J++) { printf("Elément[%d][%d] : ". printf("Nombre de colonnes (max.J). scanf("%d". J<M. I++) { for (J=0. } /* Affectation du résultat de l'addition à C */ for (I=0. } return 0. B[I][J]). I<N. /* /* /* /* /* matrice donnée */ matrice donnée */ matrice résultat */ dimensions des matrices */ indices courants */ /* Saisie des données */ printf("Nombre de lignes (max. J++) printf("%7d". I++) for (J=0. &M ).I. C[50][50]. C[I][J]).I.50) : "). J<M. printf("\n"). } /* Affichage des matrices */ printf("Matrice donnée A :\n"). } printf("*** Matrice B ***\n"). J<M. I++) for (J=0.

J). J<M. } return 0. } printf("Matrice donnée B :\n"). J<M. J. I<N. for (I=0. I<N.I. I<N. scanf("%d". &N ). B[I][J]). } /* Addition de B à A */ for (I=0.main() { /* Déclarations */ int A[50][50]. for (I=0. I++) for (J=0. } 96 WAFAE SABBAR . } /* Affichage des matrices */ printf("Matrice donnée A :\n"). I++) for (J=0. A[I][J]). /* matrice donnée */ int N. for (I=0. for (I=0. /* dimensions des matrices */ int I. I++) { for (J=0. /* Edition du résultat */ printf("Matrice résultat A :\n").50) : "). for (I=0. J++) printf("%7d". &A[I][J]).50) : "). printf("\n"). J++) { printf("Elément[%d][%d] : ". scanf("%d". J++) printf("%7d".J). J++) A[I][J] += B[I][J]. /* indices courants */ /* Saisie des données */ printf("Nombre de lignes (max. I++) { for (J=0. J<M. printf("*** Matrice A ***\n"). J++) { printf("Elément[%d][%d] : ". /* matrice donnée et résultat */ int B[50][50]. J++) printf("%7d". scanf("%d".I. M. A[I][J]). } printf("*** Matrice B ***\n"). J<M. scanf("%d". printf("\n"). J<M. I++) for (J=0. I<N. I++) { for (J=0. &M ). &B[I][J]). printf("Nombre de colonnes (max. I<N. J<M. printf("\n"). I<N.

J). I<M.I.50) : "). I++) for (J=0.22 Multiplication de deux matrices #include <stdio. P. J++) printf("%7d". for (I=0. J<M. J++) { C[I][J]=0. J++) { printf("Elément[%d][%d] : ". J<M. J<P. &N ). /* matrice résultat */ int N. K<M. printf("Nombre de colonnes de B (max. I++) { for (J=0. K. M.50) : "). printf("Nombre de lignes de B : %d\n". J++) { printf("Elément[%d][%d] : ". for (I=0. I++) { for (J=0. scanf("%d". I++) for (J=0. /* matrice donnée */ int B[50][50]. &P ). I<N. &A[I][J]). I<N. J++) printf("%7d". J<P. printf("Nombre de colonnes de A (max. for (K=0. B[I][J]). scanf("%d".50) : ").h> main() { /* Déclarations */ int A[50][50]. &M ). J. } /* Edition du résultat */ printf("Matrice résultat C :\n"). J<P. /* indices courants */ /* Saisie des données */ printf("*** Matrice A ***\n"). printf("\n"). &B[I][J]). K++) C[I][J] += A[I][K]*B[K][J]. I<M. printf("Nombre de lignes de A (max. printf("\n"). scanf("%d". } printf("*** Matrice B ***\n"). } printf("Matrice donnée B :\n"). A[I][J]). } /* Affichage des matrices */ printf("Matrice donnée A :\n").Exercice 6. M). I<N. /* dimensions des matrices */ int I. I++) for (J=0. scanf("%d". } /* Affectation du résultat de la multiplication à C */ for (I=0. for (I=0.J). /* matrice donnée */ int C[50][50]. for (I=0. scanf("%d".I. 97 WAFAE SABBAR .

printf("\n").for (I=0. P[I][0]=1. } return 0.13) : "). N). } Exercice 6. I<=N. /* indices courants */ int AIDE. I++) { for (J=0. J. J<I. for (J=1.h> main() { /* Déclarations */ int P[14][14]./* matrice indiquant les maxima des lignes */ int MIN[50][50].23 Triangle de Pascal #include <stdio. M. } Exercice 6. } /* Edition du résultat */ printf("Triangle de Pascal de degré %d :\n". I++) { P[I][I]=1. I). P[I][J]). printf("\n"). */ for (I=0. /* matrice résultat */ int N. for (J=0. I++) { printf(" N=%2d". } return 0. /* Construction des lignes 0 à N du triangle: */ /* Calcul des composantes du triangle jusqu'à */ /* la diagonale principale. C[I][J]). J<=I. scanf("%d". &N)./* matrice indiquant les minima des colonnes */ int N. /* indices courants */ /* Saisie des données */ do { printf("Entrez le degré N du triangle (max. /* compteur des points-cols */ 98 WAFAE SABBAR . for (I=0. J<P. J++) if (P[I][J]) printf("%5d". J++) P[I][J] = P[I-1][J] + P[I-1][J-1]. J. /* dimensions des matrices */ int I. I<N. /* pour la détection des extréma */ int C. I<=N. J++) printf("%7d". } while (N>13||N<0). /* matrice donnée */ int MAX[50][50].h> main() { /* Déclarations */ int A[50][50]. /* degré du triangle */ int I.24 Recherche de 'points-cols' #include <stdio.

&A[I][J]). for (J=1. J<M. &N ). scanf("%d". I++) for (J=0.cols :\n"). J++) { /* Recherche du minimum sur la colonne J */ AIDE=A[0][J]. /* Marquage de tous les minima sur la colonne J */ for (I=0. J<M. I<N. } /* Edition du résultat */ /* Les composantes qui sont marquées comme extréma */ /* dans MAX et dans MIN sont des points-cols. J<M. J++) */ */ */ */ 99 WAFAE SABBAR ./* Saisie des données */ printf("Nombre de lignes (max. J++) { printf("Elément[%d][%d] : ". printf("Nombre de colonnes (max. J++) if (A[I][J]>AIDE) AIDE=A[I][J]. for (C=0. J<M. I<N. I<N. I<N.J). */ for (I=0. J++) if (A[I][J]==AIDE) /* ou bien : MAX[I][J]=1. J++) printf("%7d".I. scanf("%d". } /* Construction de la matrice d'aide MIN */ /* qui indique les positions de tous les */ /* minima sur une colonne. */ printf("Points . I++) for (J=0. /* MAX[I][J] = (A[I][J]==AIDE) else MAX[I][J]=0. A[I][J]). J<M. I++) if (A[I][J]<AIDE) AIDE=A[I][J]. scanf("%d".50) : "). printf("\n"). J<M. /* Marquage de tous les maxima sur la ligne */ for (J=0. */ for (J=0. I<N. I++) { for (J=0. for (I=0. I=0. for (I=0. /* MIN[I][J] = (A[I][J]==AIDE) else MIN[I][J]=0. for (I=1. } /* Construction de la matrice d'aide MAX */ /* qui indique les positions de tous les */ /* maxima sur une ligne. I++) if (A[I][J]==AIDE) /* ou bien : MIN[I][J]=1. &M ). I++) { /* Recherche du maximum sur la ligne I */ AIDE=A[I][0]. } /* Affichage de la matrice */ printf("Matrice donnée :\n"). I<N.50) : ").

return 0.if (MAX[I][J]&&MIN[I][J]) { C++. I. J). printf("L'élément %d\test un maximum " "sur la ligne %d\n" " \t et un minimum " "sur la colonne %d\n".\n"). } 100 WAFAE SABBAR . A[I][J]. } if (C==0) printf("Le tableau ne contient pas de points-cols.

LES CHAÎNES DE CARACTÈRES Exercice 7. Espace: 2 octets e) char e[5] = "cinq".1. ou mieux: char b[] = "un deux trois".7 . Correction: char c[] = "abcdefg". Déclaration incorrecte: Il faut utiliser une liste de caractères ou une chaîne pour l'initialisation Correction: char d[10] = {'x'. Déclaration correcte Espace: 23 octets g) char g[2] = {'a'. '\0'} ou mieux: char d[10] = "x". pour initialiser avec une chaîne de caractères. Déclaration incorrecte: Les symboles '' encadrent des caractères. Espace: 8 octets d) char d[10] = 'x'. Déclaration correcte Espace: 5 octets f) char f[] = "Cette " "phrase" "est coupée". 101 WAFAE SABBAR . '\0'}. Espace: 14 octets c) char c[] = 'abcdefg'. Correction: char b[14] = "un deux trois". Déclaration correcte Espace: 15 octets b) char b[12] = "un deux trois". a) char a[] = "un\ndeux\ntrois\n". Déclaration incorrecte: la chaîne d'initialisation dépasse le bloc de mémoire réservé. il faut utiliser les guillemets (ou indiquer une liste de caractères).

il faut aussi indiquer le symbole de fin de chaîne. 'c'}. printf("Entrez 5 mots.M5. 'o'.h> main() { /* Déclarations */ char TXT[201]. scanf ("%s %s %s %s %s". /* compteur des lettres 'e' */ int AIDE. /* L'utilisation de scanf est impossible pour */ /* lire une phrase contenant un nombre variable de mots. M5).J. printf("Le texte contient %d lettres \'e\'. 'c'.2 #include <stdio. 102 WAFAE SABBAR . return 0. Déclaration correcte. TXT[I]. M1. I++) if (TXT[I]=='e') C++. /* indices courants */ int L. mais d'une chaîne contenant les caractères '\''. /* pour l'échange des caractères */ /* Saisie des données */ printf("Entrez une ligne de texte (max. Correction: char h[4] = {'a'. M4. '\0'}. M4. gets(TXT). /* longueur de la chaîne */ int C. */ for (L=0. L++) . } Exercice 7. 'b'. Déclaration incorrecte: Dans une liste de caractères. TXT[L].C).L). Espace: 4 octets Exercice 7. /* chaîne donnée */ int I. M2[30]. printf("Le texte est composé de %d caractères. M1). Espace: 4 octets i) char i[4] = "'o'". printf("%s %s %s %s %s\n". M3. '\'' et '\0'. for (I=0. /* b) Compter les lettres 'e' dans le texte */ C=0. M5[30]. M3[30].200 caractères) :\n"). M3.\n". */ /* a) Compter les caractères */ /* La marque de fin de chaîne '\0' est */ /* utilisée comme condition d'arrêt. M4[30]. M2.\n". 'b'.h> main() { char M1[30]. séparés par des espaces :\n"). M2.Déclaration correcte Espace: 2 octets h) char h[4] = {'a'.3 #include <stdio.

} Exercice 7. strlen(NOM) + strlen(PRENOM)). PRENOM). } puts(TXT). I<J . } Exercice 7. TXT[I] . /* indices courants */ /* Saisie des données */ printf("Entrez une ligne de texte (max. if (TXT[I] != 'e') J++. */ /* d) Inverser l'ordre des caractères */ for (I=0. */ 103 WAFAE SABBAR . PRENOM[40]. /* Eliminer les lettres 'e' et comprimer : */ /* Copier les caractères de I vers J et incrémenter J */ /* seulement pour les caractères différents de 'e'. */ return 0. I++. TXT[J]=AIDE.TXT).5 #include <stdio. strlen(strcat(NOM.\n". I++) { TXT[J] = TXT[I]. */ for (J=0. TXT[I]=TXT[J]. /* ou bien printf("Votre nom est composé de %d lettres.\n". I>=0.h> main() { /* Déclarations */ char TXT[201].TXT[I]).4 #include <stdio. PRENOM). gets(TXT)./* c) Afficher la phrase à l'envers */ for (I=L-1.PRENOM))).h> #include <string. /* ou printf("%s\n". /* ou printf("\n"). NOM. NOM.J--) { AIDE=TXT[I]. return 0. scanf("%s %s".I=0 . /* ou printf("%c". printf("Votre nom est composé de %d lettres. /* Edition du résultat */ puts(TXT). */ putchar('\n'). I--) putchar(TXT[I]).J=L-1 .J. printf("\nBonjour %s %s !\n". } /* Terminer la chaîne !! */ TXT[J]='\0'.200 caractères) :\n").h> main() { char NOM[40]. /* chaîne donnée */ int I. printf("Introduisez votre nom et votre prénom: \n").

return 0. CH2[100]. CH1. gets(CH2). CH1. /* résultat de la fonction strcmp */ printf("Introduisez la première chaîne de caractères : ").CH1. gets(CH2).CH2).6 #include <stdlib.h> #include <string.7 a) Utiliser les fonctions spéciales de <string>. return 0. CH3). CH2). /* chaînes entrées */ int RES.CH1 . strlen(CH2)/2).CH2).CH2 . strlen(CH1)/2).return 0. #include <stdio. CH2. else if (RES>0) printf("\"%s\" précède \"%s\"\n".h> main() { /* Déclarations */ char CH1[200]. else printf("\"%s\" est égal à \"%s\"\n".CH1). printf("Introduisez la deuxième chaîne de caractères : "). } Exercice 7. } Exercice 7. if (RES<0) printf("\"%s\" précède \"%s\"\n". gets(CH1). /* chaînes données */ char CH3[100]="". /* Traitements */ strncpy(CH3. CH2. CH2[200].h> #include <string. /* Comparaison et affichage du résultat */ RES = strcmp(CH1. gets(CH1). /* Affichage du résultat */ printf("Un demi \"%s\" plus un demi \"%s\" donne \"%s\"\n". strncat(CH3. } b) Utiliser uniquement les fonctions gets et puts.h> main() { /* Déclarations */ char CH1[100]. 104 WAFAE SABBAR . /* chaîne résultat */ /* Saisie des données */ printf("Introduisez la première chaîne de caractères : "). printf("Introduisez la deuxième chaîne de caractères : ").

L1++) . /* longueur de la chaîne */ /* Saisie des données */ printf("Verbe : "). /* chaîne contenant le verbe */ char AFFI[30]. /* Copier la première moitié de CH1 vers CH3 */ for (I=0 .8 #include <stdio. CH2[100]. gets(CH1).h> main() { /* Déclarations */ char CH1[100]. else 105 WAFAE SABBAR . gets(CH2). } /* Terminer la chaîne CH3 */ CH3[J]='\0'. /* Détermination les longueurs de CH1 et CH2 */ for (L1=0. CH1[L1].!"). CH2[L2]. puts(CH3). I++) { CH3[J]=CH2[I]. for (L2=0.h> main() { /* Déclarations */ char VERB[20]. /* chaînes données char CH3[100]="". /* indice courant dans CH3 */ */ */ */ */ /* Saisie des données */ puts("Introduisez la première chaîne de caractères : "). /* Copier la première moitié de CH2 vers CH3 */ J=I. if ((VERB[L-2]!='e') || (VERB[L-1]!='r')) puts("\aCe n'est pas un verbe du premier groupe.L2. I++) CH3[I]=CH1[I].h> #include <string. /* Affichage du résultat */ puts("Chaîne résultat : "). I<(L1/2) . /* chaîne pour l'affichage */ int L. J++. /* Contrôler s'il s'agit d'un verbe en 'er' */ L=strlen(VERB). for (I=0 . } Exercice 7. L2++) . /* chaîne résultat int L1. /* longueurs de CH1 et CH2 int I. gets(VERB). /* indice courant dans CH1 et CH2 int J.#include <stdio. return 0. puts("Introduisez la deuxième chaîne de caractères : "). I<(L2/2) .

ltoa(N.000000 1.000000 1234.123 d) 123. STR.45 12000. printf("base 8 = %s\n". printf("base 2 = %s\n".h> main() { long N. strcat(AFFI.h> #include <stdlib. ltoa(N. strcat(AFFI. 8)).000000 h) 123e-02 123 i) -0. return 0.{ /* Couper la terminaison 'er'.230000 -0. . VERB). N).000000 -123. STR. "ent"). "ils ").1234 0 Exercice 7. */ AFFI[0]='\0'. ltoa(N. VERB). do { puts("Entrez un nombre :"). 2)). */ VERB[L-2]='\0'..9 Entrée: a) 123 b) -123 c) . strcat(AFFI. puts(AFFI).45 e) 12E3 f) 1234f5 integer long double 123 -123 0 123 12 1234 123 -123 0 123 12 1234 123 0 123. "e"). puts(AFFI). strcat(AFFI. } 106 WAFAE SABBAR .000000 123. strcat(AFFI. } while(N).123400 g) -1234567 dépassement -1234567 -1234567. printf("Entrée = %ld\n". } Exercice 7. char STR[200]. . printf("base 16 = %s\n".10 #include <stdio. scanf("%ld". } return 0. STR. .. /* Conjuguer .&N). AFFI[0]='\0'. 16)). strcat(AFFI. "je ").000000 -0.

} /* Edition du résultat */ printf("Tableau trié lexicographiquement :\n"). /* indice courant */ int PMOT. /* nombre entré */ char JOUR[8][9] = {"\aErreur!". /* Saisie du nombre */ printf("Entrez un nombre entre 1 et 7 : ").h> #include <string. */ /* Saisie des données */ for (J=0. AIDE)."dimanche"}.h> main() { /* Déclarations */ char MOT[10][50]. J++) if (strcmp(MOT[J]. 107 WAFAE SABBAR . JOUR[N]).h> main() { /* Déclarations */ int N. "mardi". /* tableau de 10 mots à trier */ char AIDE[50]. /* Echange des mots à l'aide de strcpy */ strcpy(AIDE. J++) { printf("Mot %d : ". /* Affichage du résultat . I<9. */ printf("\n").MOT[J]). J++) puts(MOT[J]). "lundi". MOT[PMOT]) < 0) PMOT=J. } Exercice 7. &N). return 0. MOT[I]). MOT[PMOT]). MOT[J]). for (J=I+1. "vendredi". for (J=0. "samedi". I++) { /* Recherche du prochain mot à droite de A[I] */ PMOT=I. /* chaîne d'aide pour la permutation */ int I. "mercredi".pour perfectionnistes */ if (N>0 && N<8) printf("Le %de%c jour de la semaine est %s. /* rang à partir duquel MOT n'est pas trié */ int J. /* ou : scanf ("%s\n". /* indique la position du prochain mot */ /* dans la suite lexicographique. J<10.11 #include <stdio. */ for (I=0. J<10. N.Exercice 7. J<10.12 #include <stdio. strcpy(MOT[I].\n". */ } /* Tri du tableau par sélection directe du */ /* prochain mot dans la suite lexicographique. gets(MOT[J]). scanf("%d". /* ou : printf("%s\n". "jeudi". (N==1)?'r':' '. J). strcpy(MOT[PMOT].

scanf lit */ /* les 5 données à la fois.VERB). } Exercice 7. /* tableau pour les 5 mots */ int I. /* indice courant */ /* Saisie des données */ printf("Verbe : "). else { /* Couper la terminaison 'er'.. /* Après le retour à la ligne. I++) printf("%s %s%s\n".. I--) printf("%s ". séparés par des espaces :\n"). I<6. return 0. VERB). } return 0.\n"."e".14 #include <stdio. */ VERB[L-2]='\0'."nous"."vous". MOT[I]). I>=0. TERM[I]). /* longueur de la chaîne */ int I."tu"."ez". char TERM[6][5] = {"e". */ for (I=0. I<5. I++) scanf("%s". scanf("%s"."ent"}.h> main() { /* Déclarations */ /* Sujets et terminaisons */ char SUJ[6][5] = {"je". VERB."il". } 108 WAFAE SABBAR .else puts(JOUR[0]). /* chaîne contenant le verbe */ int L. */ for (I=0."es". /* Contrôler s'il s'agit d'un verbe en 'er' */ L=strlen(VERB). /* indice courant */ /* Saisie des mots */ printf("Entrez 5 mots. /* Affichage du résultat */ for (I=4. char VERB[20].SUJ[I]. /* Conjuguer . MOT[I])."ons". } Exercice 7. if ((VERB[L-2] != 'e') || (VERB[L-1] != 'r')) printf("\"%s\" n'est pas un verbe du premier groupe.13 #include <stdio.h> main() { /* Déclarations */ char MOT[5][50]. printf("\n"). return 0.h> #include <string."ils"}.

CH2). I++) . gets(CH). /* Conversion de la chaîne */ for (I=0. } Exercice 7. CH1. else if (CH1[I]<CH2[I]) printf("\"%s\" précède \"%s\"\n". else if (CH[I]>='a' && CH[I]<='z') CH[I] = CH[I]-'a'+'A'.15 #include <stdio. return 0. gets(CH2). I++) { if (CH[I]>='A' && CH[I]<='Z') CH[I] = CH[I]-'A'+'a'. */ for (I=0. CH2.h> main() { /* Déclarations */ char CH1[50]. /* Comparer le premier élément qui */ /* distingue CH1 et CH2. <stdlib> ou <ctype>.h> main() { /* Déclarations */ char CH[100]. } /* Affichage de la chaîne convertie */ printf("Chaîne convertie : %s\n". CH). /* Chercher la première position où */ /* CH1 et CH2 se distinguent. /* indice courant */ /* Saisie des données */ printf("Entrez la première chaîne à comparer : "). gets(CH1). CH1. /* chaînes à comparer */ int I. CH1). /* indice courant */ /* Saisie de la chaîne */ printf("Entrez la chaîne à convertir : "). } 109 WAFAE SABBAR . les exercices suivants sont à résoudre sans utiliser les fonctions spéciales des bibliothèques <string>.Sauf indication contraire. return 0. Ils servent à comprendre et à suivre le raisonnement de ces fonctions.16 #include <stdio. CH2[50]. CH[I]. printf("Entrez la deuxième chaîne à comparer : "). (CH1[I]==CH2[I]) && CH1[I] && CH2[I]. Exercice 7. else printf("\"%s\" précède \"%s\"\n". */ if (CH1[I]==CH2[I]) printf("\"%s\" est égal à \"%s\"\n". /* chaîne à convertir */ int I. CH2).

/* indice courant */ int OK. OK && CH[I].18 #include <stdio. if (isdigit(CH[I])) N = N*16 + (CH[I]-'0'). /* Affichage de la chaîne convertie */ if (OK) printf("Valeur numérique : %ld\n". for (I=0. N).h> main() { /* Déclarations */ char CH[100]. /* indicateur logique précisant si la */ /* chaîne a été convertie avec succès */ /* Saisie de la chaîne */ printf("Entrez un nombre hexadécimal entier et positif : "). } Exercice 7. /* indicateur logique précisant si la */ /* chaîne a été convertie avec succès */ /* Saisie de la chaîne */ printf("Entrez un nombre entier et positif : ").h> #include <ctype. gets(CH). /* résultat numérique */ int I. I++) if (isxdigit(CH[I])) { CH[I] = toupper(CH[I]). /* résultat numérique */ int I.\n". /* chaîne numérique à convertir */ long N. N=0.17 #include <stdio. /* Conversion de la chaîne */ OK=1. else printf("\a\"%s\" ne représente pas correctement " "un entier et positif.h> main() { /* Déclarations */ char CH[100]. /* indice courant */ int OK. CH). /* Conversion de la chaîne */ OK=1. OK && CH[I]. for (I=0. I++) if (isdigit(CH[I])) N = N*10 + (CH[I]-'0').h> #include <ctype. N=0. return 0. gets(CH). else OK=0. /* chaîne numérique à convertir */ long N. else 110 WAFAE SABBAR .Exercice 7.

/* Traitement du point décimal */ if (CH[I]=='. SIG=1. /* Traitement et comptage des décimales */ for (DEC=0. } else OK=0. /* Positions devant le point décimal */ for ( . printf("Valeur numérique décimale : %ld\n". else if (CH[I]) OK=0.0 + (CH[I]-'0').0. gets(CH). return 0.') I++. DEC++) N = N*10. N). isdigit(CH[I]). } Exercice 7. } else printf("\a\"%s\" n'est pas une valeur " "hexadécimale correcte. /* Affichage de la chaîne convertie */ if (OK) { printf("Valeur numérique hexadécimale : %lX\n". I=0. /* chaîne numérique à convertir */ double N. isdigit(CH[I]).\n". /* Traitement du signe */ if (CH[I]=='-') SIG=-1. CH).h> main() { /* Déclarations */ char CH[100]. /* signe de la valeur rationnelle */ int DEC.h> #include <math. /* résultat numérique */ int I.0 + (CH[I]-'0').h> #include <ctype. /* indice courant */ int SIG. /* nombre de décimales */ int OK. /* indicateur logique précisant si la */ /* chaîne a été convertie avec succès */ /* Saisie de la chaîne */ printf("Entrez un nombre rationnel : ").N = N*16 + 10 + (CH[I]-'A'). N). if (CH[I]=='-' || CH[I]=='+') I++.19 #include <stdio. I++) N = N*10. N=0. I++. /* Conversion de la chaîne : */ /* Initialisation des variables */ OK=1. 111 WAFAE SABBAR .

0 + (CH[I]-'0'). if (CH[I]=='-' || CH[I]=='+') I++. /* indicateur logique précisant si la */ /* chaîne a été convertie avec succès */ /* Saisie de la chaîne */ printf("Entrez un nombre rationnel : "). /* Traitement du signe */ if (CH[I]=='-') SIG=-1.(CH[I]) OK=0. /* nombre de décimales */ int SIGE. /* Positions devant le point décimal */ for ( . CH). /* résultat numérique */ int I. /* signe de l'exposant */ int EXP. I++) N = N*10. N=0.h> #include <math. /* Traitement de la marque exponentielle */ if (CH[I]=='e'||CH[I]=='E') I++. isdigit(CH[I]). I++. gets(CH). } if /* /* N /* if Exercice 7.h> #include <ctype. Calcul de la valeur à partir du signe et */ du nombre de décimales. /* Traitement du point décimal */ if (CH[I]=='.20 #include <stdio.\n". SIGE=1. Affichage de la chaîne convertie */ (OK) printf("Valeur numérique : %f\n".DEC). /* chaîne numérique à convertir */ double N. */ = SIG*N/pow(10. N). isdigit(CH[I]). /* signe de la valeur rationnelle */ int DEC. DEC++) N = N*10. /* valeur de l'exposant */ int OK. else printf("\a\"%s\" n'est pas une valeur " "rationnelle correcte.0 + (CH[I]-'0'). /* Traitement et comptage des décimales */ for (DEC=0. I=0. /* indice courant */ int SIG. /* Traitement du signe de l'exposant */ 112 WAFAE SABBAR .0. SIG=1.h> main() {/* Déclarations */ char CH[100].') I++. /* Conversion de la chaîne */ /* Initialisation des variables */ OK=1. return 0. else if (CH[I]) OK=0.

gets(SUJ). */ if (SUJ[I]==OBJ[0]) { /* alors comparer le reste de la chaîne */ for (J=1.h> main() { /* Déclarations */ char SUJ[100]. SUJ[I] && !TROUVE. } /* Si la position de départ de OBJ dans SUJ a été trouvée */ /* alors déplacer le reste de SUJ à cette position. gets(OBJ). I++) /* Si la première lettre est identique. /* indice courant dans SUJ */ int J. if (OBJ[J]=='\0') TROUVE=1. de la valeur de l'exposant EXP et */ /* du nombre de positions rationnelles DEC */ EXP = SIGE*EXP .DEC. else printf("\a\"%s\" n'est pas une valeur " "rationnelle correcte. /* Affichage de la chaîne convertie */ if (OK) printf("Valeur numérique : %f\n". isdigit(CH[I]). printf("Introduisez la chaîne à transformer : "). I++) EXP = EXP*10 + (CH[I]-'0').\n". for (I=0. /* Recherche de OBJ dans SUJ */ TROUVE=0. /* chaîne à supprimer dans SUJ */ int I.if (CH[I]=='-') SIGE=-1. /* chaîne à transformer */ char OBJ[100]. /* Traitement de la valeur de l'exposant */ for (EXP=0. */ N = SIG*N*pow(10. return 0. CH). if (CH[I]=='-' || CH[I]=='+') I++. OBJ[J] && (OBJ[J]==SUJ[I+J]). } Exercice 7. /* indicateur logique qui précise */ /* si la chaîne OBJ a été trouvée */ /* Saisie des données */ printf("Introduisez la chaîne à supprimer : "). /* indice courant dans OBJ */ int TROUVE. J++) . /* Calcul de la valeur à partir du signe et */ /* de l'exposant. if (CH[I]) OK=0.EXP). /* Calcul de l'exposant à partir du signe */ /* SIGE.21 #include <stdio. */ if (TROUVE) { I--. /* Maintenant I indique la position de OBJ */ /* dans SUJ et J indique la longueur de OBJ */ 113 WAFAE SABBAR . N).

gets(CH2). gets(CH1). gets(SUJ). printf("Introduisez la chaîne à transformer SUJ : "). K++) FIN[K]=SUJ[K+I+J]. /* chaîne à rechercher */ char CH2[100]. I++) SUJ[I]=SUJ[I+J]. /* indice courant dans SUJ */ int J. /* chaîne de sauvegarde pour */ /* la fin de SUJ. FIN[K]='\0'.22 #include <stdio. /* indice d'aide pour les copies */ int TROUVE. /* indicateur logique qui précise */ /* si la chaîne OBJ a été trouvée */ /* Saisie des données */ printf("Introduisez la chaîne à rechercher CH1 : "). 114 WAFAE SABBAR . CH2[K]. /* indice courant dans CH1 et CH2 */ int K. CH1[J] && (CH1[J]==SUJ[I+J]). */ int I. SUJ[I] && !TROUVE.h> main() { /* Déclarations */ char SUJ[100]. J++) . SUJ). if (CH1[J]=='\0') TROUVE=1. } /* Si CH1 a été trouvée dans SUJ alors sauvegarder la fin */ /* de SUJ dans FIN. /* chaîne de remplacement */ char FIN[100]. I++) if (SUJ[I]==CH1[0]) { for (J=1. SUJ[K+I+J]. return 0.for (. K++. printf("Introduisez la chaîne à remplacer CH2 : "). /* Recherche de CH1 dans SUJ */ TROUVE=0. */ if (TROUVE) { I--. /* Copier CH2 dans SUJ */ for (K=0.I++) SUJ[I]=CH2[K]. for (I=0. SUJ[I]='\0'. } Exercice 7. } /* Affichage du résultat */ printf("Chaîne résultat : \"%s\"\n". /* chaîne à transformer */ char CH1[100]. copier ensuite CH2 et FIN dans SUJ. /* Maintenant I indique la position de CH1 */ /* dans SUJ et J indique la longueur de CH1 */ /* Sauvegarder la fin de SUJ dans FIN */ for (K=0. SUJ[I+J].

return 0. K++) FIN[K]=SUJ[K+I+J].I++) SUJ[I]=FIN[K]. printf("Introduisez la chaîne à remplacer CH2 : "). SUJ[K+I+J]. J++) .h> main() { /* Déclarations */ char SUJ[100]. /* indice courant dans SUJ */ int J. /* Copier CH2 dans SUJ et déplacer */ /* I derrière la copie de CH2. gets(SUJ). /* chaîne de remplacement */ char FIN[100]. /* Terminer la chaîne SUJ */ SUJ[I]='\0'. } Exercice 7. FIN[K]='\0'. K++. gets(CH2). SUJ[I]. CH1[J] && (CH1[J]==SUJ[I+J]). CH2[K]. */ int I. /* chaîne à rechercher */ char CH2[100]. */ for (K=0. gets(CH1). I++) if (SUJ[I]==CH1[0]) { for (J=1. K++) SUJ[I+K]=FIN[K]. FIN[K]. /* chaîne de sauvegarde pour */ /* la fin de SUJ. /* Recherche de CH1 dans SUJ */ for (I=0.23 #include <stdio. if (CH1[J]=='\0') /* TROUVE ! */ { /* Maintenant I indique la position de CH1 */ /* dans SUJ et J indique la longueur de CH1 */ /* Sauvegarder la fin de SUJ dans FIN */ for (K=0. FIN[K]. K++. printf("Introduisez la chaîne à transformer SUJ : ").I++) SUJ[I]=CH2[K]. } /* Affichage du résultat */ printf("Chaîne résultat : \"%s\"\n". /* Recopier FIN dans SUJ */ for (K=0. /* Terminer la chaîne SUJ */ SUJ[I+K]='\0'. /* indice courant dans CH1 et CH2 */ int K./* Recopier FIN dans SUJ */ for (K=0. 115 WAFAE SABBAR . SUJ). /* chaîne à transformer */ char CH1[100]. /* indice d'aide pour les copies */ /* Saisie des données */ printf("Introduisez la chaîne à rechercher CH1 : ").

SUJ). } 116 WAFAE SABBAR .I--. /* réajustement de l'indice I */ } } /* Affichage du résultat */ printf("Chaîne résultat : \"%s\"\n". return 0.

8 . } /* Affichage des tableaux */ printf("Tableau donné A :\n"). A+I). &N ). printf("\n"). P1=&A P2=&C *P1=(*P2)++ P1=P2 P2=&B *P1-=*P2 ++*P2 *P1*=*P2 A=++*P2**P1 P1=&A 1 1 1 3 3 3 3 3 3 B C P1 P2 2 3 / / 2 3 &A / 2 3 &A &C 2 4 &A &C 2 4 &C &C 2 4 &C &B 2 2 &C &B 3 2 &C &B 3 6 &C &B 24 4 6 &C &B 24 4 6 &A &B 6 6 &A &B *P2=*P1/=*P2 6 Exercice 8. I). LES POINTEURS Exercice 8. scanf("%d". B+I). &M ). /* tableaux */ int N. M.2 #include <stdio. I<N. scanf("%d". /* indice courant */ /* Saisie des données */ printf("Dimension du tableau A (max. /* dimensions des tableaux */ int I. 117 WAFAE SABBAR . I++) { printf("Elément %d : ". I++) { printf("Elément %d : ". *(B+I)).50) : "). *(A+I)).1 A Init. for (I=0. printf("Tableau donné B :\n").h> main() { /* Déclarations */ int A[100]. } printf("Dimension du tableau B (max. for (I=0. scanf("%d". I<M. I). I<M. for (I=0. B[50].50) : "). for (I=0. I<N. I++) printf("%d ". scanf("%d". I++) printf("%d ".

} A la fin des boucles. P<A+N . printf("\n"). } } ou les versions analogues avec while. nous utilisons souvent des expressions de la forme: for (P=A . /* Nouvelle dimension de A */ N += M.h> main() { /* Déclarations */ int A[10]. P++) printf("%d ". *P). P<A+10. Dans ces boucles. /* pointeur dans A */ /* Saisie des données */ printf("Introduire 10 entiers : \n"). I<N. le pointeur P est incrémenté à la fin du bloc d'instruction et comparé ensuite à la condition de la boucle.printf("\n").3 Solution: En traitant des tableaux à l'aide de pointeurs. . printf("\n").. P++) ou for (P=CH . I++) printf("%d ". /* tableau */ int *P.4 Soit P un pointeur qui 'pointe' sur un tableau A: 118 WAFAE SABBAR . return 0. plus précisément sur le premier élément derrière le tableau. I++) *(A+N+I) = *(B+I). /* Copie de B à la fin de A */ for (I=0. Exercice 8.. P++) scanf("%d". } Exercice 8. for (P=A. P pointe déjà à l'extérieur du tableau.. P contient l'adresse A+10 et pointe donc sur l'élément A[10] qui ne fait plus partie du tableau. *(A+I)). /* Edition du résultat */ printf("Tableau résultat A :\n"). I<M. for (P=A. *P . Au moment où la condition est remplie. return 0. P<A+10. P). for (I=0. P++) { { .. /* Affichage du tableau */ printf("Tableau donné A :\n"). Exemple: #include <stdio.

int A[] = {12. /* Edition du résultat */ for (P1=A. printf("\n"). return 0. /* dimension du tableau int X. 23. Quelles valeurs ou adresses fournissent ces expressions: a) *P+2 => la valeur 14 b) *(P+2) c) &P+1 d) &A[4]-3 e) A+3 f) &A[7]-P g) P+(*P-10) => la valeur 34 => l'adresse du pointeur derrière le pointeur P (rarement utilisée) => l'adresse de la composante A[1] => l'adresse de la composante A[3] => la valeur (indice) 7 => l'adresse de la composante A[2] h) *(P+*(P+8)-A[7]) => la valeur 23 Exercice 8.50) : "). /* Affichage du tableau */ for (P1=A. P1++) printf("%d ". int *P. 34. P1++) { printf("Elément %d : ". 89. &N ).5 #include <stdio. 45. *P1). P = A. } 119 WAFAE SABBAR . /* tableau donné int N. P1<A+N. } /* Nouvelle dimension de A */ N = P2-A.h> main() { /* Déclarations */ int A[50]. P1++) { *P2 = *P1. P1<A+N. P1). /* pointeurs d'aide */ */ */ */ /* Saisie des données */ printf("Dimension du tableau (max. /* valeur à éliminer int *P1. P1-A). P1<A+N. if (*P2 != X) P2++. P1<A+N. scanf("%d". *P1). 78. &X ). 90}. 56. printf("\n"). for (P1=A. *P2. */ for (P1=P2=A. } printf("Introduire l'élément X à éliminer du tableau : "). /* Effacer toutes les occurrences de X et comprimer : */ /* Copier tous les éléments de P1 vers P2 et augmenter */ /* P2 pour tous les éléments différents de X. 67. scanf("%d". scanf("%d". P1++) printf("%d ".

P1). PB++) { printf("Elément %d : ". scanf("%d". printf("\n"). &N ). *P2 = AIDE.h> main() { /* Déclarations */ int A[50]. P1++) printf("%d ". P1<A+N.h> main() { /* Déclarations */ int A[100].*PB. *P1 = *P2. for (PA=A. 120 WAFAE SABBAR . scanf("%d". /* pointeurs d'aide */ /* Saisie des données */ printf("Dimension du tableau A (max.P2=A+(N-1). } /* Edition du résultat */ for (P1=A. P1++) { printf("Elément %d : ". PB). P1<A+N. /* pointeurs d'aide */ /* Saisie des données */ printf("Dimension du tableau (max. M. /* dimension du tableau */ int AIDE. &N ). for (P1=A. /* tableau donné */ int N. scanf("%d". P1<A+N. &M ). /* tableaux */ int N. return 0. scanf("%d".P2--) { AIDE = *P1.6 #include <stdio.50) : "). scanf("%d".7 #include <stdio. for (PB=B. /* pour la permutation */ int *P1. } /* Affichage du tableau */ for (P1=A. *P1). } Exercice 8. /* dimensions des tableaux */ int *PA. B[50]. /* Inverser la tableau */ for (P1=A. P1-A). } printf("Dimension du tableau B (max. PA<A+N.50) : "). printf("\n"). *P1). PB<B+M. *P2. P1++) printf("%d ". PA++) { printf("Elément %d : ". PA-A). P1++.Exercice 8. scanf("%d". PA). PB-B).50) : "). P1<P2.

for (PB=B. /* Copier B à la fin de A */ for (PA=A+N.\n".J--) if (CH[I] != CH[J]) PALI=0. CH). printf("Tableau donné B :\n"). PB<B+M.} /* Affichage des tableaux */ printf("Tableau donné A :\n"). I++.8 a) en utilisant uniquement le formalisme tableau #include <stdio. /* Affichage du résultat */ if (PALI) printf("La chaîne \"%s\" est un palindrome.PB=B . PA++. /* indices courants */ int PALI. CH[J].\n".PB++) *PA = *PB. PB<B+M . /* Edition du résultat */ printf("Tableau résultat A :\n"). /* chaîne donnée */ int I. printf("\n"). } b) en utilisant des pointeurs au lieu des indices numériques : 121 WAFAE SABBAR . PA++) printf("%d ". *PB). PA<A+N. PB++) printf("%d ". /* Contrôler si CH est un palindrome */ PALI=1. for (I=0 . /* indicateur logique: */ /* vrai si CH est un palindrome */ /* Saisie des données */ printf("Entrez une ligne de texte (max. J++) . CH). printf("\n").100 caractères) :\n"). /* Nouvelle dimension de A */ N += M. PA++) printf("%d ". printf("\n"). J--.h> main() { /* Déclarations */ char CH[101]. for (PA=A. return 0. *PA).J. *PA). /* Placer J sur la dernière lettre de la chaîne */ for(J=0. PALI && I<J . else printf("La chaîne \"%s\" n'est pas un palindrome. gets(CH). for (PA=A. return 0. } Exercice 8. PA<A+N.

else printf("La chaîne \"%s\" n'est pas un palindrome.#include <stdio. /* indicateur logique: */ /* vrai si CH est un palindrome */ /* Saisie des données */ printf("Entrez une ligne de texte (max. *P. gets(CH). } Exercice 8. /* chaîne donnée */ char *P. P1++.\n". return 0. /* chaîne donnée */ char *P1.\n". for (P1=CH . /* Affichage du résultat */ printf("La chaîne \"%s\" est formée de %d caractères. CH).h> main() { /* Déclarations */ char CH[101]. /* Affichage du résultat */ if (PALI) printf("La chaîne \"%s\" est un palindrome. /* chaîne donnée */ char *P. /* Contrôler si CH est un palindrome */ PALI=1. CH).\n". } Exercice 8. P2--. P++) . /* pointeurs d'aide */ int PALI. PALI && P1<P2 . *P2. P2++) . /* Placer P2 sur la dernière lettre de la chaîne */ for (P2=CH. return 0.h> main() { /* Déclarations */ char CH[101]. /* Placer P à la fin de la chaîne */ for (P=CH. gets(CH).*P2.P2--) if (*P1 != *P2) PALI=0.h> main() { /* Déclarations */ char CH[101]. /* pointeur d'aide */ 122 WAFAE SABBAR .h> #include <ctype. /* pointeur d'aide */ /* Saisie des données */ printf("Entrez une ligne de texte (max.10 #include <stdio.100 caractères) :\n").9 #include <stdio. P-CH). CH.100 caractères) :\n").

11 #include <stdio. PABC<ABC+26.h> main() { /* Déclarations */ char CH[101]. PABC++) if (*PABC) printf(" %d\tfois la lettre '%c' \n". /* indicateur logique: */ /* vrai si P pointe à l'intérieur un mot */ /* Saisie des données */ printf("Entrez une ligne de texte (max. else if (!DANS_MOT) { DANS_MOT=1. (N==1)?' ':'s'). gets(CH). /* nombre des mots */ int DANS_MOT. CH). PCH++) { if (*PCH>='A' && *PCH<='Z') (*(ABC+(*PCH-'A')))++. CH. 'A'+(PABC-ABC)). *P. gets(CH).\n". for (PABC=ABC. PABC<ABC+26. /* chaîne donnée */ char *PCH. PABC++) *PABC=0. } /* Affichage du résultat (pour perfectionnistes) */ printf("La chaîne \"%s\" \nest formée de %d mot%c. } Exercice 8. /* Compter les lettres */ for (PCH=CH. *PABC. N++. /* Attention aux parenthèses! */ if (*PCH>='a' && *PCH<='z') (*(ABC+(*PCH-'a')))++.100 caractères) :\n").int N. */ printf("La chaîne \"%s\" contient :\n". /* pointeur d'aide dans CH */ int ABC[26]. /* compteurs des différents caractères */ int *PABC. return 0. /* pointeur d'aide dans ABC */ /* Saisie des données */ printf("Entrez une ligne de texte (max. *PCH. /* Compter les mots */ N=0. return 0. DANS_MOT=0. P++) if (isspace(*P)) DANS_MOT=0.100 caractères) :\n"). /* Initialiser le tableau ABC */ for (PABC=ABC. } /* Affichage des résultats */ /* (PABC-ABC) est le numéro de la lettre de l'alphabet. for (P=CH. } 123 WAFAE SABBAR . N.

while (*P) { if (*P==C) strcpy(P. } Exercice 8. éliminer le caractère de CH1 à */ /* l'aide de strcpy. */ /* Saisie des données */ printf("Entrez la première chaîne de caractères" " (max.100 caractères) :\n"). */ for (P2=CH2. P1++) if (*P2==*P1) { 124 WAFAE SABBAR . /* Comprimer la chaîne à l'aide de strcpy */ P=CH.h> #include <string. /* pointeurs d'aide dans CH1 int TROUVE.h> main() { /* Déclarations */ char CH[101]. CH2[101]. gets(CH). /* lettre à éliminer */ char *P. /* pointeur d'aide dans CH */ /* Saisie des données */ printf("Entrez une ligne de texte (max. /* chaîne donnée */ char C. return 0. C=getchar(). for (P1=CH1 . *P2.13 #include <stdio. printf("Entrez le caractère à éliminer (suivi de Enter) : "). } /* Affichage du résultat */ printf("Chaîne résultat : \"%s\"\n". printf("Entrez la deuxième chaîne de caractères" " (max. /* indicateur logique: vrai. gets(CH1). P+1). gets(CH2). *P2. CH). *P1 && !TROUVE .100 caractères) :\n"). */ /* Si tel est le cas. else P++.100 caractères) :\n").Exercice 8. /* chaînes données char *P1. /* Eliminer les lettres communes */ /* Idée: Parcourir CH2 de gauche à droite et contrôler */ /* pour chaque caractère s'il se trouve aussi dans CH1.h> #include <string. P2++) { TROUVE = 0.12 #include <stdio.h> main() { /* Déclarations */ char CH1[101]. si /* actuel dans CH1 a été trouvé */ et CH2 */ le caractère */ dans CH2.

*/ /* Saisie des données */ printf("Entrez la chaîne à transformer" " (max. gets(CH1). /* indicateur logique: vrai. On pourrait aussi résoudre le problème à */ /* l'aide d'un troisième pointeur P3 parcourant CH1. /* Rechercher CH2 dans CH1 : */ /* L'expression P2-CH2 est utilisée pour déterminer l'indice */ /* de P2 dans CH2. } /* A la fin de la boucle. strcpy(P1. } } /* Affichage du résultat */ printf("Chaîne résultat : \"%s\" \n".15 #include <stdio.h> main() { /* Déclarations */ 125 WAFAE SABBAR . /* Affichage du résultat */ printf("Chaîne résultat : \"%s\" \n". } Exercice 8. */ if (TROUVE) strcpy(P1. P1+(P2-CH2)).h> main() { /* Déclarations */ char CH1[101]. P1+1). /* chaînes données char *P1.TROUVE = 1. *P2. (P2-CH2) est alors la longueur de CH2. for (P1=CH1 . P1++) { for (P2=CH2 . CH1). if (!*P2) TROUVE = 1. } Exercice 8. donc */ P1--.100 caractères) :\n"). P1 est incrémenté.100 caractères) :\n"). alors P1 indique la position */ /* de la première occurence de CH2 dans CH1 et P2 pointe à */ /* la fin de CH2.h> #include <string. P2++) . /* pointeurs d'aide dans CH1 int TROUVE. si /* actuel dans CH1 a été trouvé */ et CH2 */ le caractère */ dans CH2. CH2[101]. printf("Entrez la chaîne à supprimer " " (max. gets(CH2).14 #include <stdio. *P1 && !TROUVE . *P2 == *(P1+(P2-CH2)) . CH1). */ TROUVE=0. /* Si CH2 se trouve dans CH1. return 0. return 0.

scanf("%d".int A[50][50]. K. ce serait une faute grave d'afficher */ /*'simplement' les NxM premiers éléments de A ! */ printf("Matrice affichée comme vecteur :\n"). /* matrice donnée */ int C[50][50]. &N ). /* matrice */ int N. /* matrice donnée */ int B[50][50]. for (J=0.I. I++) for (J=0. /* dimensions des matrices */ int I. /* Lecture de la matrice au clavier */ for (I=0. J++) printf("%7d". M. J<M. J<M.50) : "). I<N. I++) printf("%7d ". *((int *)A+I*50+J)). P. printf("\n"). I<N. } /* b) Affichage de la transposée de A */ printf("Matrice transposée :\n"). &M ). for (I=0. scanf("%d". return 0. scanf("%d". /* dimensions de la matrice */ int I. I<N. 126 WAFAE SABBAR . J++) { printf("Elément[%d][%d] : ". /* indices courants */ /* Saisie des données */ printf("Nombre de lignes (max. printf("\n"). I++) for (J=0. I++) { for (J=0. J++) printf(" %d ". /* indices courants */ /* Saisie des données */ printf("*** Matrice A ***\n"). } Exercice 8. *((int *)A+I*50+J)).J). I<N. J++) { for (I=0. (int *)A+I*50+J). J. printf("Nombre de colonnes (max. for (I=0.h> main() { /* Déclarations */ int A[50][50]. J<M.16 #include <stdio. *((int *)A+I*50+J)). M. printf("\n"). } /* c) Interprétation de la matrice comme vecteur : */ /* Attention. } /* a) Affichage de la matrice */ printf("Matrice donnée :\n"). J. /* matrice résultat */ int N. J<M.50) : ").

*((int *)A+I*50+J)). J++) { printf("Elément[%d][%d] : ". J++) { printf("Elément[%d][%d] : ".I.50) scanf("%d". J++) printf("%7d".50) scanf("%d". I++) { for (J=0. : ").J). &P ). for (I=0. printf("Nombre de lignes de B : %d\n". &M ). I++) for (J=0.J). J<P. *((int *)B+I*50+J)). I<N. I<N. printf("\n"). I++) for (J=0. (int *)B+I*50+J). I++) for (J=0. : "). I++) { for (J=0.50) scanf("%d". J++) { *((int *)C+I*50+J)=0. for (I=0. printf("Nombre de colonnes de B (max.printf("Nombre de lignes de A (max. J<M. I<M. &N ). J<P. } /* Affectation du résultat de la multiplication à C */ for (I=0. K++) *((int*)C+I*50+J) += *((int*)A+I*50+K) * *((int*)B+K*50+J). M). I++) { for (J=0. J++) printf("%7d".I. (int *)A+I*50+J). J++) printf("%7d". for (I=0. for (K=0. J<M. printf("\n"). } /* Edition du résultat */ printf("Matrice résultat C :\n"). scanf("%d". /* Affichage des matrices */ printf("Matrice donnée A :\n"). J<P. printf("\n"). } return 0. } printf("Matrice donnée B :\n"). *((int *)C+I*50+J)). I<N. } printf("*** Matrice B ***\n"). K<M. for (I=0. J<P. scanf("%d". I<M. for (I=0. printf("Nombre de colonnes de A (max. } 127 WAFAE SABBAR . } : "). I<N.

/* Placer P2 à la fin de la chaîne */ while (*P2) P2++. /* char *P1. P2--.17 #include <stdio. for (I=0. } /* Inverser l'ordre des caractères à l'intérieur des mots */ for (I=0. P1++. *P2 = AIDE. /* sinon '\0' est placé au début de la chaîne */ while (P1<P2) { AIDE = *P1. *P2. } } /* Affichage des mots inversés */ for (I=0.h> main() { /* Déclarations */ char TABCH[5][51]. P2--.50 caractères) : ". /* tableau de chaînes de caractères */ pour la permutation des caractères */ pointeurs d'aide */ indice courant */ /* TABCH+I est l'adresse de la I-ième chaîne du tableau */ /* Il vaut mieux convertir TABCH+I en pointeur sur char */ /* Saisie des données */ printf("Entrez 5 mots :\n").18 a) Représenter graphiquement la mémorisation des deux variables NOM1 et NOM2. gets((char *)(TABCH+I)). I++) { printf("Mot %d (max./* char AIDE. I<5. I<5. /* int I. I<5. I). 128 WAFAE SABBAR . I++) { P1 = P2 = (char *)(TABCH+I).Exercice 8. I++) puts((char *)(TABCH+I)). *P1 = *P2. return 0. } Exercice 8.

"décembre"}. "janvier". "septembre". &ANNEE). ANNEE). /* Affichage des dates */ printf("Luxembourg. La durée d'une opération d'échange est constante.JOUR. den %d. ANNEE. char *MDEUT[] = {"\aEingabefehler !". "avril". &MOIS. "Oktober". "juillet". Exercice 8. printf("Luxemburg. (JOUR==1)?"er":"". MDEUT[MOIS]. 129 WAFAE SABBAR . scanf("%d %d %d". ANNEE). "Mai". "September". MOIS. if (JOUR<0||JOUR>31||MOIS<0||MOIS>12||ANNEE<0||ANNEE>3000) { CORRECT=0. "novembre". "Juni".b) Pour trier les chaînes du tableau de pointeurs. "März". "August". "Dezember"}. puts(MFRAN[0]).19 #include <stdio. %s %d \n". le tri d'un tableau de pointeurs est donc certainement plus rapide que le tri d'un tableau de chaînes de caractères.h> main() { /* Tableaux de pointeurs sur des chaînes de caractères */ char *MFRAN[] = {"\aErreur d'entrée !". int JOUR. /* données pour la date */ int CORRECT. "juin". Pour des chaînes de caractères d'une longueur 'normale'. "Januar". "Juli". MFRAN[MOIS]. "août". La durée d'une opération d'échange est dépendante de la longueur des chaînes de caractères. "octobre". } } while (!CORRECT). peu importe la longueur des chaînes. CORRECT=1. "février". le mois et l'année : "). "November". "mai". "mars". JOUR. Pour trier le tableau de chaînes de caractères. "Februar". /* indicateur logique: */ /* vrai si la date entrée est correcte */ /* Saisie des données */ do { printf("Introduire le jour. il faut uniquement changer les pointeurs. puts(MDEUT[0]). "April". &JOUR. il faut changer tous les caractères des chaînes un à un. le %d%s %s %d \n".

J=9 . I<10.h> main() { /* Déclarations */ char INTRO[500]. for (I=0. I++) { /* Lecture d'une phrase */ printf("Phrase %d : ". */ if (TEXTE[I]) /* copier la phrase à l'adresse */ /* fournie par malloc. . else { /* sinon afficher un message d'erreur */ printf("\aPas assez de mémoire \n"). INTRO). return 0. /* indices courants */ /* Saisie des données et allocation dynamique de mémoire */ puts("Introduire 10 phrases terminées chaque fois" " par un retour à la ligne :"). /* Tableau des pointeurs sur les 10 chaînes */ char *PAIDE.. /* S'il y a assez de mémoire. */ exit(-1). */ strcpy(TEXTE[I].h> #include <string. /* chaîne pour l'introduction des données */ char *TEXTE[10]..J--) { PAIDE = TEXTE[I]. } Exercice 8. I++. } /* Afficher le tableau résultat */ puts("Contenu du tableau résultat :"). I<10.h> #include <stdlib.h> #include <stdlib. for (I=0. I++) puts(TEXTE[I]). I++) puts(TEXTE[I]).20 #include <stdio. gets(INTRO). /* Inverser l'ordre des phrases avec le pointeur PAIDE */ for (I=0.21 #include <stdio.return 0. } Exercice 8. /* Réservation de la mémoire */ TEXTE[I] = malloc(strlen(INTRO)+1). I<10. /* et quitter le programme.J. } } /* Afficher le tableau donné */ puts("Contenu du tableau donné :"). TEXTE[I] = TEXTE[J]. I<J . /* pointeur d'aide pour l'échange des pointeurs */ int I.I).h> main() 130 WAFAE SABBAR . for (I=0. TEXTE[J] = PAIDE.h> #include <string.

. else { /* sinon afficher un message d'erreur */ printf("\aPas assez de mémoire \n"). /* Affichage des mots restants */ printf("Passage No. I)./* chaîne pour l'introduction des données */ char *MOT[10]. !MOT[MAX] .I). printf("Poussez Enter pour continuer .\n"). gets(INTRO).{ /* Déclarations */ char INTRO[51]. getchar(). MOT[J])>0) MAX=J. /* et quitter le programme. /* Suppression de la chaîne */ free(MOT[MAX]). MAX++) . } return 0.. for (I=0. J++) if (MOT[J] && strcmp(MOT[MAX]. */ for (MAX=0 .J. J<10. for (J=0. /* indices courants */ /* Saisie des données et allocation dynamique de mémoire */ puts("Introduire 10 phrases terminées chaque fois" " par un retour à la ligne :").%d :\n".. INTRO). J++) if (MOT[J]) puts(MOT[J]). */ exit(-1). } 131 WAFAE SABBAR .. J<10. I++) { /* Lecture d'une phrase */ printf("Phrase %d : ". } } /* Suppression des mots du tableau par ordre lexicographique */ for (I=0. /* indice du prochain candidat à supprimer */ int I. */ if (MOT[I]) /* copier la phrase à l'adresse */ /* fournie par malloc. I++) { /* Recherche de la dernière chaîne dans l'ordre */ /* lexicographique : Initialiser d'abord MAX avec */ /* l'indice d'une chaîne encore existante. /* S'il y a assez de mémoire. */ strcpy(MOT[I].. */ /* Les conditions de la forme MOT[I] ou !MOT[I] */ /* contrôlent si la chaîne I a déjà été supprimée */ /* ou non. /* Réservation de la mémoire */ MOT[I] = malloc(strlen(INTRO)+1). MOT[MAX]=0. /* Tableau de pointeurs sur les 10 chaînes */ int MAX. for (J=MAX. I<10. I<10.

h> #include <string. */ for (MAX=0 .h> #include <stdlib.\n"). } } /* Calcul de la longueur totale de la 'phrase' */ L=11. /* Longueur de la phrase */ /* Saisie des données et allocation dynamique de mémoire */ puts("Introduire 10 phrases terminées chaque fois" " par un retour à la ligne :").I). } /* Initialisation de la PHRASE */ PHRASE[0]='\0'.J. J<10. exit(-1). MAX++) . /* indice du prochain candidat à copier */ int I. for (I=0. /* Tableau de pointeurs sur les 10 chaînes */ char *PHRASE.Exercice 8. I<10. INTRO). for (J=MAX./* chaîne pour l'introduction des données */ char *MOT[10]. I<10. if (!PHRASE) { printf("\aPas assez de mémoire pour" " mémoriser la phrase.h> main() { /* Déclarations */ char INTRO[51]. /* Réservation de la mémoire */ MOT[I] = malloc(strlen(INTRO)+1). I<10. exit(-1). I++) { /* Lecture d'une phrase */ printf("Phrase %d : ". gets(INTRO). J++) if (MOT[J] && strcmp(MOT[MAX]. /* indices courants */ int L. I++) { /* Recherche de la dernière chaîne dans l'ordre */ /* lexicographique : Initialiser d'abord MAX avec */ /* l'indice d'une chaîne encore existante.22 #include <stdio. else { printf("\aPas assez de mémoire \n"). MOT[J])>0) MAX=J. !MOT[MAX] . /* Pointeur cible */ int MAX. /* Copier et supprimer les mots du tableau par */ /* ordre lexicographique */ for (I=0. if (MOT[I]) strcpy(MOT[I]. /* Réservation de la mémoire pour la 'phrase' */ PHRASE = malloc(L). /* pour les espaces et le symbole de fin de chaîne */ for (I=0. /* Copier la chaîne dans la PHRASE */ 132 WAFAE SABBAR . I++) L += (strlen(MOT[I])+1).

/* Suppression de la chaîne */ free(MOT[MAX]). I++) { /* Lecture d'une phrase */ printf("Phrase %d : ". MOT[J+1] = AIDE.h> #include <stdlib.MOT[MAX]). strcat(PHRASE. INTRO). /* Tableau de pointeurs sur les 10 chaînes */ int I. /* ligne où la dernière permutation a eu lieu */ /* permet de ne pas trier un sous-ensemble déjà trié */ /* Saisie des données et allocation dynamique de mémoire */ puts("Introduire 10 phrases terminées chaque fois" " par un retour à la ligne :"). else { printf("\aPas assez de mémoire \n").h> #include <string. /* chaîne pour l'introduction des données */ char *MOT[10]. return 0. puts(PHRASE). J++) if (strcmp(MOT[J]. } /* Affichage de la PHRASE */ puts("Résultat :"). exit(-1). /* Réservation de la mémoire */ MOT[I] = malloc(strlen(INTRO)+1). for (J=0.strcat(PHRASE. for (I=0. /* ligne à partir de laquelle MOT est trié */ int J. MOT[J] = MOT[J+1].MOT[J+1])>0) { FIN=J./* pour la permutation des pointeurs */ int FIN. I>0 . I=FIN) { FIN=0. gets(INTRO). 133 WAFAE SABBAR . I<10." "). J<I. } Exercice 8. if (MOT[I]) strcpy(MOT[I].h> main() { /* Déclarations */ char INTRO[51]. MOT[MAX]=0. /* indice courant */ char *AIDE. AIDE = MOT[J].I). */ for (I=9 .23 #include <stdio. } } /* Tri du tableau par propagation de l'élément maximal.

return 0. I<10.} } /* Affichage du tableau */ puts("Tableau trié :"). } 134 WAFAE SABBAR . I++) puts(MOT[I]). for (I=0.

. printf("Introduire le scanf("%lf". } 135 WAFAE SABBAR . return PI()*RAYON*RAYON. &R).h> double PI(void) { return 3. double SURFACE(double RAYON) { /* Déclaration locale de PI */ double PI(void). } de SURFACE */ RAYON). LES FONCTIONS Exercice 9.9 .14159265.Définition 'bottom-up' sans déclarations: #include <stdio. printf("La surface du return 0. rayon du cercle : ").h> main() { /* Déclaration locale double SURFACE(double double R. } double PI(void) { return 3.Déclarations locales des fonctions et définition 'top-down': #include <stdio. .14159265. \n". suite .1 a) Etablir la hiérarchie des appels pour les trois fonctions: b) Définir les fonctions d'après les trois méthodes décrites ci-dessus en ajoutant les déclarations manquantes. } . cercle est %f. . SURFACE(R)).

h> /* Déclaration globale des fonctions */ double SURFACE(double RAYON). } . printf("Introduire le rayon du cercle : "). Le compilateur suppose alors par défaut que la fonction fournit un résultat du type int et que les paramètres ont le type des arguments utilisés lors de l'appel..14159265. printf("La surface du cercle est %f.. 136 WAFAE SABBAR . printf("La surface du cercle est %f. nous obtenons les messages suivants: Warning . &R). : Call to function 'SURFACE' with no prototype Error . &R). printf("Introduire le rayon du cercle : "). SURFACE(R)). return 0. En rencontrant ensuite la définition de la fonction. \n". scanf("%lf".. scanf("%lf". double PI(void). car la fonction SURFACE retourne en réalité une valeur du type double. main() { double R. } c) Si nous compilons le programme donné sans changements.Déclaration globale des fonctions et définition 'top-down': #include <stdio.double SURFACE(double RAYON) { return PI()*RAYON*RAYON. } double PI(void) { return 3. \n". } double SURFACE(double RAYON) { return PI()*RAYON*RAYON. SURFACE(R)). : Type mismatch in redeclaration of 'SURFACE' Explications: Le premier message est un avertissement qui nous informe que la fonction SURFACE est appelée sans être déclarée auparavant. } main() { double R. Cet avertissement restera sans conséquences si ces suppositions sont correctes. return 0. le compilateur détecte une incompatibilité de type.. Cette incompatibilité de type ("Type mismatch") est signalée par un message d'erreur et le programme ne peut pas être compilé avec succès.

B=0. A=0. printf("%d %d \n". printf("%d %d \n". int *Y). /* Prototype de la fonction appelée */ int A. *Y).Exercice 9. B). X.2 Affichage: 1 1 01 Implémentation: #include <stdio. *Y = *Y+1. A.h> main() { void P(int X. } void P(int X. P(A. &B).B. return 0. } Exercice 9.3 Affichage: 2 2 1000 2 Implémentation: 137 WAFAE SABBAR . int *Y) { X = X+1.

&B. /* Prototype de la fonction appelée */ int A. } Exercice 9. X).h> main() { void MACHIN(int X). return 0. int *Z) { int T. printf("%d \n". C).#include <stdio. printf("%d %d %d \n".B.C. T = X. printf("%d \n". C). MODIFIER(A. A. MACHIN(A).&C). X = 1000. printf("%d %d %d \n". *Y = *Z. A). int *Y. C=12. int *Z). A=2. A). 138 WAFAE SABBAR . /* Prototype */ int A.h> main() { void MODIFIER(int X. B=-8. X = *Y. B.4 Affichage: 3 -8 12 3 12 3 Implémentation: #include <stdio. int *Y. printf("%d \n". } void MACHIN(int X) { printf("%d \n". return 0. X). A=3. } void MODIFIER(int X. B. A.

MANIPULER(A. X = X/2.B. int Y. *Z). C). C). . B. } Exercice 9.*Z = T. printf("%d %d %d \n". 5 5 10 5 -34 -34 114 114 Implémentation: #include <stdio. printf("%d %d %d \n". *Z = X+Y. float Y). B=5.B. A.h> main() { void MANIPULER(int X. X. X. *Z).C.5 Affichage: 208 208 104 208 suite . /* Prototype */ int A.B. int Y. } Exercice 9. int *Z).h> main() { /* Prototypes des fonctions appelées */ float MOYENNE(float X. B. int *Z) { printf("%d %d %d \n". /* Variables locales */ float A.&C). } void MANIPULER(int X. Y. . printf("%d %d %d \n". Y = Y*2.6 #include <stdio. Y. /* Traitements */ 139 WAFAE SABBAR . return 0. C=-34. A=208. A.

/* b */ /* Comme la valeur initiale de A est perdue à l'appel */ /* de EXP2. &B). A. A. } Exercice 9. } float MOYENNE(float X. /* a */ printf("EXP1(%. 140 WAFAE SABBAR . float Y) { return (X+Y)/2. scanf("%d". printf("La moyenne arithmétique de %. &B). printf("Introduire l'exposant positif N : "). &A).B)). for (RES=1. B. int N).0. int B. return 0. EXP2(&A. void EXP2(double *X. } void EXP2(double *X. int N) { double RES. N>0. N>0. A. int N) { double AIDE. for (AIDE=1. il faut partager l'affichage si on veut */ /* afficher la valeur de A avant et après l'appel ! */ printf("EXP2(%. return RES. scanf("%lf". scanf("%f %f".h> main() { /* Prototypes des fonctions appelées */ double EXP1(double X. /* Traitements */ printf("Introduire un réel X : "). N--) AIDE *= *X. %d) = ". B). %d) = %f\n". MOYENNE(A. } double EXP1(double X. /* Variables locales */ double A. B. A).2f est %. } Remarque: Cette solution de EXP2 respecte automatiquement le cas où N=0.2f et %. &A. printf("%f\n".2f .0. *X = AIDE. EXP1(A. B).printf("Introduire deux nombres : ").2f . N--) RES *= X.B)).7 #include <stdio. int N).4f\n". return 0.

double Y) { return (X>Y) ? X : Y. double Y) { if (X>Y) return X.B). else return Y. double Y). /* Traitements */ printf("Introduire 4 réels : "). double MAX(double X. } /* ou bien */ /* double MIN(double X.D)) ).9 #include <stdio.8 #include <stdio. /* Variables locales */ int I. printf("Le minimum des 4 réels est %f \n". scanf("%lf %lf %lf %lf". &B. MAX( MAX(A.h> main() { /* Prototypes des fonctions appelées */ double MIN(double X. } double MAX(double X. &D).h> main() { /* Prototypes des fonctions appelées */ double F(int X). MAX(C. return 0. } */ Exercice 9. MIN(C. /* Variables locales */ double A.B). &A. double Y).Exercice 9. } double MIN(double X. &C. else return Y. 141 WAFAE SABBAR .h> #include <math.B. double Y) { return (X<Y) ? X : Y.C. MIN( MIN(A.D.D)) ). printf("Le maximum des 4 réels est %f \n". } double MAX(double X. double Y) { if (X<Y) return X.

0f \n". } int NCHIFFRES(long N) { /* Comme N est transmis par valeur.NCHIFFRES(A)). scanf("%ld". return 0.h> main() { /* Prototypes des fonctions appelées */ double FACT(int N). return I. FACT(N)). I. return 0. /* Traitements */ printf("Introduire un nombre entier : "). &N). /* Compter les chiffres */ for (I=1. printf("La factorielle de %d est %. &A).h> main() { /* Prototypes des fonctions appelées */ int NCHIFFRES(long N). } 142 WAFAE SABBAR . I++) N /= 10.A . I<=10 . N>10./* Traitements */ printf("\tX\tF(X)\n").10 #include <stdio. /* Conversion du signe si N est négatif */ if (N<0) N *= -1. printf("Le nombre %ld a %d chiffres. */ int I. /* Traitements */ printf("Introduire un nombre entier N : "). I++) printf("\t%d\t%f\n". } Exercice 9. } double F(int X) { return sin(X)+log(X)-sqrt(X). } Exercice 9. for (I=1 . N peut être */ /* modifié à l'intérieur de la fonction.N .\n".11 #include <stdio. F(I)). return 0. /* Variables locales */ long A. /* Variables locales */ int N. scanf("%d".

N--) RES *= N. int Q) { /* Prototypes des fonctions appelées */ double FACT(int N). Q<=P. } Exercice 9. } void LIGNEC(int P) { /* Prototypes des fonctions appelées */ double C(int P. P++) LIGNEC(P). Q++) printf("%6. /* Variables locales */ int P.double FACT(int N) { /* Comme N est transmis par valeur.Q)). TRIANGLE(N).12 Il y a beaucoup de solutions possibles à ce problème. */ double RES. } void TRIANGLE(int LIGNES) { /* Prototypes des fonctions appelées */ void LIGNEC(int P). 143 WAFAE SABBAR . /* Traitements */ for (Q=0.h> main() { /* Prototypes des fonctions appelées */ void TRIANGLE(int LIGNES). return RES. /* Variables locales */ int N. printf("\n").0f". N>0 . #include <stdio.0 . P<LIGNES. /* Variables locales */ int Q. N peut être */ /* modifié à l'intérieur de la fonction. /* Traitements */ for (P=0. /* Traitements */ printf("Introduire le nombre de lignes N : "). scanf("%d". return 0. for (RES=1. } double C(int P. int Q). C(P. Voici probablement la solution la plus modulaire. &N).

int N). } Exercice 9. . 144 WAFAE SABBAR . I). I++) { printf("Elément[%d] : ". int NMAX) { /* Variables locales */ int I. int *N. TAB+I). /* Attention: écrire N et non &N ! */ } while (*N<0 || *N>NMAX). &DIM. printf("Tableau donné : \n"). int N) { /* Affichage des composantes du tableau */ while(N) { printf("%d ".%d) : ". } Exercice 9.14 void ECRIRE_TAB (int *TAB. /* Saisie des composantes du tableau */ for (I=0. int NMAX). } double FACT(int N) { ./* Traitements */ return FACT(P)/(FACT(Q)*FACT(P-Q)). void ECRIRE_TAB (int *TAB. } printf("\n"). } } Exercice 9.16 #include <stdio. /* Dimension du tableau */ /* Traitements */ LIRE_TAB (T. /* Tableau d'entiers */ int DIM. . 100). long SOMME_TAB(int *TAB.h> main() { /* Prototypes des fonctions appelées */ void LIRE_TAB (int *TAB. TAB++. scanf("%d". scanf("%d". N--. /* Variables locales */ int T[100]. int *N. int N).13 void LIRE_TAB (int *TAB. NMAX). *TAB). /* Saisie de la dimension du tableau */ do { printf("Dimension du tableau (max. N). I<*N.

} void ECRIRE_TAB (int *TAB. /* Variables locales */ int SAUT. DIM) ). /* Dimension du tableau */ /* Traitements */ LIRE_TAB (T. ECRIRE_TAB (T.17 Tri de Shell #include <stdio. . } Exercice 9. /* Traitements */ SAUT = N. int N) { . printf("Tableau trié : \n"). void LIRE_TAB (int *TAB. K. . printf("Tableau donné : \n").ECRIRE_TAB (T. printf("Somme des éléments du tableau : %ld\n". void ECRIRE_TAB (int *TAB. int NMAX) { . TRI_SHELL(T. } void TRI_SHELL(int *T. &DIM. int TERMINE. int *B). while (SAUT>1) { SAUT /= 2. . do 145 WAFAE SABBAR . . DIM). DIM). } void LIRE_TAB (int *TAB. int N). return 0. int N) { /* Trie un tableau T d'ordre N par la méthode de Shell */ /* Prototypes des fonctions appelées */ void PERMUTER(int *A.h> main() { /* Prototypes des fonctions appelées */ void TRI_SHELL(int *T. /* Tableau d'entiers */ int DIM. int *N. /* Variables locales */ int T[100]. int *N. . DIM). int NMAX). . DIM). ECRIRE_TAB (T. int N). return 0. SOMME_TAB(T. int N) { . } long SOMME_TAB(int *TAB. 100). M.

I<N. /* variables d'aide */ MAX=*TAB. for (I=1. . . I<N. int N) { .{ TERMINE=1. 146 WAFAE SABBAR . for (I=1. int *N.T+K). } void ECRIRE_TAB (int *TAB. I++) if (MAX < *(TAB+I)) MAX = *(TAB+I). M++) /* Attention aux indices! */ { K=M+SAUT. int N) { int MAX.18 Déterminer le maximum de N éléments d'un tableau TAB d'entiers de trois façons différentes: a) la fonction MAX1 retourne la valeur maximale int MAX1(int *TAB. int N) { int I. int NMAX) { . *A = *B.I. } Exercice 9. . } } } while(!TERMINE). M<N-SAUT. *B = AIDE. . } void LIRE_TAB (int *TAB. I++) if (*(TAB+MAX) < *(TAB+I)) MAX = I. if (*(T+M) > *(T+K)) { PERMUTER(T+M.MAX. return MAX. TERMINE=0. return MAX. AIDE = *A. /* variables d'aide */ MAX=0. int *B) { int AIDE. /* Attention: utiliser la négation de */ } /* la condition employée en lang algorithmique */ } void PERMUTER(int *A. } b) la fonction MAX2 retourne l'indice de l'élément maximal int MAX2(int *TAB. for (M=0.

MAX1(T. int N) { . int *N. /* Dimension du tableau */ /* Traitements */ LIRE_TAB (T. int N). int N). DIM).h> main() { /* Prototypes des fonctions appelées */ int MAX1 (int *TAB. void ECRIRE_TAB (int *TAB. printf("Tableau donné : \n").DIM) ). int NMAX). return MAX. . . 100). *P. P<TAB+N. &DIM. int *MAX3(int *TAB. int N) { . /* Variables locales */ int T[100].DIM) ). } void LIRE_TAB (int *TAB. return 0. int NMAX) { . T[MAX2(T. printf("MAX1 : %d \n". . } int *MAX3(int *TAB. printf("MAX2 : %d \n". ECRIRE_TAB (T. void LIRE_TAB (int *TAB.} c) la fonction MAX3 retourne l'adresse de l'élément maximal int *MAX3(int *TAB. . . *MAX3(T. int N). printf("MAX3 : %d \n". . } int MAX1(int *TAB. } int MAX2(int *TAB. 147 WAFAE SABBAR . int N) { . int N). int N) { int *MAX. .DIM)] ). for (P=TAB. /* Tableau d'entiers */ int DIM. P++) if (*MAX < *P) MAX=P. } Ecrire un programme pour tester les trois fonctions: #include <stdio. /* pointeurs d'aide */ MAX=TAB. int MAX2 (int *TAB. . int *N.

100). } Exercice 9. void LIRE_TAB (int *TAB. int NMAX) { . DIM). DIM). I<N-1 . . int N) { . } void TRI_SELECTION(int *T. int N) { /* Prototypes des fonctions appelées */ void PERMUTER(int *A.N-I) ). int *N.19 Tri par sélection #include <stdio. void ECRIRE_TAB (int *TAB. . } int *MAX3(int *TAB. TRI_SELECTION(T. MAX3(T+I. . int *B). . . printf("Tableau donné : \n"). . int N). int NMAX). return 0. I++) PERMUTER(T+I. int N). int N) { . . /* Variables locales */ int I.} void ECRIRE_TAB (int *TAB. ECRIRE_TAB (T. printf("Tableau trié : \n"). /* rang à partir duquel T n'est pas trié */ /* Tri par sélection directe du maximum */ for (I=0 . /* Tableau d'entiers */ int DIM. /* Dimension du tableau */ /* Traitements */ LIRE_TAB (T. DIM).h> main() { /* Prototypes des fonctions appelées */ void TRI_SELECTION(int *T. } 148 WAFAE SABBAR . ECRIRE_TAB (T. } void LIRE_TAB (int *TAB. } void PERMUTER(int *A. int *N. &DIM. /* Variables locales */ int T[100]. int N). int *B) { . int *MAX3(int *TAB. .

int *N) { /* Variables locales */ int I. printf("Tableau résultat : \n"). int *T.20 #include <stdio. T. /* Variables locales */ int T[100]. scanf("%d". &DIM). . I>0 && *(T+I-1)>X . DIM). /* Nombre à insérer */ /* Traitements */ LIRE_TAB (T. int *T. . DIM).h> main() { /* Prototypes des fonctions appelées */ void INSERER(int X. int NMAX). &DIM. printf("Introduire le nombre à insérer : "). return 0. /* X est copié à la position du dernier élément déplacé */ *(T+I)=X. int *N). /* Nouvelle dimension du tableau: */ (*N)++. void ECRIRE_TAB (int *TAB. . /* Insertion de X dans le tableau T supposé trié: */ /* Déplacer les éléments plus grands que X d'une */ /* position vers l'arrière. void LIRE_TAB (int *TAB. printf("Tableau donné : \n"). int N). } 149 WAFAE SABBAR . ECRIRE_TAB (T. ECRIRE_TAB (T. int *N. int *N.void ECRIRE_TAB (int *TAB. INSERER(A. int N) { . . . &A). */ for (I=*N . 100). } Exercice 9. int N) { . int NMAX) { . } void INSERER(int X. } void ECRIRE_TAB (int *TAB. I--) *(T+I) = *(T+I-1). /* Attention aux parenthèses ! */ } void LIRE_TAB (int *TAB. /* Tableau d'entiers */ int DIM. /* Dimension du tableau */ int A. .

int *N. int *N. int *N). } void LIRE_TAB (int *TAB. ECRIRE_TAB (T. int NMAX).h> main() { /* Prototypes des fonctions appelées */ void TRI_INSERTION(int *T. T. 150 WAFAE SABBAR . printf("Tableau donné : \n"). int *Y) { int AIDE. int *T. printf("Tableau trié : \n"). DIM). DIM). /* Tableau d'entiers */ int DIM. int N) { void INSERER(int X. &I). DIM). int N). . TRI_INSERTION(T. . /* Dimension du tableau */ /* Traitements */ LIRE_TAB (T. int *T. . } void ECRIRE_TAB (int *TAB. return 0. ECRIRE_TAB (T. int *N) { . &DIM.21 Tri par insertion #include <stdio. } void INSERER(int X. while (I<N) INSERER(*(T+I).Exercice 9. .22 int RANGER(int *X. /* indice courant */ /* Tri de T par insertion */ I=1. } Exercice 9. int N). int NMAX) { . void LIRE_TAB (int *TAB. } void TRI_INSERTION(int *T. . int N) { . . /* Variables locales */ int I. /* Variables locales */ int T[100]. if (*X>*Y) { AIDE = *X. void ECRIRE_TAB (int *TAB. 100).

/* indices courants */ int FIN. DIM). ECRIRE_TAB (T. int *Y). /* Dimension du tableau */ /* Traitements */ LIRE_TAB (T. for (J=0. J<I. } void LIRE_TAB (int *TAB. &DIM. . return 1. /* Tableau d'entiers */ int DIM. int N).*X = *Y. int NMAX). . /* Variables locales */ int T[100]. int *N. } else return 0. . /* Variables locales */ int I. } void TRI_BULLE(int *T. int N) { . return 0. I=FIN) { FIN=0. int N) { /* Prototypes des fonctions appelées */ int RANGER(int *X. } void ECRIRE_TAB (int *TAB. */ /* Tri de T par propagation de l'élément maximal */ for (I=N-1 . void TRI_BULLE(int *T. ECRIRE_TAB (T. TRI_BULLE(T. /* position où la dernière permutation a eu lieu */ /* permet de ne pas trier un sous-ensemble déjà trié. } Exercice 9. int N). J++) if (RANGER(T+J.23 Tri par propagation #include <stdio.J. . DIM). void ECRIRE_TAB (int *TAB. int *Y) { . } } int RANGER(int *X. . printf("Tableau trié : \n"). *Y = AIDE. 100). int *N. T+J+1)) FIN = J. int NMAX) { .h> main() { /* Prototypes des fonctions appelées */ void LIRE_TAB (int *TAB. I>0 . printf("Tableau donné : \n"). } 151 WAFAE SABBAR . DIM). .

int *FUS. } /* Si A ou B sont arrivés à la fin. IB++.h> main() { /* Prototypes des fonctions appelées */ void FUSION(int *A.B.M). printf("Tableau FUS : \n"). B et FUS */ int IA.Exercice 9. &N. } void FUSION(int *A. N). int N. return 0. /* Traitements */ printf("*** Tableau A ***\n"). &M. /* Variables locales */ /* Les tableaux et leurs dimensions */ int A[100]. int *FUS. LIRE_TAB (A. */ while (IA<N) { *(FUS+IFUS)=*(A+IA). B[100]. int *B. int M). int *N.24 Fusion de tableaux triés #include <stdio. int N). IA++. 152 WAFAE SABBAR . /* Fusion de A et B dans FUS */ IA=0. int N.IB. void LIRE_TAB (int *TAB. M.IFUS. IB=0. IFUS++. N+M). N). int NMAX). TRI_BULLE(A. printf("Tableau A trié : \n"). IFUS++.N. IFUS=0. ECRIRE_TAB (B. void TRI_BULLE(int *T. printf("*** Tableau B ***\n"). 100). ECRIRE_TAB (FUS. FUSION(A. int M) { /* Variables locales */ /* Indices courants dans A. LIRE_TAB (B. M). void ECRIRE_TAB (int *TAB. int N).FUS. TRI_BULLE(B. IFUS++. int N. while ((IA<N) && (IB<M)) if (*(A+IA)<*(B+IB)) { *(FUS+IFUS)=*(A+IA). printf("Tableau B trié : \n"). alors */ /* copier le reste de l'autre tableau. } else { FUS[IFUS]=B[IB]. M). int *B. FUS[200]. 100). ECRIRE_TAB (A.

int *Y) { . /* terminer la chaîne CH1 */ 153 WAFAE SABBAR . } *CH1='\0'. int N) { . CH2++. int *N. P++) . int N) { /* Prototypes des fonctions appelées */ int RANGER(int *X. . } int RANGER(int *X.IA++. CH1++. IFUS++. int *Y). *CH. return P-CH. . . *P. int NMAX) { . } void LIRE_TAB (int *TAB. for (P=CH . CH++) if (*CH>='a' && *CH<='z') *CH = *CH-'a'+'A'. } } void TRI_BULLE(int *T. char *CH2) { while (*CH1) /* chercher la fin de CH1 */ CH1++. } Exercice 9. } Exercice 9.27 void AJOUTE_CH(char *CH1. } void ECRIRE_TAB (int *TAB. . . . while (*CH2) /* copier CH2 à la fin de CH1 */ { *CH1 = *CH2. . IB++. } Exercice 9. .26 void MAJ_CH(char *CH) { for ( .25 int LONG_CH(char *CH) { char *P. } while (IB<M) { *(FUS+IFUS)=*(B+IB). .

char *B) { char AIDE. CH1++. *CH1 . for ( . /* Inverser la chaîne par permutations successives */ J = LONG_CH(CH)-1.J. . I<J . . *A = *B. void PERMUTER_CH(char *A. char *B). CH++) if (isspace(*CH)) DANS_MOT=0.28 void INVERSER_CH (char *CH) { /* Prototypes des fonctions appelées */ int LONG_CH(char *CH).J--) PERMUTER_CH(CH+I. /* nombre de mots */ int DANS_MOT. AIDE = *A.h> int NMOTS_CH(char *CH) { /* Variables locales */ int N. /* indicateur logique : */ /* vrai si CH pointe à l'intérieur d'un mot */ DANS_MOT=0. for (I=0 . char *CH2) { for ( . le symbole de fin de chaîne est aussi copié. } int LONG_CH(char *CH) { . 154 WAFAE SABBAR . } Comme la conditon d'arrêt est évaluée lors de l'affectation.29 #include <ctype. /* Variables locales */ int I. else if (!DANS_MOT) { DANS_MOT=1. CH1++) .} Solution plus compacte : void AJOUTE_CH(char *CH1. } Exercice 9. } return N. I++. *CH1 = *CH2 . *CH. for (N=0. } void PERMUTER_CH(char *A. N++. Exercice 9. *B = AIDE. CH+J). CH2++) .

/* Pour réajuster l'effet de l'incrémentation */ } return CH. char *CH) { /* Variables locales */ int DANS_MOT. .31 int EGAL_N_CH(int N.30 #include <ctype. char *CH2) { /* Prototypes des fonctions appelées */ int LONG_CH(char *CH). CH2++. CH1. char *CH1. . for ( . N--. } int LONG_CH(char *CH) { . . CH--. else if (!DANS_MOT) { DANS_MOT=1. CH2)) CH2++.h> char *MOT_CH(int N.} Exercice 9. return CH2. /* Recherche de CH1 dans CH2 */ L=LONG_CH(CH1). /* indicateur logique : */ /* vrai si CH pointe à l'intérieur d'un mot */ DANS_MOT=0. } Exercice 9. char *CH1. } Exercice 9. char *CH2) { while (--N && *CH1==*CH2) { CH1++. int EGAL_N_CH(int N. } return (*CH1==*CH2). 155 WAFAE SABBAR . char *CH1.32 char *CHERCHE_CH(char *CH1. char *CH2) { . . char *CH2). while (*CH2 && !EGAL_N_CH(L. } int EGAL_N_CH(int N. CH++) if (isspace(*CH)) DANS_MOT=0. N>0 && *CH . /* Variables locales */ int L.

0 + (*CH-'0').h> #include <math. /* résultat numérique */ int SIGNE. */ return SIGNE*N/pow(10. int SIGNE. /* Traitement du point décimal */ if (*CH=='.} Exercice 9. CH++) N = N*10 + (*CH-'0'). *CH>='0' && *CH<='9' . /* Conversion des chiffres */ for (N=0 . /* Traitement des positions derrière le point décimal */ for (DEC=0. isdigit(*CH).h> void ENTIER_CH(long N.h> double CH_DOUBLE(char *CH) { /* Variables locales */ double N. /* Traitement du signe */ if (*CH=='-') SIGNE = -1. } Exercice 10.0 + (*CH-'0').33 long CH_ENTIER(char *CH) { /* Variables locales */ long N. /* Traitement du signe */ SIGNE = 1.') CH++. if (*CH=='-') SIGNE = -1. DEC++.0.34 #include <ctype.35 #include <stdio. isdigit(*CH). return SIGNE*N. /* signe de la valeur rationnelle */ int DEC. } Exercice 10. CH++) N = N*10. SIGNE = 1. if (*CH=='-' || *CH=='+') CH++. } /* Calcul de la valeur à partir du signe et */ /* du nombre de décimales.DEC). /* Positions devant le point décimal */ for ( . if (*CH=='-' || *CH=='+') CH++. CH++) { N = N*10. /* positions derrière la virgule */ /* Initialisation des variables */ N = 0. char *CH) { 156 WAFAE SABBAR .

/* Prototypes des fonctions appelées */ void INVERSER_CH(char *CH). . } while ((N/=10) > 0). I++. } int LONG_CH(char *CH) { . void PERMUTER_CH(char *A. I++. char *B) { . . } Exercice 10. } /* Terminer la chaîne */ *(CH+I)='\0'. /* Ajouter le signe à la fin de la chaîne */ if (SIGNE<0) { *(CH+I)='-'.36 Solution: 157 WAFAE SABBAR . /* Inverser la chaîne */ INVERSER_CH(CH). char *B). do { *(CH+I) = N % 10 + '0'. int SIGNE. . . . /* Traitement du signe */ SIGNE = (N<0) ? -1 : 1. . . /* Variables locales */ int I. } void PERMUTER_CH(char *A. } void INVERSER_CH (char *CH) { /* Prototypes des fonctions appelées */ int LONG_CH(char *CH). if (N<0) N=-N. /* Conversion des chiffres (à rebours) */ I=0.

/* Conversion */ N *= 10000.0. char *CH). void PERMUTER_CH(char *A. /* Variables locales */ int I. /* point décimal. . .void DOUBLE_CH(double N. int *C. . } int LONG_CH(char *CH) { . /* Conversion forcée est facultative */ L=LONG_CH(CH). . */ *(CH+L-4)='. . . CH). .'. char *B). void ENTIER_CH(long N. } Exercice 10. char *CH) { /* Prototypes des fonctions appelées */ void INVERSER_CH(char *CH).37 void LIRE_DIM (int *L. char *CH) { /* Prototypes des fonctions appelées */ int LONG_CH(char *CH). I>=L-4. I--) /* Libérer une position pour le */ *(CH+I+1) = *(CH+I). . char *B) { . } void PERMUTER_CH(char *A. } void ENTIER_CH(long N. } void INVERSER_CH (char *CH) { /* Prototypes des fonctions appelées */ int LONG_CH(char *CH). int CMAX) { 158 WAFAE SABBAR . . .L. int LMAX. ENTIER_CH((long)N. for (I=L.

I<L. C). scanf("%d". void ECRIRE_MATRICE (int *MAT. int L.%d) : ". C. /* Variables locales */ 159 WAFAE SABBAR . } while (*C<0 || *C>CMAX). } } Exercice 9. int C. scanf("%d". void LIRE_MATRICE (int *MAT.CMAX). int C. printf("\n"). int CMAX) { /* Variables locales */ int I. int C.h> main() { /* Prototypes des fonctions appelées */ long SOMME_MATRICE (int *MAT. } b) Ecrire la fonction LIRE_MATRICE à quatre paramètres MAT. int C. } } Exercice 9. I++) { for (J=0.%d) : ". L). void LIRE_DIM (int *L. J<C. J++) { printf("Elément[%d][%d] : ".J. /* Affichage des composantes de la matrice */ for (I=0. int L. int LMAX.39 #include <stdio. I++) for (J=0. void LIRE_MATRICE (int *MAT. int C. int *C. int L. J++) printf("%7d". CMAX). int int int int CMAX). CMAX)./* Saisie des dimensions de la matrice */ do { printf("Nombre de lignes de la matrice (max. scanf("%d".J. et CMAX qui lit les composantes d'une matrice MAT du type int et de dimensions L et C. *(MAT + I*CMAX + J)). J<C. int CMAX) { /* Variables locales */ int I. MAT + I*CMAX + J). J). CMAX). I. int L. do { printf("Nombre de colonnes de la matrice (max. int L.38 void ECRIRE_MATRICE (int *MAT. L.LMAX). /* Saisie des composantes de la matrice */ for (I=0. } while (*L<0 || *L>LMAX). I<L.

/* Variables locales */ /* Les matrices et leurs dimensions */ int M1[30][30].30. int int int int L. M2[30][30]. int LMAX. LIRE_MATRICE ( (int*)M. 160 WAFAE SABBAR . I++) for (J=0. &C. int *MAT2.&C.J. int L. int L. int L. } void ECRIRE_MATRICE (int *MAT. CMAX).30). . CMAX). printf("*** Matrice 2 ***\n").C. int C. int C. C. int C. int CMAX) { . . int C. int C.30). C. long SOMME = 0. int L. int CMAX) { . } Exercice 9.C. } long SOMME_MATRICE(int *MAT. J++) SOMME += *(MAT + I*CMAX + J). . 30. /* Dimensions de la matrice */ /* Traitements */ LIRE_DIM (&L. CMAX). int *C.30)).C. ECRIRE_MATRICE ( (int*)M. int CMAX).L. L. int L. /* Traitements */ LIRE_DIM (&L. } void LIRE_DIM (int *L. printf("Somme des éléments de la matrice : %ld\n". int CMAX) { /* Variables locales */ int I. return SOMME. .int M[30][30]. I<L. int *C. void ECRIRE_MATRICE (int *MAT. int CMAX) { . SOMME_MATRICE( (int*)M.h> main() { /* Prototypes des fonctions appelées */ void ADDITION_MATRICE (int *MAT1. void LIRE_MATRICE (int *MAT. } void LIRE_MATRICE (int *MAT.30 ).40 #include <stdio. int L. /* Calcul de la somme */ for (I=0. printf("Matrice donnée : \n"). printf("*** Matrice 1 ***\n"). . L.C. J<C. . /* Matrice d'entiers */ int L.30). void LIRE_DIM (int *L. return 0. LIRE_MATRICE ((int*)M1. 30). int LMAX. int C. L.

. printf("Matrice donnée 1 : \n"). &X). } void ADDITION_MATRICE (int *MAT1. ECRIRE_MATRICE ((int*)M1. printf("Matrice donnée 2 : \n"). /* Matrice d'entiers */ int L. ECRIRE_MATRICE ((int*)M. int L. int C.L. printf("Matrice donnée : \n"). ECRIRE_MATRICE ((int*)M1. int L.30). void ECRIRE_MATRICE (int *MAT.30). int LMAX.C.30. int CMAX). int *MAT. int CMAX) { /* Variables locales */ int I. printf("Matrice résultat : \n"). int CMAX). int L.30 ). int CMAX).30). ECRIRE_MATRICE ((int*)M2. LIRE_MATRICE ((int*)M.C. . /* Variables locales */ int M[30][30].L. printf("Introduire le multiplicateur (entier) : "). int L. int CMAX) { .J. 161 WAFAE SABBAR . return 0. .30 ). } void ECRIRE_MATRICE (int *MAT.41 #include <stdio. int *C. int L. (int*)M2 . I++) for (J=0. J++) *(MAT1+I*CMAX+J) += *(MAT2+I*CMAX+J). scanf("%d".LIRE_MATRICE ((int*)M2. . int CMAX).C. . int C.C. J<C. int C. } void LIRE_MATRICE (int *MAT. /* Dimensions de la matrice */ int X. int *C. .30). int L.h> main() { /* Prototypes des fonctions appelées */ void MULTI_MATRICE(int X. /* Ajouter les éléments de MAT2 à MAT1 */ for (I=0.L.C. /* Traitements */ LIRE_DIM (&L. int CMAX) { . ADDITION_MATRICE( (int*)M1 .30).C. int C. void LIRE_DIM (int *L. int C.L.C.L. int C. } Exercice 9. void LIRE_MATRICE (int *MAT. int CMAX) { . int LMAX. I<L.&C.30). C. int *MAT2.L.L. } void LIRE_DIM (int *L.

30). . /* Dimensions de la matrice */ /* Traitements */ LIRE_DIM (&L. ECRIRE_MATRICE ((int*)M. int CMAX) { .J.42 #include <stdio. int C. LIRE_MATRICE ((int*)M.30. void LIRE_MATRICE (int *MAT.30). /* Matrice d'entiers */ int L.(int*)M. } void LIRE_MATRICE (int *MAT. ECRIRE_MATRICE ((int*)M. int L. int *C.h> main() { /* Prototypes des fonctions appelées */ int TRANSPO_MATRICE (int *MAT. } else printf("\aLa matrice n'a pas pu être transposée\n"). . . int C. int CMAX).C.L. } void LIRE_DIM (int *L. if (TRANSPO_MATRICE ((int*)M.C.L.30). int C.&L. return 0. int CMAX).30). I++) for (J=0. int *C. int CMAX) { .C.30 ).C. int CMAX) { /* Variables locales */ int I.&C. C. /* Multiplication des éléments */ for (I=0.L. int LMAX. int CMAX).C. . } void ECRIRE_MATRICE (int *MAT. printf("Matrice résultat : \n"). .&C. ECRIRE_MATRICE ((int*)M. int L. int *C. int L. int L. int LMAX. int C. return 0.30). int CMAX). void LIRE_DIM (int *L. void ECRIRE_MATRICE (int *MAT. /* Variables locales */ int M[30][30]. } Exercice 9.MULTI_MATRICE (X.30)) { printf("Matrice transposée : \n"). int L. J++) *(MAT+I*CMAX+J) *= X.30. int *MAT. int CMAX) { .L. int LMAX. int *L. printf("Matrice donnée : \n"). int C. } 162 WAFAE SABBAR .L. I<L. } void MULTI_MATRICE(int X. J<C. .

int L. int L. . MAT+J*CMAX+I). /* pour la lecture de la première dimension de */ 163 WAFAE SABBAR . int LMAX.C). int LMAX. int *C. int C. P. int N. int *C. else { DMAX = (*L>*C) ? *L : *C. . int P. void LIRE_DIM (int *L. } Exercice 9. int C. . } void LIRE_DIM (int *L. PERMUTER(L. .h> main() { /* Prototypes des fonctions appelées */ void MULTI_2_MATRICES (int *MAT1. void ECRIRE_MATRICE (int *MAT. M3[30][30]. . M2[30][30]. int L. I++) for (J=0. . /* échanger les dimensions */ return 1. int *B) { . int *B). . int CMAX). int L. int CMAX). int CMAX) { . int N. int M. int CMAX) { /* Prototypes des fonctions appelées */ void PERMUTER(int *A. int LMAX. int C.J. } void LIRE_MATRICE (int *MAT. int CMAX). for (I=0. int DUMMY. } void ECRIRE_MATRICE (int *MAT. int *MAT3. J<I. /* Variables locales */ /* Les matrices et leurs dimensions */ int M1[30][30]. int C. int CMAX) { . . /* la plus grande des deux dimensions */ /* Transposition de la matrice */ if (*L>CMAX || *C>LMAX) return 0. J++) PERMUTER (MAT+I*CMAX+J. int DMAX. } } void PERMUTER(int *A. void LIRE_MATRICE (int *MAT. /* Variables locales */ int I.43 #include <stdio. int *C. I<DMAX. M. int CMAX). int *MAT2. int *L. int CMAX) { .int TRANSPO_MATRICE (int *MAT.

30).K. } void MULTI_2_MATRICES (int *MAT1./* MAT2 à l'aide de LIRE_DIM. MULTI_2_MATRICES ((int*)M1 . /* Multiplier MAT1 et MAT2 en affectant le résultat à MAT3 */ for (I=0. K++) *(MAT3+I*CMAX+J) += *(MAT1+I*CMAX+K) * *(MAT2+K*CMAX+J).M.30). printf("Matrice donnée 1 : \n").P. int C. */ /* Traitements */ printf("*** Matrice 1 ***\n"). .N. int P. int M. LIRE_DIM (&DUMMY.30. ECRIRE_MATRICE ((int*)M3. int LMAX. int *MAT2.30. int C. int CMAX) { . .P.30). int *C. int CMAX) { . . K<M. J<P.30). printf("Matrice résultat : \n").J. printf("*** Matrice 2 ***\n").M. ECRIRE_MATRICE ((int*)M1. (int*)M3 . LIRE_DIM (&N. return 0.30).N. for (K=0. } void ECRIRE_MATRICE (int *MAT. LIRE_MATRICE ((int*)M2. int CMAX) { . J++) { *(MAT3+I*CMAX+J)=0.30 ). ECRIRE_MATRICE ((int*)M2. printf("Matrice donnée 2 : \n"). int L.&M. LIRE_MATRICE ((int*)M1. . N.M.M.P. int N.30 ). int L. I++) for (J=0. (int*)M2 . int *MAT3. } 164 WAFAE SABBAR . .30).P.M.&P. . int CMAX) { /* Variables locales */ int I. I<N.N. } } void LIRE_DIM (int *L. } void LIRE_MATRICE (int *MAT.

scanf("%d". "r"). PRENOM).TXT". exit(-1). /* Autres variables */ char NOM[30]. NOM_FICH).1 #include <stdio.NOM).\n".PRENOM). &MATRICULE. fprintf(FICHIER. if (!FICHIER) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s. I). /* Ouverture du fichier en lecture */ FICHIER = fopen(NOM_FICH. "%d\n%s\n%s\n". } /* Affichage du fichier */ printf("*** Contenu du fichier %s ***\n". scanf("%s". NOM_FICH). while (!feof(FICHIER)) { fscanf(FICHIER. for (I=1. printf("Nombre d'enregistrements à créer : "). /* Ouverture du nouveau fichier en écriture */ FICHIER = fopen(NOM_FICH. "w"). printf("Prénom : "). printf("Numéro de matricule : ").N_ENR. FILE *FICHIER. NOM_FICH). } /* Fermeture du fichier */ fclose(FICHIER). MATRICULE). NOM. PRENOM). printf("Matricule : %d\t". printf("Nom : ").&N_ENR). NOM. MATRICULE. int MATRICULE. scanf("%s". } /* Saisie des données et création du fichier */ printf("*** Création du fichier %s ***\n".10 . LES FICHIERS SEQUENTIELS Exercice 10. PRENOM[30]. "%d\n%s\n%s\n". NOM_FICH). exit(-1). int I. scanf("%d". 165 WAFAE SABBAR . I++) { printf("Enregistrement No: %d \n".h> main() { /* Déclarations : */ /* Nom du fichier et pointeur de référence */ char NOM_FICH[] = "A:\\INFORM.\n". if (!FICHIER) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s. I<=N_ENR.&MATRICULE).h> #include <stdlib.

NOM.TXT". PRENOM). FILE *INFILE.TXT". char NOUVEAU[] = "A:\\INFBIS.h> #include <stdlib. fprintf(OUTFILE. ANCIEN). 166 WAFAE SABBAR . PRENOM[30]. } /* Ouverture du nouveau fichier en écriture */ OUTFILE = fopen(NOUVEAU.3 #include <stdio. if (!OUTFILE) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s. NOUVEAU). "r"). "%d\n%s\n%s\n". PRENOM).h> main() { /* Déclarations : */ /* Noms des fichiers et pointeurs de référence */ char ANCIEN[] = "A:\\INFORM. NOM. int MATRICULE. } /* Fermeture du fichier */ fclose(FICHIER). NOM. } /* Copie de tous les enregistrements */ while (!feof(INFILE)) { fscanf (INFILE. "%d\n%s\n%s\n".printf("Nom et prénom : %s %s\n". "w").\n". exit(-1). } Exercice 10. } Exercice 10. &MATRICULE. fclose(INFILE). } /* Fermeture des fichiers */ fclose(OUTFILE).h> #include <stdlib. PRENOM).h> main() { /* Déclarations : */ /* Noms des fichiers et pointeurs de référence */ char ANCIEN[] = "A:\\INFORM. MATRICULE. if (!INFILE) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s. /* Ouverture de l'ancien fichier en lecture */ INFILE = fopen(ANCIEN. *OUTFILE.2 #include <stdio. return 0.TXT". exit(-1). return 0. /* Autres variables */ char NOM[30].\n".

/* Copie des enregistrements de l'ancien fichier */ while (!feof(INFILE)) { fscanf (INFILE. PRENOM[30].h> main() { /* Déclarations : */ /* Noms des fichiers et pointeurs de référence */ char ANCIEN[] = "A:\\INFORM.\n". /* Autres variables */ char NOM[30]. printf("Nom : "). *OUTFILE. fclose(INFILE).TXT". char NOUVEAU[] = "A:\\INFBIS.h> #include <string.4 #include <stdio. NOM. PRENOM).NOM_NOUV. fprintf(OUTFILE. "r"). int MATRI_NOUV. scanf("%d".&MATRI_NOUV). FILE *INFILE.MATRI_NOUV. NOM. &MATRICULE. "w").char NOUVEAU[] = "A:\\INFBIS.\n".h> #include <stdlib. PRE_NOUV[30].TXT". MATRICULE. ANCIEN). /* Ouverture de l'ancien fichier en lecture */ INFILE = fopen(ANCIEN."%d\n%s\n%s\n". *OUTFILE. scanf("%s". printf("Numéro de matricule : "). NOUVEAU). exit(-1). int MATRICULE. PRENOM). } /* Saisie de l'enregistrement à ajouter */ printf("Enregistrement à ajouter : \n"). 167 WAFAE SABBAR . "%d\n%s\n%s\n".TXT". FILE *INFILE. printf("Prénom : ").PRE_NOUV).PRE_NOUV). } /* Ouverture du nouveau fichier en écriture */ OUTFILE = fopen(NOUVEAU. "%d\n%s\n%s\n". if (!INFILE) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s. /* Fermeture des fichiers */ fclose(OUTFILE). scanf("%s". return 0. if (!OUTFILE) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s. } /* Ecriture du nouvel enregistrement à la fin du fichier */ fprintf(OUTFILE. exit(-1). char NOM_NOUV[30].NOM_NOUV). } Exercice 10.

"r"). } 168 WAFAE SABBAR .\n". "%d\n%s\n%s\n". exit(-1).NOM_NOUV). */ fprintf(OUTFILE. if (strcmp(NOM.NOM. printf("Nom : "). /* et du dernier enregistrement lu. /* Ouverture de l'ancien fichier en lecture */ INFILE = fopen(ANCIEN. "%d\n%s\n%s\n". PRENOM).PRE_NOUV). "w"). */ if (TROUVE) fprintf(OUTFILE.PRE_NOUV). scanf("%d". printf("Prénom : "). /* Copie des enregistrements dont le nom */ /* précéde lexicogr."%d\n%s\n%s\n". MATRICULE. &MATRICULE. int MATRI_NOUV. } /* Ecriture du nouvel enregistrement. scanf("%s". PRENOM). /* Copie du reste des enregistrements */ while (!feof(INFILE)) { fscanf (INFILE. "%d\n%s\n%s\n". NOM. while (!feof(INFILE) && !TROUVE) { fscanf (INFILE. char NOM_NOUV[30]. } /* Ouverture du nouveau fichier en écriture */ OUTFILE = fopen(NOUVEAU. &MATRICULE. MATRICULE. } /* Saisie de l'enregistrement à insérer */ printf("Enregistrement à ajouter : \n"). NOM_NOUV) > 0) TROUVE = 1. if (!INFILE) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s. ANCIEN).PRENOM). NOM.NOM_NOUV. MATRICULE./* Autres variables */ char NOM[30]. fprintf(OUTFILE. "%d\n%s\n%s\n". NOUVEAU). int TROUVE. */ TROUVE = 0. NOM.\n". scanf("%s". else fprintf(OUTFILE. celui à insérer.MATRI_NOUV. PRENOM). PRE_NOUV[30]. if (!OUTFILE) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s. PRENOM). exit(-1). "%d\n%s\n%s\n".&MATRI_NOUV). printf("Numéro de matricule : "). PRENOM[30]. int MATRICULE. NOM.

h> 169 WAFAE SABBAR . PRENOM[30].TXT".h> #include <stdlib./* Fermeture des fichiers */ fclose(OUTFILE).\n". NOUVEAU). "w"). } /* Ouverture du nouveau fichier en écriture */ OUTFILE = fopen(NOUVEAU. if (!INFILE) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s. ANCIEN). return 0. PRENOM). } Exercice 10.\n". if (MATRICULE%10 != 8) fprintf(OUTFILE. /* Ouverture de l'ancien fichier en lecture */ INFILE = fopen(ANCIEN. int MATRICULE.h> main() { /* Déclarations : */ /* Noms des fichiers et pointeurs de référence */ char ANCIEN[] = "A:\\INFORM. "r").h> #include <stdlib. } /* Copie de tous les enregistrements à l'exception */ /* de ceux dont le numéro de matricule se termine */ /* par 8. dont le prénom est "Paul" (utiliser strcmp) #include <stdio. /* Autres variables */ char NOM[30].5 a) Supprimer les enregistrements. NOM. exit(-1). "%d\n%s\n%s\n".NOM. */ while (!feof(INFILE)) { fscanf (INFILE. "%d\n%s\n%s\n".PRENOM). } /* Fermeture des fichiers */ fclose(OUTFILE). exit(-1). return 0. char NOUVEAU[] = "A:\\INFBIS. fclose(INFILE). if (!OUTFILE) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.TXT". &MATRICULE. FILE *INFILE. *OUTFILE. dont le numéro de matricule se termine par 8 #include <stdio. } b) Supprimer les enregistrements. MATRICULE. fclose(INFILE).

&MATRICULE. if (strcmp(PRENOM. . . . . if (!PALI(NOM)) fprintf(OUTFILE. #include <stdio.CH2--) 170 WAFAE SABBAR ."Paul") != 0) fprintf(OUTFILE. } /* Fermeture des fichiers */ . /* Contrôler si la chaîne désignée par CH est un palindrome */ for (. . MATRICULE. *CH2. sinon la valeur zéro.PRENOM). /* Copie de tous les enregistrements à l'exception */ /* des palindromes.NOM. NOM. dont le nom est un palindrome. /* Ouverture du nouveau fichier en écriture */ . . . CH2++) . CH<CH2. CH2--. . */ while (!feof(INFILE)) { fscanf (INFILE. &MATRICULE. . . /* Déclarations */ . CH++. MATRICULE. "%d\n%s\n%s\n". PRENOM). } int PALI(char *CH) { /* Variable locale */ char *CH2. . "%d\n%s\n%s\n". /* Ouverture du nouveau fichier en écriture */ . /* Ouverture de l'ancien fichier en lecture */ . */ while (!feof(INFILE)) { fscanf (INFILE. PRENOM).NOM.h> main() { /* Prototype de la fonction PALI */ int PALI(char *CH). . Définir une fonction d'aide PALI qui fournit le résultat 1 si la chaîne transmise comme paramètre est un palindrome. /* Ouverture de l'ancien fichier en lecture */ . "%d\n%s\n%s\n". . /* Copie de tous les enregistrements à l'exception */ /* de ceux dont le prénom est 'Paul'. /* Placer CH2 à la fin de la chaîne */ for (CH2=CH. } /* Fermeture des fichiers */ .#include <string.PRENOM).h> main() { /* Déclarations */ . "%d\n%s\n%s\n". . . } c) Supprimer les enregistrements. .h> #include <stdlib. NOM.

J<=N_ENFANTS. PERE. enfant : ". MERE. printf("Prénom du père : "). scanf("%s". I++) { printf("Enregistrement No: %d \n". } Exercice 10. "w"). J). if (!FICHIER) { 171 WAFAE SABBAR . printf("Prénom de la mère : "). exit(-1). FILE *FICHIER. J++) { printf("Prénom %d. printf("Nom de famille : ").\n".N_ENR. scanf("%s".h> main() { /* Déclarations : */ /* Nom du fichier et pointeur de référence */ char NOM_FICH[] = "A:\\FAMILLE. N_ENFANTS). fprintf(FICHIER. int I. NOM_FICH). PERE[30].h> #include <stdlib. /* Autres variables */ char NOM[30]. scanf("%s". NOM_FICH).&N_ENR). ENFANT[30]. for (J=1. scanf("%s". fprintf(FICHIER. printf("Nombre d'enregistrements à créer : "). } } /* Fermeture du fichier */ fclose(FICHIER). printf("Nombre d'enfants : "). int J. ENFANT). "%s\n%s\n%s\n%d\n". MERE[30]. NOM).if (*CH != *CH2) return 0. } /* Saisie des données et création du fichier */ printf("*** Création du fichier %s ***\n". scanf("%d". return 1. &N_ENFANTS). I). /* Ouverture du nouveau fichier en écriture */ FICHIER = fopen(NOM_FICH.N_ENFANTS. for (I=1. /* Réouverture du fichier */ FICHIER = fopen(NOM_FICH. NOM. MERE).TXT". if (!FICHIER) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s. "%s\n".6 #include <stdio. ENFANT). PERE). "r"). I<=N_ENR. scanf("%d".

h> main() { /* Déclarations : */ /* Nom du fichier et pointeur de référence */ char NOM_FICH[] = "A:\\MOTS. PERE. MERE.TXT". N_ENFANTS). : %s %s\n". 172 WAFAE SABBAR .\n". NOM). exit(-1). do { printf("Entrez un mot ('*' pour finir) : "). NOM_FICH). NOM_FICH). exit(-1). printf("Nom du père : %s %s\n".h> #include <stdlib. NOM_FICH). CHAINE). } /* Saisie des données et création du fichier */ printf("*** Création du fichier %s ***\n". } /* Affichage du fichier */ printf("*** Contenu du fichier %s ***\n". while (!feof(FICHIER)) { fscanf (FICHIER. ENFANT). } Exercice 10. FILE *FICHIER. J<=N_ENFANTS. printf("Nom de la mère : %s %s\n". "%s\n". NOM). printf("Noms des enfants : \n". scanf("%s". ENFANT. return 0. "%s\n". /* Fermeture du fichier */ fclose(FICHIER). printf("\n"). NOM_FICH). printf("Nom de famille : %s\n". if (CHAINE[0] != '*') fprintf(FICHIER. NOM). "%s\n%s\n%s\n%d\n". if (!FICHIER) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s. MERE. NOM).\n".7 #include <stdio. PERE. printf("\t%d. &N_ENFANTS). J++) { fscanf(FICHIER. /* Autres variables */ char CHAINE[50]. for (J=1. CHAINE). /* Ouverture du nouveau fichier en écriture */ FICHIER = fopen(NOM_FICH. } while (CHAINE[0] != '*'). } } /* Fermeture du fichier */ fclose(FICHIER). "w"). J.printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s. NOM.

/* Placer CH2 à la fin de la chaîne */ for (CH2=CH. */ L_TOT =0. L_TOT += LONG_CH(CHAINE). *CH2. exit(-1). } /* Compter les palindromes et accumuler */ /* les longueurs des mots. int LONG_CH(char *CH). return 0.1f \tcaractères et\n". CHAINE).\n". N_PALI=0.8 #include <stdio.TXT". /* Autres variables */ char CHAINE[50].h> #include <stdlib. N_PALI). "r"). if (!FICHIER) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s. /* Déclarations : */ /* Nom du fichier et pointeur de référence */ char NOM_FICH[] = "A:\\MOTS. } /* Fermeture du fichier */ fclose(FICHIER). (float)L_TOT/N_MOTS). printf("\t%d \tpalindromes\n". while (!feof(FICHIER)) { fscanf(FICHIER. N_MOTS++. /* nombre de palindromes */ int N_MOTS. printf("\t%. N_PALI += PALI(CHAINE). /* Affichage des résultats */ printf("Le fichier %s contient :\n". /* longueur totale de tous les mots */ /* Ouverture du nouveau fichier en écriture */ FICHIER = fopen(NOM_FICH. /* nombre de mots */ int L_TOT.h> main() { /* Prototypes des fonctions appelées */ int PALI(char *CH).return 0. N_MOTS=0. FILE *FICHIER. NOM_FICH). } int PALI(char *CH) { /* Variable locale */ char *CH2. } Exercice 10. int N_PALI. CH2++) 173 WAFAE SABBAR . NOM_FICH). printf("\t%d \tmots d'une longueur moyenne de :\n". N_MOTS). "%s\n".

/* ligne où la dernière permutation a eu lieu */ /* permet de ne pas trier un sous-ensemble déjà trié */ /* Ouverture de l'ancien fichier en lecture */ INFILE = fopen(ANCIEN. } Exercice 10. } int LONG_CH(char *CH) { char *P. /* Autres variables */ char CHAINE[50].\n".TXT". *P. /* pour la permutation */ int N_MOTS. CH++. char NOUVEAU[] = "A:\\MOTS_TRI.CH2--) if (*CH != *CH2) return 0. /* indice courant */ int FIN.h> main() { /* Déclarations : */ /* Noms des fichiers et pointeurs de référence */ char ANCIEN[] = "A:\\MOTS. "%s\n". /* Lecture du fichier dans la mémoire centrale */ while (!feof(INFILE)) { fscanf (INFILE. /* Tableau de pointeurs */ char *TAB[50]. *OUTFILE. /* Contrôler si la chaîne désignée par CH est un palindrome */ for (. } /* Initialisation du du compteur des mots */ N_MOTS = 0. CH2--. /* nombre de mots du fichier */ int I. ANCIEN). else 174 WAFAE SABBAR . CHAINE). CHAINE). return 1. for (P=CH . /* ligne à partir de laquelle TAB est trié */ int J. "r").. FILE *INFILE. char *AIDE. P++) .TXT". /* Réservation de la mémoire */ TAB[N_MOTS] = malloc(strlen(CHAINE)+1). if (TAB[N_MOTS]) strcpy(TAB[N_MOTS]. CH<CH2. exit(-1).9 #include <stdio.h> #include <string. if (!INFILE) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s. return P-CH.h> #include <stdlib.

"r"). AIDE = TAB[J].10 #include <stdio. TAB[J] = TAB[J+1].\n". exit(-1).h> #include <stdlib.h> main() { /* Déclarations : */ /* Noms des fichiers et pointeurs de référence */ char NOM_FICH[] = "A:\\NOMBRES. TAB[J+1] = AIDE. FILE *FICHIER. 175 WAFAE SABBAR . I>0 . } N_MOTS++. I++) fprintf(OUTFILE. if (!OUTFILE) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s. NOUVEAU). TAB[I]). } /* Fermeture du fichier */ fclose(INFILE). for (J=0. "%s\n".TAB[J+1])>0) { FIN=J. return 0. if (!FICHIER) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s. /* somme des nombres */ /* Ouverture de l'ancien fichier en lecture */ FICHIER = fopen(NOM_FICH. } /* Copie du tableau dans le nouveau fichier */ for (I=0. exit(-1). } } /* Ouverture du nouveau fichier en écriture */ OUTFILE = fopen(NOUVEAU. I<N_MOTS. */ for (I=N_MOTS-1 . J<I.\n". /* compteur des nombres */ long SOMME. /* nombre actuel lu dans le fichier */ int N. /* Tri du tableau par propagation de l'élément maximal.TXT". I=FIN) { FIN=0. "w"). J++) if (strcmp(TAB[J].{ printf("\aPas assez de mémoire \n"). /* Autres variables */ int NOMBRE. /* Fermeture du fichier */ fclose(OUTFILE). NOM_FICH). exit(-1). } Exercice 10.

"%d\n". ANCIEN). /* Copier tous les caractères et remplacer le */ /* premier retour à la ligne d'une suite par */ 176 WAFAE SABBAR . (float)SOMME/N). return 0. ANCIEN). } Exercice 10. SOMME). /* caractère lu dans le fichier */ char N_RET. SOMME=0. NOM_FICH. NOUVEAU).\n".} /* Lecture du fichier et comptabilité */ N=0. "r"). /* Compteur des retours à la ligne consécutifs */ /* Ouverture de l'ancien fichier en lecture */ do { printf("Nom du fichier source : "). "w"). if (!INFILE) printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s. N++. while (!feof(FICHIER)) { fscanf (FICHIER. } /* Fermeture du fichier */ fclose(FICHIER). /* Ouverture du nouveau fichier en écriture */ do { printf("Nom du nouveau fichier : "). printf("La moyenne des nombres est : %f\n". } while (!OUTFILE). FILE *INFILE. NOUVEAU). if (!OUTFILE) printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s. /* Affichage des résultats */ printf("Le fichier %s contient %d nombres. &NOMBRE). SOMME += NOMBRE. } while (!INFILE). NOUVEAU[30]. printf("La somme des nombres est : %ld\n".11 #include <stdio. OUTFILE = fopen(NOUVEAU. scanf("%s". /* Autres variables */ char C. INFILE = fopen(ANCIEN. N).\n". scanf("%s". *OUTFILE.h> main() { /* Déclarations : */ /* Noms des fichiers et pointeurs de référence */ char ANCIEN[30].\n".

} } Il est possible de réunir plusieurs instructions dans le bloc conditionnel de la structure while. en les séparant par des virgules.h> main() { /* Prototype de la fonction FIN_PHRASE */ int FIN_PHRASE(char C). if (N_RET > 1) fputc('\n'. on retrouve cette solution souvent pour éviter des constructions inutilement lourdes: while (C=fgetc(INFILE). .12 #include <stdio. if (!feof(INFILE)) { if (C == '\n') { N_RET++. . } } } /* Fermeture des fichiers */ fclose(OUTFILE). il faut s'assurer encore une fois que le caractère lu est différent de EOF. fputc(C. else fputc(' '. if (!feof(INFILE)) { . } Exercice 10. /* Déclarations : */ 177 WAFAE SABBAR . . En pratique. OUTFILE). */ N_RET=0. Nous obtenons ainsi une construction un peu lourde: while (!feof(INFILE)) { C=fgetc(INFILE). } else { N_RET=0. fclose(INFILE). OUTFILE). return 0. while (!feof(INFILE)) { C=fgetc(INFILE)./* un espace. . } Remarque : Après la lecture par fgetc. !feof(INFILE)) { . OUTFILE).

/* Noms des fichiers et pointeurs de référence */ char NOM_FICH[30]; FILE *FICHIER; /* Autres variables */ char C; /* caractère lu dans le fichier */ char NP; /* Compteur de phrases */ /* Ouverture de l'ancien fichier en lecture */ do { printf("Nom du fichier texte : "); scanf("%s", NOM_FICH); FICHIER = fopen(NOM_FICH, "r"); if (!FICHIER) printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", NOM_FICH); } while (!FICHIER); /* Compter les symboles de fin de phrase */ NP=0; while (!feof(FICHIER)) NP += FIN_PHRASE(fgetc(FICHIER)); /* Fermeture du fichier */ fclose(FICHIER); /* Affichage du résultat */ printf("Le fichier %s contient %d phrases.\n", NOM_FICH, NP); return 0; } int FIN_PHRASE(char C) { return (C=='.' || C=='!' || C=='?'); }

Exercice 10.13
#include <stdio.h> main() { /* Prototype de la fonction FIN_PHRASE */ int SEPA(char C); /* Déclarations : */ /* Noms des fichiers et pointeurs de référence */ char NOM_FICH[30]; FILE *FICHIER; /* Autres variables */ char C; /* caractère lu dans le fichier */ int ABC[26]; /* compteurs des lettres de l'alphabet */ int NTOT; /* nombre total des caractères */ int NAUTRES; /* nombre des caractères qui ne font pas partie de l'alphabet */ int NMOTS; /* nombre des mots */ int NPARA; /* nombre de paragraphes (retours à la ligne) */ int I; /* indice d'aide */ int DANS_MOT; /* indicateur logique: */ /* vrai si la tête de lecture se trouve */ /* actuellement à l'intérieur d'un mot. */

178

WAFAE SABBAR

/* Ouverture de l'ancien fichier en lecture */ do { printf("Nom du fichier texte : "); scanf("%s", NOM_FICH); FICHIER = fopen(NOM_FICH, "r"); if (!FICHIER) printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", NOM_FICH); } while (!FICHIER); /* Initialisations des variables */ for (I=0; I<26; I++) ABC[I]=0; NTOT =0; NAUTRES =0; NMOTS =0; NPARA =0; DANS_MOT=0; /* Examination des caractères du fichier */ while (!feof(FICHIER)) { C=fgetc(FICHIER); if (!feof(FICHIER)) { /* Comptage au niveau caractères */ if (C=='\n') NPARA++; else { NTOT++; if (C>='a' && C<='z') ABC[C-'a']++; else if (C>='A' && C<='Z') ABC[C-'A']++; else NAUTRES++; }

/* Comptage des mots */ if (SEPA(C)) { if (DANS_MOT) { NMOTS++; DANS_MOT=0; } } else DANS_MOT=1; } } /* Fermeture du fichier */ fclose(FICHIER); /* Affichage du résultat */ printf("Votre fichier contient :\n"); printf("\t%d paragraphes\n", NPARA);

179

WAFAE SABBAR

printf("\t%d mots\n", NMOTS); printf("\t%d caractères\ndont\n", NTOT); for (I=0; I<26; I++) printf("\t%d fois la lettre %c\n", ABC[I], 'a'+I); printf("et %d autres caractères\n", NAUTRES); return 0; }

int SEPA(char C) { /* Tableau contenant tous les séparateurs de mots */ char SEP[12] = { '\n', ' ', ',', ';', '.', ':', '?', '!', '(', ')', '"', '\'' }; int I; /* Comparaison de C avec tous les éléments du tableau */ for (I=0 ; C!=SEP[I] && I<12 ; I++) ; if (I==12) return 0; else return 1; /* ou bien simplement : */ /* return (I != 12); */

Exercice 10.14
#include <stdio.h> main() { /* Noms des fichiers et pointeurs de référence */ char NOM_FICH[30]; FILE *FICHIER; /* Autres variables */ char C; /* caractère actuel */ int NLIGNE, NCOLO; /* position actuelle sur l'écran */ /* Ouverture de l'ancien fichier en lecture */ do { printf("Nom du fichier texte : "); scanf("%s", NOM_FICH); FICHIER = fopen(NOM_FICH, "r"); if (!FICHIER) printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n", NOM_FICH); } while (!FICHIER) ; getchar(); /* Initialisations des variables */ NLIGNE = 0; NCOLO = 0; /* Affichage du fichier */ while (!feof(FICHIER)) { C=fgetc(FICHIER); if (!feof(FICHIER)) { NCOLO++; if (NCOLO==80 || C=='\n') /* fin de la ligne */

180

WAFAE SABBAR

} } /* Fermeture du fichier */ fclose(FICHIER). } /* Lecture des nombres et appel de la fonction CCP_TEST /* A l'aide de la chaîne de format. FILE *FICHIER.h> #include <stdlib. NLIGNE=1. /* en int et affecte les résultats aux variables COMPTE /* et CONTROLE. int CONTROLE). les convertit en long resp. CONTROLE).15 #include <stdio.\n".C). /* nombre de contrôle */ /* Ouverture du fichier CCP. &COMPTE. /* Déclarations : */ /* Noms des fichiers et pointeurs de référence */ char NOM_FICH[] = "A:\\CCP. */ while (!feof(FICHIER)) { fscanf (FICHIER.C). return 0. scanf lit les deux /* parties du nombre de CCP.{ NLIGNE++. } /* Fermeture du fichier */ fclose(FICHIER).TXT". return 0. CCP_TEST(COMPTE. } */ */ */ */ 181 WAFAE SABBAR . &CONTROLE). "%ld-%d\n". } Exercice 10. NOM_FICH). NCOLO=1.TXT en lecture */ FICHIER = fopen(NOM_FICH. if (NLIGNE==25) /* fin de l'écran */ { getchar(). "r").h> main() { /* Prototype de la fonction CCP_TEST */ void CCP_TEST(long COMPTE. /* Autres variables */ long COMPTE. /* nombre du compte CCP */ int CONTROLE. } printf("%c". if (!FICHIER) { printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s. exit(-1). } else printf("%c".

*TFUS. /* pointeurs pour les tableaux */ int LA. FA = fopen(FICH_A. if (!FA) printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s. int CONTROLE) { int RESTE. "r"). /* Déclarations : */ /* Noms des fichiers et pointeurs de référence */ char FICH_A[30]. FICH_A). COMPTE. *TABB.\n". /* Autres variables */ int *TABA. scanf("%s". *FFUS. int M). FICH_FUS[30]. } 182 WAFAE SABBAR . /* Fermeture du fichier FA */ fclose(FA). } Exercice 10. /* Détection de la longueur de FA */ for (LA=0. /* Indice d'aide */ /* Ouverture du fichier FA en lecture */ do { printf("Nom du fichier FA : "). LA++) fscanf(FA. } while (!FA). CONTROLE). RESTE = COMPTE % 97. else printf ("Le nombre CCP %ld-%d n'est pas valide\n". int *FUS. /* Longueurs de FA et FB */ int N. FILE *FA. /* Nombre lu ou écrit dans un fichier */ int I. /* Allocation de la mémoire pour TABA */ TABA = malloc (LA*sizeof(int)). FICH_B[30]. LB. if (RESTE == 0) RESTE = 97. CONTROLE). &N). int *B.void CCP_TEST(long COMPTE."%d\n". !feof(FA).16 #include <stdio. if (!TABA) { printf("\a Pas assez de mémoire pour TABA\n"). *FB.h> #include <stdlib. FICH_A). if (RESTE == CONTROLE) printf ("Le nombre CCP %ld-%d est valide\n". exit(-1).h> main() { /* Prototype de la fonction FUSION */ void FUSION(int *A. int N. COMPTE.

TABB. /* Mêmes opérations pour FB : */ /* Ouverture du fichier FB en lecture */ do { printf("Nom du fichier FB : "). LA.\n". !feof(FB). if (!TFUS) { printf("\a Pas assez de mémoire pour TFUS\n"). TABB+I). } /* Réouverture du fichier FB en lecture */ FB = fopen(FICH_B. FICH_B). } while (!FB). TABA+I). FFUS = fopen(FICH_FUS. /* Fermeture du fichier FB */ fclose(FB)./* Réouverture du fichier FA en lecture */ FA = fopen(FICH_A. if (!TABB) { printf("\a Pas assez de mémoire pour TABB\n"). } /* Fusion des tableaux TA et TB dans TFUS */ FUSION (TABA. exit(-1). scanf("%s". LB). /* Allocation de la mémoire pour TABB */ TABB = malloc (LB*sizeof(int)). /* Fermeture du fichier FA */ fclose(FA). /* Ouverture du fichier FFUS en écriture */ do { printf("Nom du fichier FFUS : "). FB = fopen(FICH_B. LB++) fscanf(FB. &N). FICH_FUS). TFUS."%d\n". scanf("%s". /* Copie du contenu de FB dans TABB */ for (I=0. I++) fscanf(FB. /* Détection de la longueur de FB */ for (LB=0. /* Copie du contenu de FA dans TABA */ for (I=0. /* Allocation de la mémoire pour TFUS */ TFUS = malloc ((LA+LB)*sizeof(int)). I<LA. exit(-1). "r"). /* Fermeture du fichier FB */ fclose(FB). "w"). I<LB. "r")."%d\n". if (!FB) printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s. "r"). I++) fscanf(FA. if (!FFUS) 183 WAFAE SABBAR . FICH_B)."%d\n".

IFUS++. /* Fusion de A et B dans FUS */ IA=0. B et FUS */ int IA. IFUS++. int *FUS. IB++.IFUS."%d\n". */ while (IA<N) { *(FUS+IFUS)=*(A+IA). *(TFUS+I)). } while (IB<M) { *(FUS+IFUS)=*(B+IB). I++) fprintf(FFUS. } } 184 WAFAE SABBAR . while ((IA<N) && (IB<M)) if (*(A+IA)<*(B+IB)) { *(FUS+IFUS)=*(A+IA). /* Copier le contenu de TFUS dans FFUS */ for (I=0.IB. IA++. } /* Si A ou B sont arrivés à la fin. IFUS=0. return 0. int M) { /* Variables locales */ /* Indices courants dans A. IB++. IA++. } void FUSION(int *A.printf("\aERREUR: Impossible d'ouvrir " "le fichier: %s.\n". } while (!FFUS). I<(LA+LB). IFUS++. FICH_FUS). alors */ /* copier le reste de l'autre tableau. IFUS++. /* Fermeture du fichier FFUS */ fclose(FFUS). int *B. int N. IB=0. } else { FUS[IFUS]=B[IB].

Sign up to vote on this title
UsefulNot useful