Vous êtes sur la page 1sur 184

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

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

...5 .. (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.. sans perdre en précision.. binaire 01770 8100 0XAAAA 1001001001 1100101011111110 10000 0234 5 WAFAE SABBAR . 2. TYPES DE BASE.......3 Complétez le tableau suivant: base décimale base octale base hexadécimale représ...14159265 1015 2*107 10000001 2*10-7 10000001 -1.BASE.2 305.. 300} {-120 . 326} {-1280 . Choisissez les types les plus économiques. 210} {-47 ..05*1050 0..Y MESURE SURFACE1 SURFACE2 N1 N2 N3 N4 TROUVE {0 .... 150075} {-12 ... 1285} {vrai. 1500750.. 47} {0 .122212 0 -12 Traduisez les déclarations suivantes en C..5 125 -220 32000 0 -3000005. 100} {-10 .. sachant que vous travaillerez dans les ensembles de nombres indiqués. OPERATEURS ET EXPRESSIONS Exercice 2..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. 104} {0.....5} {0 ..000000001 410 50000 2 410 50000 -2 3. faux} Exercice 2......0001 (13) Exercice 2.

23ul 70000u 0 0. * l'hypoténuse d'un triangle rectangle de côtés A et B.5. (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. Exercice 2.4 Pour les constantes correctement définies. scanf("%lf".4 0123l 40000 o \r 345LU '\n' 40000u '\0' 01001 34.0l -1. #include <stdio.Exercice 2. &A).6 Eliminer les parenthèses superflues dans les expressions de l'exercice 3.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é.h> main() { double A. B 6 WAFAE SABBAR .0e-1 1e1f 'O' 0XEUL Exercice 2. /* Saisie de A et B */ printf("Introduire la valeur pour A : "). * la tangente de A en n'utilisant que les fonctions sin et cos. double RES. * la valeur arrondie (en moins) de A/B.7 Essayez le programme suivant et modifiez-le de façon à ce qu'il affiche: *A . trouvez les types et les valeurs numériques décimales: 12332 0xeba 0FE0 '0' 67e0 23. double B.5L 1. * la valeur arrondie (en moins) à trois positions derrière la virgule de A/B.0 -1.

RES). } Exercice 2.printf("Introduire la valeur pour B : "). char B = 'A'.0) / C 7 WAFAE SABBAR . short C = 10.8 Soient les déclarations: long A = 15. &B). /* Affichage du résultat */ printf("Le carré de B est %f \n". /* Affichage du résultat */ printf("Le carré de A est %f \n". scanf("%lf". /* 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. /* Calcul */ RES = B*B. return 0. RES). /* Calcul */ RES = A*A.

N). N.h> main() { int N=10. N=5. N. N). Exercice 3. N = 5. printf ("E : N=%d P=%d Q=%d\n". trouvez et notez les résultats du programme ci-dessus. N = 5. N = 5.1 #include <stdio. P. 0. Q=10. ("I : %x %x\n". Q = ++N == 3 && ++P == 3. C. P. é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.2 En vous référant aux exemples du chapitre 3. b) Vérifiez vos résultats à l'aide de l'ordinateur. P = 2. } a) Sans utiliser l'ordinateur. N). N. printf printf printf return ("G : %c %c\n". printf ("C : N=%d P=%d Q=%d\n". Q = ++N == 6 && ++P == 3. N=C.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. Q). R. P.2. P = 2. C. C. printf ("F : N=%d P=%d Q=%d\n". Q = N++ < P || P++ != 3. LIRE ET ÉCRIRE DES DONNÉES Exercice 3. Essayez d'introduire des nombres de différents formats et différentes grandeurs.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 . P=2. Q). N. P = 2. Exercice 3. Q). P. Q = N++ > P || P++ != 3. ("H : %d %d\n". Q). * Changez la partie format du programme de façon à séparer les différentes données par le symbole '-' . printf ("D : N=%d P=%d Q=%d\n". P=5. char C='S'.

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.8 Ecrire un programme qui calcule la somme de quatre nombres du type int entrés au clavier.a) en employant getchar et printf. Exercice 3. 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. B. Exercice 3. 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.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. C ==> A Exercice 3. Utilisez la formule : S = P(P-A)(P-B)(P-C) où A.4 Ecrire un programme qui permute et affiche les valeurs de trois variables A.6 Ecrire un programme qui affiche la résistance équivalente à trois résistances R1. R3 (type double).si les résistances sont branchées en parallèle: Exercice 3. 9 WAFAE SABBAR .7 Ecrire un programme qui calcule et affiche l'aire d'un triangle dont il faut entrer les longueurs des trois côtés. C sont les longueurs des trois côtés (type int) et P le demi-périmètre du triangle. R2. C de type entier qui sont entrées au clavier : A ==> B . b) en employant getch et printf. B ==> C . Exercice 3. B.si les résistances sont branchées en série: Rsér = R1+R2+R3 . .

YA) et (XB. YB) sont entrées au clavier comme entiers.(Déduisez la formule du calcul de celle indiquée ci-dessus) Exercice 3. 10 WAFAE SABBAR .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.

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

Exercice 4. ..b) if . Exercice 4.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. B et C par échanges successifs de manière à obtenir : val(A) val(B) val(C) Affichez les trois valeurs. Considérez aussi les cas où l'utilisateur entre des valeurs nulles 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. Utilisez la fonction fabs de la bibliothèque <math>. Triez les valeurs A. Utilisez des variables du type int pour A. B et C. Affichez les résultats et les messages nécessaires sur l'écran. pour A.else if . Exercice 4.. B et C. pour A et B.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..4 Ecrivez un programme qui lit trois valeurs entières (A. deux ou aucune solution réelle. B et C) au clavier. si l'équation a une. 2 12 WAFAE SABBAR .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.

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

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.le type double .. Exemple: Entrée: 1 2 3 4 0 Affichage: 4321 Exercice 5.G. 14 WAFAE SABBAR . ..11 Calculez le P.C. Utilisez le schéma de Horner qui évite les opérations d'exponentiation lors du calcul: Exercice 5. .D. de deux entiers naturels entrés au clavier en utilisant l'algorithme d'EUCLIDE. Exercice 5. des coefficients An.le type long ..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 + . terminée par zéro (Contrôlez s'il s'agit vraiment de chiffres). A0 et de X seront entrées au clavier. Exemple: Entrée: 1234 Affichage: 4321 Exercice 5.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.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 : .le type long double Exercice 5..le type int . + A1X + A0 Les valeurs de n.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.

... La 3e approximation de la racine carrée de .14 Affichez un triangle isocèle formé d'étoiles de N lignes (N est fourni au clavier): Nombre de lignes : 8 * *** ***** ******* ********* *********** ************* *************** Exercice 5.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 . est .. ... .. c) Affichez lors du calcul toutes les approximations calculées : La 1ère approximation de la racine carrée de . est ..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 . Exercice 5. La 2e approximation de la racine carrée de . plus petit que 50..

Exercice 6.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.3 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. Remplir le tableau par des valeurs entrées au clavier et afficher le tableau ainsi que la somme de tous ses éléments. 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. Ranger ensuite les éléments du tableau T dans l'ordre inverse sans utiliser de tableau d'aide. Afficher le tableau résultant. remplit le tableau par des valeurs entrées au clavier et affiche le tableau. 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.6 . Exercice 6.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).4 Ecrire un programme qui lit la dimension N d'un tableau T du type int (dimension maximale: 50 composantes). Exercice 6. remplit le tableau par des valeurs entrées au clavier et affiche le tableau. LES TABLEAUX Exercice 6. Calculer et afficher ensuite la somme des éléments du tableau. Exemple: 16 WAFAE SABBAR . Exercice 6.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). Afficher le tableau résultant. Effacer ensuite toutes les occurrences de la valeur 0 dans le tableau T et tasser les éléments restants.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. Exercice 6. 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.1 Ecrire un programme qui lit la dimension N d'un tableau T du type int (dimension maximale: 50 composantes). Afficher les tableaux TPOS et TNEG.

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.. le programme retiendra la position du premier maximum ou minimum rencontré..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 + . + A1X + A0 Les valeurs des coefficients An. .. Exemple: / | 3 \ \ / -4 | * | 2 / \ \ 5 | = 3*2+2*(-3)+(-4)*5 = -20 / 2 -3 Exercice 6./ \ | a b c d | | e f g h | | i j k l | \ / Exercice 6. a) Utilisez la fonction pow() pour le calcul.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. Exercice 6.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). ième 17 WAFAE SABBAR . b) Utilisez le schéma de Horner qui évite les opérations d'exponentiation: Exercice 6. Si le tableau contient plusieurs maxima ou minima. . Afficher ensuite la valeur et la position du maximum et du minimum. la (N+1) indéfinie. A0 seront entrées au clavier et mémorisées dans un tableau A de type float et de dimension n+1. 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..

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

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. 19 WAFAE SABBAR .15 Tri par propagation (bubble sort) Problème: Classer les éléments d'un tableau A par ordre croissant. le tableau est trié. Méthode: En recommençant chaque fois au début du tableau. le plus grand élément du tableau vers la fin du tableau (comme une bulle qui remonte à la surface d'un liquide).Exercice 6. par permutations successives. on effectue à plusieurs reprises le traitement suivant: On propage. * Si aucune permutation n'a eu lieu.

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

. telles que: / 1 si A[i.j] est un minimum MIN[i.j = Pi-1. 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 + 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] = | sur la ligne i \ 0 sinon / 1 si A[i. Ces éléments sont appelés des points-cols.j-1 Exercice 6.Calculer les valeurs entre les éléments initialisés de gauche à droite en utilisant la relation: Pi. Afficher les positions et les valeurs de tous les points-cols trouvés.j] est un maximum MAX[i.j] = | sur la colonne j \ 0 sinon 23 WAFAE SABBAR .

e) char e[5] = "cinq". c) toute variable TXT. LES CHAÎNES DE CARACTÈRES Exercice 7.. g) char g[2] = {'a'. Les modifications se feront dans la même variable TXT. . séparés par des espaces et qui les affiche ensuite dans une ligne.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. après avoir inversé l'ordre des voici une petite phrase ! ! esarhp etitep enu iciov Exercice 7. a) char a[] = "un\ndeux\ntrois\n".. c) char c[] = 'abcdefg'. . b) char b[12] = "un deux trois". la phrase à rebours. f) char f[] = "Cette " "phrase" "est coupée". i) char i[4] = "'o'". Exercice 7. Les mots sont mémorisés dans 5 variables M1. b) le nombre de 'e' contenus dans le texte. sans changer le contenu de la d) toute la caractères dans TXT: phrase à rebours.M5. h) char h[4] = {'a'.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.7 . Exemple voici une petite phrase ! ! phrase petite une voici Exercice 7.2 Ecrire un programme qui lit 5 mots. 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'}. Exemple: Cette ligne contient quelques lettres e.5 24 WAFAE SABBAR . mais dans l'ordre inverse. Ctt lign contint qulqus lttrs .1. '\0'}. 'b'. d) char d[10] = 'x'.

atoi(STR)). 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. Employer la fonction strlen. strcat et strlen.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. = = = = %s \n".9 Soient les instructions: char STR[200]. %d \n". printf("Entrée printf("integer printf("long printf("double nombre :"). Exemple: Introduisez votre nom et votre prénom: Mickey Mouse Bonjour Mickey Mouse ! Votre nom est composé de 11 lettres.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. atof(STR)). puts("Entrez un gets(STR). atol(STR)). b) Utiliser uniquement les fonctions gets et puts. %f \n". Exercice 7. STR). %ld \n". a) Utiliser les fonctions spéciales de <string>.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. Utiliser les fonctions gets. Contrôlez s'il s'agit bien d'un verbe en "er" avant de conjuguer. 25 WAFAE SABBAR .6 Ecrire un programme qui lit deux chaînes de caractères CH1 et CH2. puts. Afficher le résultat. Exemple: Verbe : fêter je fête tu fêtes il fête nous fêtons vous fêtez ils fêtent Exercice 7. Exercice 7.

<b>) ultoa (<n_uns_long>. 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. 33 byte est la base pour la conversion (2 . <b>) ltoa (<n_long>. ltoa et ultoa qui convertissent des entiers en chaînes de caractères. Afficher le tableau trié. . <chaîne de formatage>. La conversion se fait dans la base <b>. <s>.12 26 WAFAE SABBAR . 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.3.Quelles sont les valeurs affichées si on entre les chaînes de caractères suivantes: a) 123 b) -123 c) .. Conversion de nombres en chaînes de caractères itoa (<n_int>. Trier les 10 mots lexicographiquement en utilisant les fonctions strcmp et strcpy.11 Ecrire un programme qui lit 10 mots et les mémorise dans un tableau de chaînes de caractères. Si on se limite aux systèmes fonctionnant sous DOS.14). ) Exercice 7.10 Ecrivez un petit programme utilisant la fonction ltoa qui sert à contrôler les résultats de l'exercice 3. on peut quand même utiliser les fonctions itoa. <expr2>. <expr1>.123 d) 123. <s>. <s>. Exercice 7.45 e) 12E3 f) 1234f5 g) -1234567 h) 123e-02 i) -0. <b>) Chacune de ces trois procédures convertit son premier argument en une chaîne de caractères qui sera ensuite attribuée à <s>. . <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. Syntaxe: sprintf( <chaîne cible>. Utilisez la méthode de tri par sélection directe (voir Exercice 6. ..

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

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.8 . A=++*P2**P1. A B C P1 P2 Init. *P1=(*P2)++. LES POINTEURS Exercice 8. ++*P2. *P1-=*P2. Utiliser le formalisme pointeur à chaque fois que cela est possible. P1=&A. *P1*=*P2.1 main() { int A = 1. int B = 2. *P2=*P1/=*P2. Exercice 8. 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. P1=&A. P1=P2. P2=&C. P2=&B. int C = 3. } Copiez le tableau suivant et complétez-le pour chaque instruction du programme ci-dessus.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.4 1 2 3 / / 1 2 3 &A / 30 WAFAE SABBAR . *P2. return 0. Exercice 8. int *P1.

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. un programme qui vérifie sans utiliser une fonction de <string>. 78. Exercice 8. Le programme utilisera des pointeurs P1 et P2 et une variable numérique AIDE pour la permutation des éléments. Exercice 8. 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. Exercice 8. 56. P = A. 90}. Quelles valeurs ou adresses fournissent ces expressions: a) b) c) d) e) f) g) h) Exercice 8.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.Soit P un pointeur qui 'pointe' sur un tableau A: int A[] = {12. Utiliser un pointeur P. *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 . Le programme n'utilisera pas de variables numériques.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. la fonction isspace et une variable numérique N qui contiendra le nombre des mots. int *P. une variable logique. 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. Exercice 8. 34. Utiliser deux pointeurs PA et PB pour le transfer et afficher le tableau résultant A. 67.6 Ecrire un programme qui range les éléments d'un tableau A du type int dans l'ordre inverse. 23. 45. Le programme utilisera les pointeurs P1 et P2 pour parcourir le tableau.8 Ecrire de deux façons différentes.

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.12 Ecrire un programme qui lit un caractère C et une chaîne de caractères CH au clavier. Exercice 8. Exemples: Alphonse phon ==> Alse totalement t ==> otalement abacab aa ==> abacab texte (max.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. Ensuite toutes les occurrences de C dans CH seront éliminées. 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. Le reste des caractères dans CH sera tassé à l'aide d'un pointeur et de la fonction strcpy. 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. une variable logique TROUVE et la fonction strcpy. une variable logique TROUVE et la fonction strcpy. 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. Utiliser deux pointeurs P1 et P2.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. Utiliser uniquement des pointeurs.16 32 WAFAE SABBAR . Exemples: Bonjour Bravo ==> njou Bonjour bravo ==> Bnjou abacab aa ==> bcab Exercice 8.Exercice 8. 100 caractères) : contient : 'A' 'E' 'J' 'N' Exercice 8.

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

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

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

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

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

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

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

Ecrire un petit programme qui teste la fonction TRANSPO_MATRICE. 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. Exercice 9.43 4 42 WAFAE SABBAR . Ecrire un petit programme qui teste la fonction SOMME_MATRICE. TRANSPO_MATRICE retourne une valeur logique qui indique si les dimensions de la matrice sont telles que la transposition a pu être effectuée.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. L. Implémenter les fonctions en choisissant bien le type des paramètres et utiliser un dialogue semblable à celui de LIRE_TAB. Exercice 9. Choisir les paramètres nécessaires. 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. C et CMAX qui affiche les composantes de la matrice de dimensions L et C.38 Ecrire la fonction ECRIRE_MATRICE à quatre paramètres MAT.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.37 a) Ecrire la fonction LIRE_DIM à quatre paramètres L.42 Ecrire la fonction TRANSPO_MATRICE à cinq paramètres MAT.Ecrire la fonction ENTIER_CH qui construit une chaîne de caractères CH qui représente un nombre entier N du type long. L. Exercice 9.39 Ecrire la fonction SOMME_MATRICE du type long qui calcule la somme des éléments d'une matrice MAT du type int. Les dimensions L et C doivent être inférieures à LMAX respectivement CMAX. C. Exercice 9. Exercice 9. Idée pour la conversion : Multiplier N par 10 et utiliser ENTIER_CH. LMAX. Exercice 9. Exercice 9. N et CH sont les paramètres de la fonction DOUBLE_CH. Exercice 9. C. LMAX. et CMAX qui lit les composantes d'une matrice MAT du type int et de dimensions L et C. b) Ecrire la fonction LIRE_MATRICE à quatre paramètres MAT. C. Utiliser la fonction INVERSER_CH définie plus haut. Représenter schématiquement la hiérarchie des appels des fonctions utilisées. L.

22. Ecrire un petit programme qui teste la fonction MULTI_2_MATRICES. (Méthode de calcul: voir exercice 7.) 43 WAFAE SABBAR .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.

TXT et sauver le nouveau fichier sous le nom INFBIS.10 .3 Ajouter un nouvel enregistrement (entré au clavier) à la fin de INFORM.TXT qui est la copie exacte (enregistrement par enregistrement) du fichier INFORM.TXT.TXT. Exercice 10.2 Ecrire un programme qui crée sur disquette un fichier INFBIS.1 Créer sur disquette puis afficher à l'écran le fichier INFORM. Exercice 10. Exercice 10. LES FICHIERS SEQUENTIELS Exercice 10.TXT. Exercice 10.6 Créer sur disquette puis afficher à l'écran le fichier FAMILLE. sinon la valeur zéro. Exercice 10.TXT.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.4 Insérer un nouvel enregistrement dans INFORM. 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 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 en supposant que le fichier est trié relativement à la rubrique NOM et sauver le nouveau fichier sous le nom INFBIS. Sauver le nouveau fichier à chaque fois sous le nom INFBIS.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.5 Supprimer dans INFORM.

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

. 3 fois la lettre z et 470 autres caractères Exercice 10. . Utiliser la fonction getchar. .fin de ligne .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. Exemple: Nom du fichier texte : A:LITTERA.parenthèses: ( ) .TXT Votre fichier contient: 12 paragraphes 571 mots 4186 caractères dont 279 fois la lettre a 56 fois la lettre b . Nombre de CCP 50537-97 : 50537 modulo 97 = 0 correct correct incorrect correct WAFAE SABBAR 46 . On admettra que deux mots sont toujours séparés par un ou plusieurs des caractères suivants: . Un numéro de CCP est composé de trois parties: un numéro de compte.15 Ecrire un programme qui vérifie la validité d'une série de numéros de CCP mémorisés dans un fichier.Les retours à la ligne ne devront pas être comptabilisés dans les caractères. un séparateur '-' et un numéro de contrôle. Un numéro de CCP est correct: . .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. car la valeur de contrôle devrait être 97. Exercice 10.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. 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.si le reste de la division par 97 est zéro et la valeur de contrôle est 97. : . SEPA restituera la valeur (logique) 1 si le caractère est un séparateur et 0 dans le cas contraire. SEPA utilise un tableau qui contient les séparateurs à détecter.espace .ponctuation: .guillemets: " . ? ! .

TXT qui contient les numéros ci-dessus. Pour tester le programme. la tableau TABC est sauvé dans un fichier FC dont le nom est à entrer au clavier. Après la fusion. 47 WAFAE SABBAR . 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. La mémoire pour TABA. créer à l'aide d'un éditeur de texte un fichier CCP.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. TABB et TFUS dont les nombres d'éléments sont inconnus. est réservée dynamiquement après que les longueurs des fichiers FA et FB ont été détectées. Les tableaux TABA et TABB sont fusionnés dans un troisième tableau trié en ordre croissant TABC.16 Deux fichiers FA et FB dont les noms sont à entrer au clavier contiennent des nombres entiers triés dans l'ordre croissant. Exercice 10.

SOLUTIONS SOLUTIONS 48 WAFAE SABBAR .

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

. SOMME).Commentaires (mis en italique).h> pour pouvoir utiliser les fonctions printf et scanf.Opérateurs: 50 WAFAE SABBAR . return 0. COMPTEUR. */ main() { int NOMBRE. /* Initialisation des variables */ SOMME = 0. COMPTEUR déclarées comme entiers (type int).Variables utilisées: NOMBRE.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). . SOMME.\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.Commande au compilateur: #include<stdio. scanf("%i". &NOMBRE).5 #include <stdio. } Solution: . . . SOMME.Fonctions utilisées: printf. COMPTEUR = 0. /* Ajouter le nombre au résultat */ SOMME += NOMBRE. scanf de la bibliothèque <stdio>. . /* Lecture des données */ while (COMPTEUR < 4) { /* Lire la valeur du nombre suivant */ printf("Entrez un nombre entier :").h> /* Ce programme calcule la somme de 4 nombres entiers introduits au clavier. /* Incrémenter le compteur */ COMPTEUR++. } /* Impression du résultat */ printf("La somme est: %i \n".

. retourne la valeur zéro comme code d'erreur à l'environnement après l'exécution du programme Ajoutes : . .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).Structure de contrôle: while(<condition>) { .. . (ici: SOMME) 51 WAFAE SABBAR . les paramètres qui suivent la chaîne de caractères indiquent les noms des variables à afficher. 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).+= ++ < = opérateur arithmétique d'affectation opérateur arithmétique opérateur de comparaison opérateur d'affectation . } répète le bloc d'instructions aussi longtemps que la <condition> est remplie.L'instruction return 0.la fonction printf est appelée avec un respectivement avec deux paramètres: le premier paramètre est une chaîne de caractères.

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

long N3.3 base décimale base octale base hexadécimale représ.0e-1 double unsigned long 70000 53 WAFAE SABBAR .4 Donnée Type (si correct) Valeur / Erreur 12332 23. (10) booléen TROUVE int TROUVE. 3.4 345lu 34. (9) entier N4 double N4..5L -1.. 'FE' seulement pour hexa. faux} par convention Exercice 2. dépend de la machine (ASCII: 10) 'unsigned' seulement pour des entiers -0.. 1285} = {-1 .4*1010} 11 positions significatives {vrai... dépend de la machine (ASCII: 79) 67 apostrophes manquent 1+0*8+0*64+1*512 = 513 -1.5 -1..1 0 => octal. 40000 40000 10 val.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. dépend de la machine (ASCII: 48) apostrophes manquent valeur en général zéro valeur zéro val.0 0xeba 0123l '\n' 1. 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.4 déclaration correcte: 345ul 34..0 10+11*16+14*256 = 3770 3+2*8+1*64 = 83 val. {-1280 ..

h> 54 WAFAE SABBAR .0l 0XEUL long double 0 unsigned long 14 Exercice 2.7 #include <stdio.h> #include <math.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.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.

/* Affichage du résultat */ printf("L'hypoténuse du triangle rectangle est %f \n". printf("Introduire la valeur pour B : ").0) / C double 132.2)+pow(B. 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. RES). char B = 'A'. /* Calcul */ RES = floor(A/B). short C = 10. scanf("%lf". /* Affichage du résultat */ printf("La tangente de A est %f \n". /* Affichage du résultat */ printf("La valeur A/B arrondie à trois décimales: %f \n". /* Affichage du résultat */ printf("A exposant B est %f \n".8 Soient les déclarations: long A = 15. return 0. &B). scanf("%lf". /* Calcul */ RES = sin(A)/cos(A).5 55 WAFAE SABBAR . /* Affichage du résultat */ printf("La valeur arrondie en moins de A/B est %f \n". RES). double B. RES).2)). /* Calcul */ RES = floor(1000*(A/B))/1000. /* Calcul */ RES = sqrt(pow(A. RES). /* Calcul */ RES = pow(A.main() { double A. } Exercice 2. double RES. RES). /* Saisie de A et B */ printf("Introduire la valeur pour A : "). &A).B).

C. } Changez la partie format du programme de façon à séparer les différentes données par le symbole '-'. &MOIS. ANNEE). JOUR. C). return 0. RECU. printf("Le caractère %c a le code ASCII %d\n".h> 56 WAFAE SABBAR . RECU=scanf("%i %i %i". RECU.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. #include <stdio. &JOUR. printf("Introduire un caractère suivi de 'Enter'\n").h> main() { int JOUR. RECU=scanf("%i-%i-%i". Exercice 3. &ANNEE). . .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.h> main() { int C. printf("Introduisez la date (JOUR. #include <stdio. &ANNEE).2 #include <stdio. MOIS.3 . ANNEE. printf("\ndonnées reçues : %i\njour : %i\nmois : %i\nannee : %i\n". MOIS. &MOIS. . . return 0. } b) en employant getch et printf. ANNéE) : "). C = getchar(). Solution: . MOIS. LIRE ET ÉCRIRE DES DONNÉES Exercice 3. . &JOUR.

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

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

printf("Entrez le quatrième scanf("%d".9 a) #include <stdio. &D). = %ld\n".h> main() { int PNET. SOM+=A. printf("Entrez le premier scanf("%d". printf("Entrez le deuxième scanf("%d". &A). long SOM. SOM). nombre : "). printf("Entrez le quatrième nombre : "). nous choisissons le type long pour la somme. scanf("%d". } nombre : "). A. printf("Entrez le taux de la TVA (en %) : "). &C). &A). PTTC = PNET+(double)PNET*TVA/100. scanf("%d". C. B. &B). &TVA). scanf("%d". scanf("%d".PTTC). SOM+=A. } 59 WAFAE SABBAR . SOM). C. D. return 0. SOM = (long)A+B+C+D. scanf("%d". printf("Entrez le prix net de l'article : "). printf("Entrez le troisième nombre : "). B. printf(" %d + %d + %d + %d return 0. printf("Entrez le deuxième nombre : "). 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. &PNET). } Exercice 3. &A). &A). printf("La somme des nombres entrés est %ld\n". nombre : "). */ int A. SOM+=A. return 0. long SOM. nombre : "). printf("Entrez le premier nombre : "). printf("Entrez le troisième scanf("%d". double PTTC. printf("Le prix TTC est %. &A).int A. TVA. D. SOM+=A. SOM = 0. scanf("%d".2lf Francs\n".

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

DIST=sqrt(pow(XA-XB.YA "). YB.2f\n".10 #include <stdio. YA. YA. return 0. XB.%d". scanf("%d. /* 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("Entrez les coordonnées du point B : XB.h> #include <math. %d) est %. &XB. XA. */ printf("Entrez les coordonnées du point A : XA. &YB). printf("La distance entre A(%d.% d) et B(%d. &YA).YB ").%d".Exercice 3. } 61 WAFAE SABBAR .h> main() { int XA. XB.2)+pow(YA-YB. YB. &XA. DIST).2)). scanf("%d. double DIST.

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

scanf("%i %i %i".. 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).C). int MAX.A). &B. MAX). printf("La valeur maximale est ").. if (A>B && A>C) printf("%i\n".h> main() { int A. return 0. else printf ("quatrième choix \n").. Si (A>B) alors la construction if .else if .else garantit que toutes les combinations sont traitées et fournissent un résultat Exercice 4. printf("La valeur maximale est %i\n".else et une variable d'aide MAX #include <stdio..3 a) if . . B. &C).. } b) if . 63 WAFAE SABBAR . &A. . C. if (A>B) MAX=A.else sans variable d'aide int A. else if (B>C) printf("%i\n". else MAX=B. &B. if (C>MAX) MAX=C. &A. &C).else if . else printf("%i\n"..printf ("deuxième choix \n"). B.B). printf("Introduisez trois nombres entiers :"). scanf("%i %i %i". printf("Introduisez trois nombres entiers :"). C. else if (A==B) printf ("troisième choix \n").

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

FUS[100]. else POS=MIL.\n"). Ainsi. IFUS.le pire des cas pour la recherche dichotomique peut entraîner 20 exécutions de la boucle. \n". int N. 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. VAL. IB.le pire des cas pour la recherche séquentielle peut entraîner 1 048 576 exécutions de la boucle. la recherche se termine beaucoup plus rapidement. int IA.13 Fusion de deux tableaux triés #include <stdio.POS=-1. M. POS). if (VAL < A[MIL]) SUP=MIL-1. .le pire des cas pour la recherche séquentielle peut entraîner 1024 exécutions de la boucle.le pire des cas pour la recherche dichotomique peut entraîner 10 exécutions de la boucle. else printf("La valeur %d se trouve à la position %d. Lors de la recherche dichotomique.h> main() { /* Déclarations */ /* Les tableaux et leurs dimensions */ int A[50]. return 0. B[50]. 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. while ((INF<=SUP) && (POS==-1)) { MIL=(SUP+INF)/2. 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. Exemple: Lors de la recherche dans un tableau de 1024 éléments: . Exercice 6. } Question: Quel est l'avantage de la recherche dichotomique? Dans le pire des cas d'une recherche séquentielle. } /* Edition du résultat */ if (POS==-1) printf("La valeur recherchée ne se trouve pas " "dans le tableau. . else if (VAL > A[MIL]) INF=MIL+1. /* indices courants */ 85 WAFAE SABBAR .

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

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

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

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

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

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

} 92 WAFAE SABBAR . for (I=0. I<N.50) : "). J. printf("\n").J). I<N.} /* Affectation de la matrice transposée à B */ for (I=0. } return 0. J<M. printf("Nombre de colonnes (max. I++) { for (J=0. } b) La matrice A sera transposée par permutation des éléments. I++) for (J=0. &M ). I++) for (J=0. J<N. J++) { printf("Elément[%d][%d] : ". B[I][J]). J<I. I<DMAX. &A[I][J]). */ DMAX = (N>M) ? N : M. } /* 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.50) : "). scanf("%d". for (I=0. for (I=0. J++) printf("%7d".h> main() { /* Déclarations */ int A[50][50]. /* int I. I<N. A[I][J]). /* int N. I++) for (J=0. /* 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. J++) B[J][I]=A[I][J]. I++) { for (J=0. J++) { AIDE = A[I][J]. J<M. /* int DMAX. #include <stdio. scanf("%d". &N ). for (I=0. A[J][I] = AIDE. scanf("%d". } /* Affichage de la matrice */ printf("Matrice donnée :\n"). I<M. /* Edition du résultat */ /* Attention: maintenant le rôle de N et M est inversé. M.I. J<M. */ printf("Matrice résultat :\n"). J++) printf("%7d". printf("\n"). /* int AIDE. A[I][J] = A[J][I].

printf("Nombre de colonnes (max. &A[I][J]). I<M. &N ). J<M. B[I][J]). /* dimensions des matrices */ int I. J<M. /* Edition du résultat */ printf("Matrice résultat :\n").2f". I++) for (J=0. for (I=0. scanf("%f"./* Edition du résultat */ /* Attention: maintenant le rôle de N et M est inversé. I<N. } Exercice 6. I++) { for (J=0. for (I=0. J++) { printf("Elément[%d][%d] : ". /* matrice résultat */ int N. } printf("Multiplicateur X : "). scanf("%d". J<N. } /* Affectation du résultat de la multiplication à B */ for (I=0. /* indices courants */ float X. */ printf("Matrice résultat :\n"). for (I=0. J<M. I++) for (J=0. I++) { for (J=0. J. J++) printf("%7d".h> main() { /* Déclarations */ float A[50][50].50) : "). /* Affichage de la matrice */ printf("Matrice donnée :\n"). &X ).2f". #include <stdio. printf("\n"). J<M. /* matrice donnée */ float B[50][50].I. for (I=0. printf("\n"). printf("\n"). /* multiplicateur */ /* Saisie des données */ printf("Nombre de lignes (max. J++) printf("%10. A[I][J]). M. I<N. A[I][J]). I<N.J). scanf("%f". I++) { for (J=0.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. J++) B[I][J] = X*A[I][J]. } 93 WAFAE SABBAR . I<N. scanf("%d". &M ). } return 0. J++) printf("%10.50) : ").

} Exercice 6. J++) printf("%10.return 0. for (I=0. J<M. } return 0.J). printf("\n"). I<N.50) : "). #include <stdio.h> main() { /* Déclarations */ float A[50][50]. J++) A[I][J] *= X. J<M. /* Edition du résultat */ printf("Matrice résultat :\n"). scanf("%f". I++) for (J=0. &A[I][J]). J++) printf("%10. } printf("Multiplicateur X : ").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. M. &X).2f". #include <stdio.h> main() { /* Déclarations */ 94 WAFAE SABBAR . J. A[I][J]). I<N. /* Affichage de la matrice */ printf("Matrice donnée :\n"). I<N. /* int N. I++) { for (J=0.I. } /* Multiplication des éléments de A par X */ for (I=0. } b) Les éléments de la matrice A seront multipliés par X. I<N. /* float X.2f". I++) { for (J=0. for (I=0. printf("Nombre de colonnes (max. J<M. scanf("%d". /* int I. J<M. &N ). A[I][J]). /* matrice donnée */ dimensions de la matrice */ indices courants */ multiplicateur */ /* Saisie des données */ printf("Nombre de lignes (max. &M ). I++) for (J=0.50) : "). scanf("%d". J++) { printf("Elément[%d][%d] : ". scanf("%f". for (I=0. printf("\n").

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

&N ). /* Affichage du tableau */ for (P1=A. P1<A+N. P1++) { *P2 = *P1. } 119 WAFAE SABBAR . for (P1=A.50) : "). 45. P1-A). scanf("%d".int A[] = {12. P1<A+N. */ for (P1=P2=A. int *P. P1<A+N. P1<A+N. 56. 89.h> main() { /* Déclarations */ int A[50]. *P2. 34. printf("\n"). printf("\n").5 #include <stdio. /* tableau donné int N. /* valeur à éliminer int *P1. *P1). /* Edition du résultat */ for (P1=A. 90}. P = A. /* dimension du tableau int X. scanf("%d". P1). 67. 78. &X ). if (*P2 != X) P2++. *P1). P1++) printf("%d ". /* pointeurs d'aide */ */ */ */ /* Saisie des données */ printf("Dimension du tableau (max. P1++) { printf("Elément %d : ". } printf("Introduire l'élément X à éliminer du tableau : "). 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. scanf("%d". } /* Nouvelle dimension de A */ N = P2-A. return 0. P1++) printf("%d ". 23. /* 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.

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

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

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

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

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

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

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

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

18 a) Représenter graphiquement la mémorisation des deux variables NOM1 et NOM2. I<5. P2--. 128 WAFAE SABBAR . *P2 = AIDE. return 0. } } /* Affichage des mots inversés */ for (I=0. } Exercice 8.17 #include <stdio. *P1 = *P2.Exercice 8. I<5. I++) { P1 = P2 = (char *)(TABCH+I). I<5. I++) puts((char *)(TABCH+I)). /* 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"). /* int I. P1++. /* Placer P2 à la fin de la chaîne */ while (*P2) P2++. for (I=0.h> main() { /* Déclarations */ char TABCH[5][51]. /* sinon '\0' est placé au début de la chaîne */ while (P1<P2) { AIDE = *P1.50 caractères) : "./* char AIDE. } /* Inverser l'ordre des caractères à l'intérieur des mots */ for (I=0. /* char *P1. *P2. I++) { printf("Mot %d (max. gets((char *)(TABCH+I)). I). P2--.

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

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

getchar(). I<10. /* indice du prochain candidat à supprimer */ int I. J++) if (MOT[J] && strcmp(MOT[MAX]. /* 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 :"). } return 0.I). */ for (MAX=0 .. */ exit(-1).. } 131 WAFAE SABBAR . for (J=MAX. J++) if (MOT[J]) puts(MOT[J]). */ strcpy(MOT[I]. else { /* sinon afficher un message d'erreur */ printf("\aPas assez de mémoire \n"). I++) { /* Lecture d'une phrase */ printf("Phrase %d : ". MAX++) . for (J=0.\n"). I<10. J<10. */ /* 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. printf("Poussez Enter pour continuer .. /* Tableau de pointeurs sur les 10 chaînes */ int MAX.%d :\n". */ if (MOT[I]) /* copier la phrase à l'adresse */ /* fournie par malloc. J<10. !MOT[MAX] .{ /* Déclarations */ char INTRO[51]. /* Affichage des mots restants */ printf("Passage No. INTRO). 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./* chaîne pour l'introduction des données */ char *MOT[10]. MOT[J])>0) MAX=J. MOT[MAX]=0.. /* Suppression de la chaîne */ free(MOT[MAX]).J. /* Réservation de la mémoire */ MOT[I] = malloc(strlen(INTRO)+1). /* S'il y a assez de mémoire. . gets(INTRO). } } /* Suppression des mots du tableau par ordre lexicographique */ for (I=0. /* et quitter le programme. I). for (I=0.

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

J<I. I>0 . } Exercice 8. INTRO). I<10.MOT[J+1])>0) { FIN=J. I=FIN) { FIN=0.h> #include <string. */ for (I=9 . if (MOT[I]) strcpy(MOT[I]. /* indice courant */ char *AIDE. strcat(PHRASE. I++) { /* Lecture d'une phrase */ printf("Phrase %d : ".h> main() { /* Déclarations */ char INTRO[51]. exit(-1)." "). /* Suppression de la chaîne */ free(MOT[MAX]).I).h> #include <stdlib.23 #include <stdio. /* 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 :"). MOT[J] = MOT[J+1].MOT[MAX]). for (J=0. 133 WAFAE SABBAR . /* chaîne pour l'introduction des données */ char *MOT[10]. return 0. MOT[MAX]=0. /* ligne à partir de laquelle MOT est trié */ int J. } /* Affichage de la PHRASE */ puts("Résultat :"). else { printf("\aPas assez de mémoire \n"). /* Tableau de pointeurs sur les 10 chaînes */ int I. for (I=0. puts(PHRASE). J++) if (strcmp(MOT[J]./* pour la permutation des pointeurs */ int FIN. /* Réservation de la mémoire */ MOT[I] = malloc(strlen(INTRO)+1). AIDE = MOT[J].strcat(PHRASE. MOT[J+1] = AIDE. } } /* Tri du tableau par propagation de l'élément maximal. gets(INTRO).

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

printf("La surface du return 0. SURFACE(R)). &R).9 . \n". . . double SURFACE(double RAYON) { /* Déclaration locale de PI */ double PI(void).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. } 135 WAFAE SABBAR . rayon du cercle : "). } double PI(void) { return 3.h> double PI(void) { return 3. } . LES FONCTIONS Exercice 9.14159265. suite . printf("Introduire le scanf("%lf". } de SURFACE */ RAYON).Définition 'bottom-up' sans déclarations: #include <stdio.h> main() { /* Déclaration locale double SURFACE(double double R.14159265.Déclarations locales des fonctions et définition 'top-down': #include <stdio. cercle est %f. . return PI()*RAYON*RAYON.

double SURFACE(double RAYON) { return PI()*RAYON*RAYON. } c) Si nous compilons le programme donné sans changements. 136 WAFAE SABBAR . return 0. printf("La surface du cercle est %f. &R). \n"..Déclaration globale des fonctions et définition 'top-down': #include <stdio. : 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. printf("La surface du cercle est %f. : Call to function 'SURFACE' with no prototype Error . \n". &R).h> /* Déclaration globale des fonctions */ double SURFACE(double RAYON). Cet avertissement restera sans conséquences si ces suppositions sont correctes. SURFACE(R)). En rencontrant ensuite la définition de la fonction. nous obtenons les messages suivants: Warning . 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. SURFACE(R)). } double SURFACE(double RAYON) { return PI()*RAYON*RAYON. scanf("%lf". main() { double R. 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.. printf("Introduire le rayon du cercle : "). le compilateur détecte une incompatibilité de type.14159265. scanf("%lf". double PI(void). } . } double PI(void) { return 3.. return 0. car la fonction SURFACE retourne en réalité une valeur du type double.

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

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

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

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

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

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

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

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

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

int *N. } Exercice 9. } void ECRIRE_TAB (int *TAB. . . /* Attention: utiliser la négation de */ } /* la condition employée en lang algorithmique */ } void PERMUTER(int *A. return MAX. *A = *B. } void LIRE_TAB (int *TAB. I++) if (*(TAB+MAX) < *(TAB+I)) MAX = I. I<N. } } } while(!TERMINE). for (M=0. int NMAX) { . for (I=1. M++) /* Attention aux indices! */ { K=M+SAUT. *B = AIDE.MAX. for (I=1. I++) if (MAX < *(TAB+I)) MAX = *(TAB+I). /* variables d'aide */ MAX=0. /* variables d'aide */ MAX=*TAB. . if (*(T+M) > *(T+K)) { PERMUTER(T+M.I. 146 WAFAE SABBAR .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.{ TERMINE=1. TERMINE=0. I<N. int *B) { int AIDE. M<N-SAUT. . } b) la fonction MAX2 retourne l'indice de l'élément maximal int MAX2(int *TAB.T+K). int N) { . int N) { int MAX. AIDE = *A. int N) { int I. return MAX.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/* 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

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

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

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

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