Exercices en C

EXERCICES EN C
Exercice 5.3
Ecrivez un programme qui lit trois valeurs entières (A, B et C) au clavier et qui
affiche la plus grande des trois valeurs, en utilisant:
a) if - else et une variable d'aide MAX
b) if - else if - ... - else sans variable d'aide
c) les opérateurs conditionnels et une variable d'aide MAX
d) les opérateurs conditionnels sans variable d'aide
a) if - else et une variable d'aide MAX
#include <stdio.h>
main()
{
int A, B, C;
int MAX;
printf("Introduisez trois nombres entiers :");
scanf("%i %i %i", &A, &B, &C);
if (A>B)
MAX=A;
else
MAX=B;
if (C>MAX)
MAX=C;
printf("La valeur maximale est %i\n", MAX);
return 0;
}
b) if - else if - ... - else sans variable d'aide
int A, B, C;
scanf("%i %i %i", &A, &B, &C);
printf("La valeur maximale est ");
if (A>B && A>C)
printf("%i\n",A);
else if (B>C)
printf("%i\n",B);
else
printf("%i\n",C);
c) opérateurs conditionnels et une variable d'aide MAX
int A, B, C;
int MAX;
scanf("%i %i %i", &A, &B, &C);
MAX = (A>B) ? A : B;
MAX = (MAX>C) ? MAX : C;
printf("La valeur maximale est %i\n", MAX);
d) opérateurs conditionnels sans variable d'aide

int A, B, C;
scanf("%i %i %i", &A, &B, &C);
printf("La valeur maximale est %i\n",
(A>((B>C)?B:C)) ? A : ((B>C)?B:C));
Exercice 5.4
Ecrivez un programme qui lit trois valeurs entières (A, B et C) au clavier. Triez les
valeurs A, B et C par échanges successifs de manière à obtenir :
val(A) val(B) val(C)
Affichez les trois valeurs.
#include <stdio.h>
main()
{
/* Tri par ordre décroissant de trois entiers
en échangeant les valeurs
*/
int A, B, C, AIDE;
scanf("%i %i %i", &A, &B, &C);
printf("Avant le tri : \tA = %i\tB = %i\tC = %i\n", A, B, C);
/* Valeur maximale -> A */
if (A<B)
{
AIDE = A;
A = B;
B = AIDE;
}
if (A<C)
{
AIDE = A;
A = C;
C = AIDE;
}
/* trier B et C */
if (B<C)
{
AIDE = B;
B = C;
C = AIDE;
}
printf("Après le tri : \tA = %i\tB = %i\tC = %i\n", A, B, C);
return 0;
}
Exercice 5.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.
#include <stdio.h>
main()
{
/* Afficher le signe du produit de deux entiers sans
faire la multiplication
*/
int A, B;
printf("Introduisez deux nombres entiers :");
scanf("%i %i", &A, &B);
if ((A>0 && B>0) || (A<0 && B<0))
printf("Le signe du produit %i * %i est positif\n", A, B);
else if ((A<0 && B>0) || (A>0 && B<0))
printf("Le signe du produit %i * %i est négatif\n", A, B);
else
printf("Le produit %i * %i est zéro\n", A, B);
return 0;
}
Exercice 5.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. Utilisez la fonction fabs de la
bibliothèque <math>.
#include <stdio.h>
#include <math.h>
main()
{
/* Afficher le signe de la somme de deux entiers sans
faire l'addition
*/
int A, B;
printf("Introduisez deux nombres entiers :");
scanf("%i %i", &A, &B);
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",A,B);
else if ((A<0 && B<0) || (A<0 && B>0 && fabs(A)>fabs(B))
|| (A>0 && B<0 && fabs(A)<fabs(B)))
printf("Le signe de la somme %i + %i est négatif\n",A,B);
else
printf("La somme %i + %i est zéro\n", A, B);
return 0;
}
Exercice 5.7
Ecrivez un programme qui calcule les solutions réelles d'une équation du second
degré ax2+bx+c = 0 en discutant la formule:
Utilisez une variable d'aide D pour la valeur du discriminant b2-4ac et décidez à l'aide
de D, si l'équation a une, deux ou aucune solution réelle. Utilisez des variables du
type int pour A, B et C.
Considérez aussi les cas où l'utilisateur entre des valeurs nulles pour A; pour A et B;
pour A, B et C. Affichez les résultats et les messages nécessaires sur l'écran.
#include <stdio.h>
#include <math.h>
main()
{
/* Calcul des solutions réelles d'une équation du second degré */
int A, B, C;
double D; /* Discriminant */
printf("Calcul des solutions réelles d'une équation du second \n");
printf("degré de la forme ax^2 + bx + c = 0 \n\n");
printf("Introduisez les valeurs pour a, b, et c : ");
scanf("%i %i %i", &A, &B, &C);
/* Calcul du discriminant b^2-4ac */

D = pow(B,2) - 4.0*A*C;
/* Distinction des différents cas */

if (A==0 && B==0 && C==0) /* 0x = 0 */
printf("Tout réel est une solution de cette
équation.\n");
else if (A==0 && B==0) /* Contradiction: c # 0 et c = 0 */
printf("Cette équation ne possède pas de
solutions.\n");
else if (A==0) /* bx + c = 0 */
{
printf("La solution de cette équation du premier degré est
:\n");
printf(" x = %.4f\n", (double)C/B);
}
else if (D<0) /* b^2-4ac < 0 */
printf("Cette équation n'a pas de solutions réelles.\n");
else if (D==0) /* b^2-4ac = 0 */
{
printf("Cette équation a une seule solution réelle :\n");
printf(" x = %.4f\n", (double)-B/(2*A));
}
else /* b^2-4ac > 0 */
{
printf("Les solutions réelles de cette équation sont :\n");
printf(" x1 = %.4f\n", (-B+sqrt(D))/(2*A));
printf(" x2 = %.4f\n", (-B-sqrt(D))/(2*A));
}
return 0;
}
Exercice 6.1
Ecrivez un programme qui lit N nombres entiers au clavier et qui affiche leur somme,
leur produit et leur moyenne. Choisissez un type approprié pour les valeurs à afficher.
Le nombre N est à entrer au clavier. Résolvez ce problème,
a) en utilisant while,
b) en utilisant do - while,
c) en utilisant for.
d) Laquelle des trois variantes est la plus naturelle pour ce problème?
#include <stdio.h>
main()
{
int N; /* nombre de données */
int NOMB; /* nombre courant */
int I; /* compteur */
long SOM; /* la somme des nombres entrés */
double PROD; /* le produit des nombres entrés */
printf("Nombre de données : ");

scanf("%d", &N);
SOM=0;
PROD=1;
I=1;
while(I<=N)
{
printf("%d. nombre : ", I);
scanf("%d", &NOMB);
SOM += NOMB;
PROD *= NOMB;
I++;
}
printf("La somme des %d nombres est %ld \n", N, SOM);

printf("Le produit des %d nombres est %.0f\n", N, PROD);
printf("La moyenne des %d nombres est %.4f\n", N, (float)SOM/N);
return 0;
}
Exercice 6.2
Complétez la 'meilleure' des trois versions de l'exercice 6.1 :
Répétez l'introduction du nombre N jusqu'à ce que N ait une valeur entre 1 et 15.
Quelle structure répétitive utilisez-vous? Pourquoi?
Remplacer les lignes

scanf("%d", &N);
par
do
{
scanf("%d", &N);
}
while(N<1 || N>15);
Quelle structure répétitive utilisez-vous? Pourquoi?

Comme il n'y pas d'initialisation ni de réinitialisation de variables, nous avons le
choix entre while et do - while. Comme l'introduction du nombre de données doit
toujours être exécuté (au moins une fois), le plus naturel sera l'utilisation de la
structure do - while.
Exercice 6.3
Calculez par des soustractions successives le quotient entier et le reste de la division

entière de deux entiers entrés au clavier.
#include <stdio.h>
main()
{
int NUM; /* numérateur de la division entière */
int DEN; /* dénominateur de la division entière */
int DIV; /* résultat de la division entière */
int RES; /* reste de la division entière */
printf("Introduisez le numérateur : ");

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

return 0;
}
Exercice 6.5
Calculez par multiplications successives XN de deux entiers naturels X et N entrés au

clavier.
#include <stdio.h>
main()
{
int X, N; /* Les données */
int I; /* Le compteur */
double RESU; /* Type double à cause de la */
/* grandeur du résultat. */
do
{
printf("Entrez l'entier naturel X : ");
scanf("%d", &X);
}
while (X<0);
do
{
printf("Entrez l'exposant N : ");
scanf("%d", &N);
}
while (N<0);
/* Pour N=0, le résultat sera automatiquement X^0=1 */

for (RESU=1.0, I=1 ; I<=N ; I++)
RESU*=X;
/* Attention: Pour X=0 et N=0 , 0^0 n'est pas défini */

if (N==0 && X==0)
printf("zéro exposant zéro n'est pas défini !\n");
else
printf("Résultat : %d ^ %d = %.0f\n", X, N, RESU);
return 0;
}
Exercice 6.6 Calculez la somme des N premiers termes de la série harmonique :

1 + 1/2 + 1/3 + ... + 1/N
#include <stdio.h>
main()
{
int N; /* nombre de termes à calculer */
int I; /* compteur pour la boucle */
float SOM; /* Type float à cause de la précision du résultat. */
do
{
printf ("Nombre de termes: ");
scanf ("%d", &N);
}
while (N<1);
for (SOM=0.0, I=1 ; I<=N ; I++)
SOM += (float)1/I;
printf("La somme des %d premiers termes est %f \n", N, SOM);
return 0;
}
Exercice 6.7
Calculez la somme, le produit et la moyenne d'une suite de chiffres non nuls entrés au
clavier, sachant que la suite est terminée par zéro. Retenez seulement les chiffres (0, 1
... 9) lors de l'entrée des données et effectuez un signal sonore si les données sortent
de ce domaine.
Solution (une de plusieurs solutions possibles) :
#include <stdio.h>
main()
{
int X; /* Le chiffre courant */
int N=0; /* Le compteur des données */
int SOM=0; /* La somme actuelle */
long PROD=1; /* Le produit actuel - Type long à */
/* cause de la grandeur du résultat. */
*/
do
{
/* Saisie des données (pour perfectionnistes) */
printf("Entrez le %d%s chiffre : ", (N+1), (N)?"e":"er");
scanf("%d", &X);
if (X<0||X>9)
printf("\a");
else if (X)
{
N++;
SOM+=X;
PROD*=X;
}
else if (!X && N>0)
{/* Seulement si au moins un chiffre a été accepté */
printf("La somme des chiffres est %d \n", SOM);
printf("Le produit des chiffres est %ld\n", PROD);
printf("La moyenne des chiffres est %f \n", (float)SOM/N);
}
}
while (X);
return 0;
}
Exercice 6.8
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, terminée par zéro
(Contrôlez s'il s'agit vraiment de chiffres). Exemple: Entrée: 1 2 3 4 0 Affichage:
4321
#include <stdio.h>
main()
{
int X; /* Le chiffre courant */
int N=0; /* Le compteur des décimales */
long VALD=1; /* Valeur de la position décimale courante */
long NOMB=0; /* Le nombre résultat */
do
{
printf("Entrez le %d%s chiffre : ", (N+1), (N)?"e":"er");
scanf("%d", &X);
if (X<0||X>9)
printf("\a");
else if (X)
{
NOMB += VALD*X;
N++;
VALD *= 10;
}
else
printf("La valeur du nombre renversé est %ld\n", NOMB);
}
while (X);
return 0;
}
Remarque :
En remplaçant la ligne
NOMB += VALD*X;
par
NOMB += pow(10, N)*X;
on n'a plus besoin de la variable VALD. Il faut cependant inclure les fonctions de la
bibliothèque <math>. D'autre part, le calcul de 10N serait alors répété à chaque
exécution de la boucle.
Finalement, cette variante est plus lente et plus volumineuse que la première.
Exercice 6.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. Exemple: Entrée: 1234
Affichage: 4321
#include <stdio.h>
main()
{
int NOMB; /* Le nombre à inverser */
int NINV; /* Le nombre inversé */
/* Attention: en utilisant le type int, il est impossible */
/* d'inverser correctement des nombres comme 10033 ... */
do
{
printf("Entrez un nombre positif (<10000) : ", NOMB);
scanf("%d", &NOMB);
}
while (NOMB<0 || NOMB>9999);
NINV=0;
while(NOMB>0)
{
NINV *= 10;
NINV += NOMB%10;
NOMB /= 10;
}
/* Autre possibilité : */
/* for (NINV=0 ; NOMB>0 ; NOMB/=10)
NINV = NINV*10 + NOMB%10;
*/
printf("Le nombre 'inversé' est : %d\n", NINV);

return 0;
}
Exercice 6.10
Calculez pour une valeur X donnée du type float la valeur numérique d'un polynôme
de degré n:
P(X) = AnXn + An-1Xn-1 + ... + A1X + A0
Les valeurs de n, des coefficients An, ... , A0 et de X seront entrées au clavier.
Utilisez le schéma de Horner qui évite les opérations d'exponentiation lors du calcul:
#include <stdio.h>
main()
{
int N; /* degré du polynôme */
float X; /* argument */
float A; /* coefficients successifs du polynôme */
float P; /* coefficient courant du terme Horner */
printf("Entrer le degré N du polynôme : ");

scanf("%d", &N);
printf("Entrer la valeur X de l'argument : ");
scanf("%f", &X);
for(P=0.0 ; N>=0 ; N--)

{
printf("Entrer le coefficient A%d : ", N);
scanf("%f", &A);
P = P*X + A;
}
printf("Valeur du polynôme pour X = %.2f : %.2f\n", X, P);

return 0;
}
Exercice 6.11
Calculez le P.G.C.D. de deux entiers naturels entrés au clavier en utilisant

l'algorithme d'EUCLIDE.
#include <stdio.h>
main()
{
int A, B; /* données */
int X, Y, RESTE; /* var. d'aide pour l'algorithme d'Euclide */
do
{
printf("Entrer l'entier A (non nul) : ");
scanf("%d", &A);
}
while(!A);
do
{
printf("Entrer l'entier B (non nul) : ");
scanf("%d", &B);
}
while(!B);
for (RESTE=A, X=A, Y=B ; RESTE ; X=Y, Y=RESTE)

RESTE = X%Y;
printf("Le PGCD de %d et de %d est %d\n", A, B, X);

return 0;
}
Exercice 6.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 int
- le type long
- le type double
- le type long double
#include <stdio.h>
main()
{
int U1, U2, UN; /* pour parcourir la suite */
int N; /* rang du terme demandé */
int I; /* compteur pour la boucle */
do
{
printf("Rang du terme demandé : ");
scanf("%d", &N);
}
while(N<1);
U1=U2=1; /* Initialisation des deux premiers termes */

if (N==1)
UN=U1;
else if (N==2)
UN=U2;
else
{
for (I=3 ; I<=N ; I++)
{
UN = U1+U2;
U1 = U2;
U2 = UN;
}
}
printf("Valeur du terme de rang %d : %d\n", N, UN);
return 0;
}
Rang et terme maximal calculable en utilisant les déclarations :
int U1, U2, UN; (spéc. de format : %d) U23 = 28657

long U1, U2, UN; (spéc. de format : %ld) U46 = 1836311903
double U1, U2, UN; (spéc. de format : %e) U1476 = 1.306989e308
long double U1, U2, UN; (spéc. de format : %Le) U23601 = 9.285655e4931
Exercice 6.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.
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, plus petit que 50.
c) Affichez lors du calcul toutes les approximations calculées :
La 1ère approximation de la racine carrée de ... est ...

La 2e approximation de la racine carrée de ... est ...
La 3e approximation de la racine carrée de ... est ...
. . .
#include <stdio.h>
main()
{
double A; /* donnée */
double X; /* approximation de la racine carrée de A */
int N; /* degré/précision de l'approximation */
int J; /* degré de l'approximation courante */
do
{
printf("Entrer le réel positif A : ");
scanf("%lf", &A);
}
while(A<0);
do
{
printf("Entrer le degré de l'approximation : ");
scanf("%d", &N);
}
while(N<=0 || N>=50);
for(X=A, J=1 ; J<=N ; J++)

{
X = (X + A/X) / 2;
printf("La %2d%s approximation de la racine carrée"
" de %.2f est %.2f\n", J, (J==1)?"ère":"e", A, X);
}
return 0;
}
Exercice 6.14
Affichez un triangle isocèle formé d'étoiles de N lignes (N est fourni au clavier):
Nombre de lignes : 8
*
***
*****
*******
*********
***********
*************
***************
#include <stdio.h>
main()
{
int LIG; /* nombre de lignes */
int L; /* compteur des lignes */
int ESP; /* nombre d'espaces */
int I; /* compteur des caractères */
do
{
printf("Nombres de lignes : ");
scanf("%d", &LIG);
}
while (LIG<1 || LIG>20);
for (L=0 ; L<LIG ; L++)

{
ESP = LIG-L-1;
for (I=0 ; I<ESP ; I++)
putchar(' ');
for (I=0 ; I<2*L+1 ; I++)
putchar('*');
putchar('\n');
}
return 0;
}
Exercice 6.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
#include <stdio.h>
main()
{
const int MAX = 10; /* nombre de lignes et de colonnes */
int I; /* compteur des lignes */
int J; /* compteur des colonnes */
/* Affichage de l'en-tête */
printf(" X*Y I");
for (J=0 ; J<=MAX ; J++)
printf("%4d", J);
printf("\n");
printf("------");
for (J=0 ; J<=MAX ; J++)
printf("----");
printf("\n");
/* Affichage du tableau */
for (I=0 ; I<=MAX ; I++)
{
printf("%3d I", I);
for (J=0 ; J<=MAX ; J++)
printf("%4d", I*J);
printf("\n");
}
return 0;
}
Exercice 7.1
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.
Calculer et afficher ensuite la somme des éléments du tableau.
#include <stdio.h>
main()
{
/* Déclarations */
int T[50]; /* tableau donné */
int N; /* dimension */
int I; /* indice courant */
long SOM; /* somme des éléments - type long à cause */
/* de la grandeur prévisible du résultat. */
/* Saisie des données */

printf("Dimension du tableau (max.50) : ");
scanf("%d", &N );
for (I=0; I<N; I++)
{
printf("Elément %d : ", I);
scanf("%d", &T[I]);
}
printf("Tableau donné :\n");
for (I=0; I<N; I++)
printf("%d ", T[I]);
printf("\n");
/* Calcul de la somme */
for (SOM=0, I=0; I<N; I++)
SOM += T[I];
/* Edition du résultat */
printf("Somme de éléments : %ld\n", SOM);
return 0;
}
Exercice 7.2
affiche le tableau.
Effacer ensuite toutes les occurrences de la valeur 0 dans le tableau T et tasser les
éléments restants. Afficher le tableau résultant.
#include <stdio.h>
main()
{
/* Déclarations */
int I,J; /* indices courants */

scanf("%d", &N );
for (I=0; I<N; I++)
{
scanf("%d", &T[I]);
}
printf("Tableau donné : \n");
for (I=0; I<N; I++)
printf("\n");
/* Effacer les zéros et comprimer : */
/* Copier tous les éléments de I vers J et */
/* augmenter J pour les éléments non nuls. */
for (I=0, J=0 ; I<N ; I++)
{
T[J] = T[I];
if (T[I]) J++;
}
/* Nouvelle dimension du tableau ! */
N = J;
/* Edition des résultats */
printf("Tableau résultat :\n");
for (I=0; I<N; I++)
printf("\n");
return 0;
}
Exercice 7.3
affiche le tableau.
Ranger ensuite les éléments du tableau T dans l'ordre inverse sans utiliser de tableau
d'aide. Afficher le tableau résultant.
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.
#include <stdio.h>
main()
{
/* Déclarations */
int AIDE; /* pour l'échange */

scanf("%d", &N );
for (I=0; I<N; I++)
{
scanf("%d", &T[I]);
}
for (I=0; I<N; I++)
printf("\n");
/* Inverser le tableau */
for (I=0, J=N-1 ; I<J ; I++,J--)
/* Echange de T[I] et T[J] */
{
AIDE = T[I];
T[I] = T[J];
T[J] = AIDE;
}
for (I=0; I<N; I++)
printf("\n");
return 0;
}
Exercice 7.4
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.
Afficher les tableaux TPOS et TNEG.
Lors du travail avec les tableaux à deux dimensions, nous utiliserons deux indices
(p.ex: I et J), et la structure for, souvent imbriquée, pour parcourir les lignes et les
colonnes des tableaux.
#include <stdio.h>
main()
{
/* Déclarations */
/* Les tableaux et leurs dimensions */
int T[50], TPOS[50], TNEG[50];
int N, NPOS, NNEG;

scanf("%d", &N );
for (I=0; I<N; I++)
{
scanf("%d", &T[I]);
}
for (I=0; I<N; I++)
printf("\n");
/* Initialisation des dimensions de TPOS et TNEG */
NPOS=0;
NNEG=0;
/* Transfer des données */
for (I=0; I<N; I++)
{ if (T[I]>0) {
TPOS[NPOS]=T[I];
NPOS++;
}
if (T[I]<0) {
TNEG[NNEG]=T[I];
NNEG++;
}
}
printf("Tableau TPOS :\n");
for (I=0; I<NPOS; I++)
printf("%d ", TPOS[I]);
printf("\n");
printf("Tableau TNEG :\n");
for (I=0; I<NNEG; I++)
printf("%d ", TNEG[I]);
printf("\n");
return 0;
}
Exercice 7.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). Remplir le tableau par
des valeurs entrées au clavier et afficher le tableau ainsi que la somme de tous ses
éléments.
#include <stdio.h>
main()
{
/* Déclarations */
int T[50][50]; /* tableau donné */
int L, C; /* dimensions */
int I, J; /* indices courants */
/* de la grandeur prévisible du résultat. */

printf("Nombre de lignes (max.50) : ");
scanf("%d", &L );
printf("Nombre de colonnes (max.50) : ");
scanf("%d", &C );
for (I=0; I<L; I++)
for (J=0; J<C; J++)
{
printf("Elément[%d][%d] : ",I,J);
scanf("%d", &T[I][J]);
}
for (I=0; I<L; I++)
{
for (J=0; J<C; J++)
printf("%7d", T[I][J]);
printf("\n");
}
for (SOM=0, I=0; I<L; I++)
for (J=0; J<C; J++)
SOM += T[I][J];
printf("Somme des éléments : %ld\n", SOM);
return 0;
}
Exercice 7.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). 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.
#include <stdio.h>
main()
{
/* Déclarations */
int T[50][50]; /* tableau donné */
/* de la grandeur prévisible des résultats. */

scanf("%d", &L );
scanf("%d", &C );
for (I=0; I<L; I++)
for (J=0; J<C; J++)
{
scanf("%d", &T[I][J]);
}
for (I=0; I<L; I++)
{
for (J=0; J<C; J++)
printf("%7d", T[I][J]);
printf("\n");
}
/* Calcul et affichage de la somme des lignes */
for (I=0; I<L; I++)
{
for (SOM=0, J=0; J<C; J++)
SOM += T[I][J];
printf("Somme - ligne %d : %ld\n",I,SOM);
}
/* Calcul et affichage de la somme des colonnes */
for (J=0; J<C; J++)
{
for (SOM=0, I=0; I<L; I++)
SOM += T[I][J];
printf("Somme - colonne %d : %ld\n",J,SOM);
}
return 0;
}
Exercice 7.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.
Exemple:
/ \
| a b c d | / \
| e f g h | ==> | a b c d e f g h i j k l |
| i j k l | \ /
\ /
#include <stdio.h>
main()
{
/* Déclarations */
int M[10][10]; /* tableau à 2 dimensions */
int V[100]; /* tableau à 1 dimension */

scanf("%d", &L );
scanf("%d", &C );
for (I=0; I<L; I++)
for (J=0; J<C; J++)
{
scanf("%d", &M[I][J]);
}
/* Affichage du tableau 2-dim */
for (I=0; I<L; I++)
{
for (J=0; J<C; J++)
printf("%7d", M[I][J]);
printf("\n");
}
/* Transfer des éléments ligne par ligne */
for (I=0; I<L; I++)
for (J=0; J<C; J++)
V[I*C+J] = M[I][J];
/* Affichage du tableau 1-dim */
printf("Tableau résultat : ");
for (I=0; I<L*C; I++)
printf("%d ", V[I]);
printf("\n");
return 0;
}
Exercice 7.8 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).
Exemple:
/ \ / \
| 3 2 -4 | * | 2 -3 5 | = 3*2+2*(-3)+(-4)*5 = -20
\ / \ /
#include <stdio.h>
main()
{
/* Déclarations */
int U[50], V[50]; /* tableaux donnés */
long PS; /* produit scalaire */
printf("Dimension des tableaux (max.50) : ");
scanf("%d", &N );
printf("** Premier tableau **\n");
for (I=0; I<N; I++)
{
scanf("%d", &U[I]);
}
printf("** Deuxième tableau **\n");
for (I=0; I<N; I++)
{
scanf("%d", &V[I]);
}
/* Calcul du produit scalaire */
for (PS=0, I=0; I<N; I++)
PS += (long)U[I]*V[I];
printf("Produit scalaire : %ld\n", PS);
return 0;
}
Exercice 7.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) = AnXn + An-1Xn-1 + ... + A1X + A0

Les valeurs des coefficients An, ... , A0 seront entrées au clavier et mémorisées dans
un tableau A de type float et de dimension n+1.
a) Utilisez la fonction pow() pour le calcul.
b) Utilisez le schéma de Horner qui évite les opérations d'exponentiation:
Solution combinée:
#include <stdio.h>
#include <math.h>
main()
{
float A[20];/* tableau des coefficients de P */
int N; /* degré du polynôme */
float X; /* argument */
float P; /* résultat */
/* Saisie du degré N et de l'argument X */

printf("Entrer le degré N du polynôme (max.20) : ");
scanf("%d", &N);
printf("Entrer la valeur X de l'argument : ");
scanf("%f", &X);
/* Saisie des coefficients */
for (I=0 ; I<=N ; I++)
{
printf("Entrer le coefficient A%d : ", I);
scanf("%f", &A[I]);
}
/* a) Calcul à l'aide de pow

for (P=0.0, I=0 ; I<=N ; I++)
P += A[I]*pow(X,I); */
/* b) Calcul de Horner */
/* commencer le calcul avec le dernier coefficient...*/
for (P=0.0, I=0 ; I<=N ; I++)
P = P*X + A[N-I];
printf("Valeur du polynôme pour X = %.2f : %.2f\n", X, P);
return 0;
}
Exercice 7.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. Afficher ensuite la valeur et la position du maximum et du
minimum. Si le tableau contient plusieurs maxima ou minima, le programme retiendra
la position du premier maximum ou minimum rencontré.
#include <stdio.h>
main()
{
/* Déclarations */
int A[50]; /* tableau donné */
int MIN; /* position du minimum */
int MAX; /* position du maximum */
scanf("%d", &N );
for (I=0; I<N; I++)
{
scanf("%d", &A[I]);
}
for (I=0; I<N; I++)
printf("%d ", A[I]);
printf("\n");
/* Recherche du maximum et du minimum */
MIN=0;
MAX=0;
for (I=0; I<N; I++)
{
if(A[I]>A[MAX]) MAX=I;
if(A[I]<A[MIN]) MIN=I;
}
printf("Position du minimum : %d\n", MIN);
printf("Position du maximum : %d\n", MAX);
printf("Valeur du minimum : %d\n", A[MIN]);
printf("Valeur du maximum : %d\n", A[MAX]);
return 0;
}
Exercice 7.11 Insérer une valeur dans un tableau trié
Un tableau A de dimension N+1 contient N valeurs entières triées par ordre croissant;
la (N+1)ième valeur est indéfinie. 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.
#include <stdio.h>
main()
{
/* Déclarations */
int VAL; /* valeur à insérer */

printf("Dimension N du tableau initial (max.50) : ");
scanf("%d", &N );
for (I=0; I<N; I++)
{
scanf("%d", &A[I]);
}
printf("Elément à insérer : ");
scanf("%d", &VAL );
for (I=0; I<N; I++)
printf("\n");
/* Déplacer les éléments plus grands que */
/* VAL d'une position vers l'arrière. */
for (I=N ; (I>0)&&(A[I-1]>VAL) ; I--)
A[I]=A[I-1];
/* VAL est copié à la position du dernier */
/* élément déplacé. */
A[I]=VAL;
/* Nouvelle dimension du tableau ! */
N++;
for (I=0; I<N; I++)
printf("\n");
return 0;
}
Exercice 7.12 Recherche d'une valeur dans un tableau
Problème: Rechercher dans un tableau d'entiers A une valeur VAL entrée au clavier.
Afficher la position de VAL si elle se trouve dans le tableau, sinon afficher un
message correspondant. La valeur POS qui est utilisée pour mémoriser la position de
la valeur dans le tableau, aura la valeur -1 aussi longtemps que VAL n'a pas été
trouvée.
a) La recherche séquentielle
Comparer successivement les valeurs du tableau avec la valeur donnée.
#include <stdio.h>
main()
{
/* Déclarations */
int VAL; /* valeur à rechercher */
int POS; /* position de la valeur */

scanf("%d", &N );
for (I=0; I<N; I++)
{
scanf("%d", &A[I]);
}
printf("Elément à rechercher : ");
scanf("%d", &VAL );
for (I=0; I<N; I++)
printf("\n");
/* Recherche de la position de la valeur */
POS = -1;
for (I=0 ; (I<N)&&(POS==-1) ; I++)
if (A[I]==VAL)
POS=I;
if (POS==-1)
printf("La valeur recherchée ne se trouve pas "
"dans le tableau.\n");
else
printf("La valeur %d se trouve à la position %d. \n",
VAL, POS);
return 0;
}
b) La recherche dichotomique ('recherche binaire', 'binary search')
#include <stdio.h>
main()
{
/* Déclarations */
int VAL; /* valeur à rechercher */
int POS; /* position de la valeur */
int INF, MIL, SUP; /* limites du champ de recherche */

scanf("%d", &N );
for (I=0; I<N; I++)
{
scanf("%d", &A[I]);
}
printf("Elément à rechercher : ");
scanf("%d", &VAL );
for (I=0; I<N; I++)
printf("\n");
/* Initialisation des limites du domaine de recherche */
INF=0;
SUP=N-1;
/* Recherche de la position de la valeur */
POS=-1;
while ((INF<=SUP) && (POS==-1))
{
MIL=(SUP+INF)/2;
if (VAL < A[MIL])
SUP=MIL-1;
else if (VAL > A[MIL])
INF=MIL+1;
else
POS=MIL;
}
if (POS==-1)
printf("La valeur recherchée ne se trouve pas "
"dans le tableau.\n");
else
printf("La valeur %d se trouve à la position %d. \n",
VAL, POS);
return 0;
}
Question: Quel est l'avantage de la recherche dichotomique?
Dans le pire des cas d'une recherche séquentielle, 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.
Lors de la recherche dichotomique, on élimine la moitié des éléments du tableau à

chaque exécution de la boucle. Ainsi, la recherche se termine beaucoup plus
rapidement.
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.
Exemple:
Lors de la recherche dans un tableau de 1024 éléments:
- 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.
Lors de la recherche dans un tableau de 1 048 576 éléments:
- le pire des cas pour la recherche séquentielle peut entraîner 1 048 576 exécutions de
la boucle.
- le pire des cas pour la recherche dichotomique peut entraîner 20 exécutions de la

boucle.
Exercice 7.13 Fusion de deux tableaux triés
Problème: On dispose de deux tableaux A et B (de dimensions respectives N et M),

triés par ordre croissant. Fusionner les éléments de A et B dans un troisième tableau
FUS trié par ordre croissant.
Méthode: Utiliser trois indices IA, IB et IFUS. Comparer A[IA] et B[IB]; remplacer
FUS[IFUS] par le plus petit des deux éléments; avancer dans le tableau FUS et dans
le tableau qui a contribué son élément. Lorsque l'un des deux tableaux A ou B est
épuisé, il suffit de recopier les éléments restants de l'autre tableau dans le tableau FUS
#include <stdio.h>
main()
{
/* Déclarations */
int A[50], B[50], FUS[100];
int N, M;
int IA, IB, IFUS; /* indices courants */

printf("Dimension du tableau A (max.50) : ");
scanf("%d", &N );
printf("Entrer les éléments de A dans l'ordre croissant :\n");
for (IA=0; IA<N; IA++)
{
printf("Elément A[%d] : ", IA);
scanf("%d", &A[IA]);
}
printf("Dimension du tableau B (max.50) : ");
scanf("%d", &M );
printf("Entrer les éléments de B dans l'ordre croissant :\n");
for (IB=0; IB<M; IB++)
{
printf("Elément B[%d] : ", IB);
scanf("%d", &B[IB]);
}
/* Affichage des tableaux A et B */
printf("Tableau A :\n");
for (IA=0; IA<N; IA++)
printf("%d ", A[IA]);
printf("\n");
printf("Tableau B :\n");
for (IB=0; IB<M; IB++)
printf("%d ", B[IB]);
printf("\n");
/* Fusion des éléments de A et B dans FUS */

/* de façon à ce que FUS soit aussi trié. */
IA=0; IB=0; IFUS=0;
while ((IA<N) && (IB<M))
if(A[IA]<B[IB])
{
FUS[IFUS]=A[IA];
IFUS++;
IA++;
}
else
{
FUS[IFUS]=B[IB];
IFUS++;
IB++;
}
/* Si IA ou IB sont arrivés à la fin de leur tableau, */
/* alors copier le reste de l'autre tableau. */
while (IA<N)
{
FUS[IFUS]=A[IA];
IFUS++;
IA++;
}
while (IB<M)
{
FUS[IFUS]=B[IB];
IFUS++;
IB++;
}
printf("Tableau FUS :\n");
for (IFUS=0; IFUS<N+M; IFUS++)
printf("%d ", FUS[IFUS]);
printf("\n");
return 0;
}
Exercice 7.14 Tri par sélection du maximum
Problème: Classer les éléments d'un tableau A par ordre décroissant.
Méthode: Parcourir le tableau de gauche à droite à l'aide de l'indice I. Pour chaque

élément A[I] du tableau, déterminer la position PMAX du (premier) maximum à
droite de A[I] et échanger A[I] et A[PMAX].
Exemple:
#include <stdio.h>
main()
{
/* Déclarations */
int I; /* rang à partir duquel A n'est pas trié */
int J; /* indice courant */
int AIDE; /* pour la permutation */
int PMAX; /* indique la position de l'élément */
/* maximal à droite de A[I] */

scanf("%d", &N );
for (J=0; J<N; J++)
{
printf("Elément %d : ", J);
scanf("%d", &A[J]);
}
for (J=0; J<N; J++)
printf("%d ", A[J]);
printf("\n");
/* Tri du tableau par sélection directe du maximum. */

for (I=0; I<N-1; I++)
{
/* Recherche du maximum à droite de A[I] */
PMAX=I;
for (J=I+1; J<N; J++)
if (A[J]>A[PMAX]) PMAX=J;
/* Echange de A[I] avec le maximum */
AIDE=A[I];
A[I]=A[PMAX];
A[PMAX]=AIDE;
}
printf("Tableau trié :\n");
for (J=0; J<N; J++)
printf("\n");
return 0;
}
Exercice 7.15 Tri par propagation (bubble sort)
Problème: Classer les éléments d'un tableau A par ordre croissant.
Méthode: En recommençant chaque fois au début du tableau, on effectue à plusieurs

reprises le traitement suivant: On propage, par permutations successives, le plus grand
élément du tableau vers la fin du tableau (comme une bulle qui remonte à la surface
d'un liquide).
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.
* Si aucune permutation n'a eu lieu, le tableau est trié.
#include <stdio.h>
main()
{
/* Déclarations */
int I; /* rang à partir duquel A est trié */
int FIN; /* position où la dernière permutation a eu lieu. */
/* permet de ne pas trier un sous-ensemble déjà trié. */

scanf("%d", &N );
for (J=0; J<N; J++)
{
printf("Elément %d : ", J);
scanf("%d", &A[J]);
}
for (J=0; J<N; J++)
printf("\n");
/* Tri du tableau par propagation de l'élément maximal. */

for (I=N-1 ; I>0 ; I=FIN)
{
FIN=0;
for (J=0; J<I; J++)
if (A[J]>A[J+1])
{
FIN=J;
AIDE=A[J];
A[J]=A[J+1];
A[J+1]=AIDE;
}
}
printf("Tableau trié :\n");
for (J=0; J<N; J++)
printf("\n");
return 0;
}
Exercice 7.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
...
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
#include <stdio.h>
main()
{
int POINTS[50]; /* tableau des points */
int NOTES[7]; /* tableau des notes */
int N; /* nombre d'élèves */
int I, IN; /* compteurs d'aide */
int SOM; /* somme des points */
int MAX, MIN; /* maximum, minimum de points */
int MAXN; /* nombre de lignes du graphique */

printf("Entrez le nombre d'élèves (max.50) : ");
scanf("%d", &N);
printf("Entrez les points des élèves:\n");
for (I=0; I<N; I++)
{printf("Elève %d:", I+1);
scanf("%d", &POINTS[I]);
}
printf("\n");
/* Calcul et affichage du maximum et du minimum des points */

for (MAX=0, MIN=60, I=0; I<N; I++)
{if (POINTS[I] > MAX) MAX=POINTS[I];
if (POINTS[I] < MIN) MIN=POINTS[I];
}
printf("La note maximale est %d \n", MAX);
printf("La note minimale est %d \n", MIN);
/* Calcul et affichage de la moyenne des points */
for (SOM=0,I=0 ; I<N ; I++)
SOM += POINTS[I];
printf("La moyenne des notes est %f \n", (float)SOM/N);
/* Etablissement du tableau NOTES */

for (IN=0 ; IN<7 ; IN++)
NOTES[IN] = 0;
for (I=0; I<N; I++)
NOTES[POINTS[I]/10]++;
/* Recherche du maximum MAXN dans NOTES */

for (MAXN=0,IN=0 ; IN<7 ; IN++)
if (NOTES[IN] > MAXN)
MAXN = NOTES[IN];
/* Affichage du graphique de barreaux */

/* Représentation de MAXN lignes */
for (I=MAXN; I>0; I--)
{
printf("\n %2d >", I);
for (IN=0; IN<7; IN++)
{
if (NOTES[IN]>=I)
printf(" #######");
else
printf(" ");
}
}
/* Affichage du domaine des notes */
printf("\n +");
for (IN=0; IN<7; IN++)
printf("-------+");
printf("\n I 0 - 9 I 10-19 I 20-29 "
"I 30-39 I 40-49 I 50-59 I 60 I\n");
return 0;
}
Exercice 7.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.
#include <stdio.h>
main()
{
/* Déclarations */
int A[50][50]; /* matrice carrée */
int N; /* dimension de la matrice carrée */

printf("Dimension de la matrice carrée (max.50) : ");
scanf("%d", &N);
for (I=0; I<N; I++)
for (J=0; J<N; J++)
{
scanf("%d", &A[I][J]);
}
/* Affichage de la matrice */
printf("Matrice donnée :\n");
for (I=0; I<N; I++)
{
for (J=0; J<N; J++)
printf("%7d", A[I][J]);
printf("\n");
}
/* Mise à zéro de la diagonale principale */

for (I=0; I<N; I++)
A[I][I]=0;
printf("Matrice résultat :\n");
for (I=0; I<N; I++)
{
for (J=0; J<N; J++)
printf("\n");
}
return 0;
}
Exercice 7.18 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
uij = |
\ 0 si ij
#include <stdio.h>
main()
{
/* Déclarations */
int U[50][50]; /* matrice unitaire */
int N; /* dimension de la matrice unitaire */

printf("Dimension de la matrice carrée (max.50) : ");
scanf("%d", &N);
/* Construction de la matrice carrée unitaire */

for (I=0; I<N; I++)
for (J=0; J<N; J++)
if (I==J)
U[I][J]=1;
else
U[I][J]=0;
printf("Matrice unitaire de dimension %d :\n", N);
for (I=0; I<N; I++)
{
for (J=0; J<N; J++)
printf("%7d", U[I][J]);
printf("\n");
}
return 0;
}
Remarque:
L'opération:
if (I==J)
U[I][J]=1;
else
U[I][J]=0;
peut être simplifiée par:
U[I][J] = (I==J);
Exercice 7.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:
/ \ / \
tA = t | a b c d | = | a e i |
| e f g h | | b f j |
| i j k l | | c g k |
\ / | d h l |
\ /
a) La matrice transposée sera mémorisée dans une deuxième matrice B qui sera
ensuite affichée.
#include <stdio.h>
main()
{
/* Déclarations */
int A[50][50]; /* matrice initiale */
int B[50][50]; /* matrice résultat */
int N, M; /* dimensions des matrices */

scanf("%d", &N );
scanf("%d", &M );
for (I=0; I<N; I++)
for (J=0; J<M; J++)
{
}
for (I=0; I<N; I++)
{
for (J=0; J<M; J++)
printf("\n");
}
/* Affectation de la matrice transposée à B */
for (I=0; I<N; I++)
for (J=0; J<M; J++)
B[J][I]=A[I][J];
/* Attention: maintenant le rôle de N et M est inversé. */
for (I=0; I<M; I++)
{
for (J=0; J<N; J++)
printf("%7d", B[I][J]);
printf("\n");
}
return 0;
}
b) La matrice A sera transposée par permutation des éléments.
#include <stdio.h>
main()
{
/* Déclarations */
int A[50][50]; /* matrice donnée */
int N, M; /* dimensions de la matrice */
int DMAX; /* la plus grande des deux dimensions */

scanf("%d", &N );
scanf("%d", &M );
for (I=0; I<N; I++)
for (J=0; J<M; J++)
{
}
for (I=0; I<N; I++)
{
for (J=0; J<M; J++)
printf("\n");
}
/* 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. */
DMAX = (N>M) ? N : M;
for (I=0; I<DMAX; I++)
for (J=0; J<I; J++)
{
AIDE = A[I][J];
A[I][J] = A[J][I];
A[J][I] = AIDE;
}
/* Attention: maintenant le rôle de N et M est inversé. */
for (I=0; I<M; I++)
{
for (J=0; J<N; J++)
printf("\n");
}
return 0;
}
Exercice 7.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.
a) Le résultat de la multiplication sera mémorisé dans une deuxième matrice A qui

sera ensuite affichée.
#include <stdio.h>
main()
{
/* Déclarations */
float A[50][50]; /* matrice donnée */
float B[50][50]; /* matrice résultat */
float X; /* multiplicateur */
scanf("%d", &N );
scanf("%d", &M );
for (I=0; I<N; I++)
for (J=0; J<M; J++)
{
scanf("%f", &A[I][J]);
}
printf("Multiplicateur X : ");
scanf("%f", &X );
for (I=0; I<N; I++)
{
for (J=0; J<M; J++)
printf("%10.2f", A[I][J]);
printf("\n");
}
/* Affectation du résultat de la multiplication à B */
for (I=0; I<N; I++)
for (J=0; J<M; J++)
B[I][J] = X*A[I][J];
for (I=0; I<N; I++)
{
for (J=0; J<M; J++)
printf("%10.2f", B[I][J]);
printf("\n");
}
return 0;
}
b) Les éléments de la matrice A seront multipliés par X.
#include <stdio.h>
main()
{
/* Déclarations */
float A[50][50]; /* matrice donnée */
int N, M; /* dimensions de la matrice */
float X; /* multiplicateur */

scanf("%d", &N );
scanf("%d", &M );
for (I=0; I<N; I++)
for (J=0; J<M; J++)
{
scanf("%f", &A[I][J]);
}
printf("Multiplicateur X : ");
scanf("%f", &X);
for (I=0; I<N; I++)
{
for (J=0; J<M; J++)
printf("%10.2f", A[I][J]);
printf("\n");
}
/* Multiplication des éléments de A par X */
for (I=0; I<N; I++)
for (J=0; J<M; J++)
A[I][J] *= X;
for (I=0; I<N; I++)
{
for (J=0; J<M; J++)
printf("%10.2f", A[I][J]);
printf("\n");
}
return 0;
}
Exercice 7.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' | | a+a' b+b' c+c' d+d' |
| e f g h | + | e' f' g' h' | = | e+e' f+f' g+g' h+h' |
| i j k l | | i' j' k' l' | | i+i' j+j' k+k' l+l' |
\ / \ / \ /
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.
a) Le résultat de l'addition sera mémorisé dans une troisième matrice C qui sera
ensuite affichée.
#include <stdio.h>
main()
{
/* Déclarations */
int B[50][50]; /* matrice donnée */
int C[50][50]; /* matrice résultat */

scanf("%d", &N );
scanf("%d", &M );
printf("*** Matrice A ***\n");
for (I=0; I<N; I++)
for (J=0; J<M; J++)
{
}
printf("*** Matrice B ***\n");
for (I=0; I<N; I++)
for (J=0; J<M; J++)
{
scanf("%d", &B[I][J]);
}
/* Affichage des matrices */
printf("Matrice donnée A :\n");
for (I=0; I<N; I++)
{
for (J=0; J<M; J++)
printf("\n");
}
printf("Matrice donnée B :\n");
for (I=0; I<N; I++)
{
for (J=0; J<M; J++)
printf("\n");
}
/* Affectation du résultat de l'addition à C */

for (I=0; I<N; I++)
for (J=0; J<M; J++)
C[I][J] = A[I][J]+B[I][J];
printf("Matrice résultat C :\n");
for (I=0; I<N; I++)
{
for (J=0; J<M; J++)
printf("%7d", C[I][J]);
printf("\n");
}
return 0;
}
b) La matrice B est ajoutée à A.
#include <stdio.h>
main()
{
/* Déclarations */
int A[50][50]; /* matrice donnée et résultat */

scanf("%d", &N );
scanf("%d", &M );
for (I=0; I<N; I++)
for (J=0; J<M; J++)
{
}
for (I=0; I<N; I++)
for (J=0; J<M; J++)
{
}
for (I=0; I<N; I++)
{
for (J=0; J<M; J++)
printf("\n");
}

for (I=0; I<N; I++)
{
for (J=0; J<M; J++)
printf("\n");
}
/* Addition de B à A */
for (I=0; I<N; I++)
for (J=0; J<M; J++)
A[I][J] += B[I][J];
printf("Matrice résultat A :\n");
for (I=0; I<N; I++)
{
for (J=0; J<M; J++)
printf("\n");
}
return 0;
}
Exercice 7.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:
/ \ / \ /
\
| a b c | | p q | | a*p + b*r + c*t a*q + b*s +
c*u |
| e f g | * | r s | = | e*p + f*r + g*t e*q + f*s +
g*u |
| h i j | | t u | | h*p + i*r + j*t h*q + i*s +
j*u |
| k l m | \ / | k*p + l*r + m*t k*q + l*s +
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.
#include <stdio.h>
main()
{
/* Déclarations */
int C[50][50]; /* matrice résultat */
int N, M, P; /* dimensions des matrices */
int I, J, K; /* indices courants */

printf("Nombre de lignes de A (max.50) : ");
scanf("%d", &N );
printf("Nombre de colonnes de A (max.50) : ");
scanf("%d", &M );
for (I=0; I<N; I++)
for (J=0; J<M; J++)
{
}
printf("Nombre de lignes de B : %d\n", M);
printf("Nombre de colonnes de B (max.50) : ");
scanf("%d", &P );
for (I=0; I<M; I++)
for (J=0; J<P; J++)
{
}
for (I=0; I<N; I++)
{
for (J=0; J<M; J++)
printf("\n");
}
for (I=0; I<M; I++)
{
for (J=0; J<P; J++)
printf("\n");
}
/* Affectation du résultat de la multiplication à C */
for (I=0; I<N; I++)
for (J=0; J<P; J++)
{
C[I][J]=0;
for (K=0; K<M; K++)
C[I][J] += A[I][K]*B[K][J];
}
printf("Matrice résultat C :\n");
for (I=0; I<N; I++)
{
for (J=0; J<P; J++)
printf("%7d", C[I][J]);
printf("\n");
}
return 0;
}
Exercice 7.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 1
n=1 1 1
n=2 1 2 1
n=3 1 3 3 1
n=4 1 4 6 4 1
n=5 1 5 10 10 5 1
n=6 1 6 15 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.
- Calculer les valeurs entre les éléments initialisés de gauche à droite en utilisant la
relation:
Pi,j = Pi-1,j + Pi-1,j-1
#include <stdio.h>
main()
{
/* Déclarations */
int P[14][14]; /* matrice résultat */
int N; /* degré du triangle */
do {
printf("Entrez le degré N du triangle (max.13) : ");
scanf("%d", &N);
} while (N>13||N<0);
/* Construction des lignes 0 à N du triangle: */
/* Calcul des composantes du triangle jusqu'à */
/* la diagonale principale. */
for (I=0; I<=N; I++)
{
P[I][I]=1;
P[I][0]=1;
for (J=1; J<I; J++)
P[I][J] = P[I-1][J] + P[I-1][J-1];
}
printf("Triangle de Pascal de degré %d :\n", N);
for (I=0; I<=N; I++)
{
printf(" N=%2d", I);
for (J=0; J<=I; J++)
if (P[I][J])
printf("%5d", P[I][J]);
printf("\n");
}
return 0;
}
Exercice 7.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. Ces éléments sont appelés des points-
cols. Afficher les positions et les valeurs de tous les points-cols trouvés.
Exemples: Les éléments soulignés sont des points-cols:
/ \ / \ / \ / \
| 1 8 3 4 0 | | 4 5 8 9 | | 3 5 6 7 7 | | 1 2 3 |
| | | 3 8 9 3 | | 4 2 2 8 9 | | 4 5 6 |
| 6 7 2 7 0 | | 3 4 9 3 | | 6 3 2 9 7 | | 7 8 9 |
\ / \ / \ / \ /
Méthode: Etablir deux matrices d'aide MAX et MIN de même dimensions que A,
telles que:
/ 1 si A[i,j] est un maximum
MAX[i,j] = | sur la ligne i
\ 0 sinon
/ 1 si A[i,j] est un minimum

MIN[i,j] = | sur la colonne j
\ 0 sinon
#include <stdio.h>
main()
{
/* Déclarations */
int MAX[50][50];/* matrice indiquant les maxima des lignes */
int MIN[50][50];/* matrice indiquant les minima des colonnes */
int AIDE; /* pour la détection des extréma */
int C; /* compteur des points-cols */

scanf("%d", &N );
scanf("%d", &M );
for (I=0; I<N; I++)
for (J=0; J<M; J++)
{
}
for (I=0; I<N; I++)
{
for (J=0; J<M; J++)
printf("\n");
}
/* Construction de la matrice d'aide MAX */

/* qui indique les positions de tous les */
/* maxima sur une ligne. */
for (I=0; I<N; I++)
{
/* Recherche du maximum sur la ligne I */
AIDE=A[I][0];
for (J=1; J<M; J++)
if (A[I][J]>AIDE) AIDE=A[I][J];
/* Marquage de tous les maxima sur la ligne */
for (J=0; J<M; J++)
if (A[I][J]==AIDE) /* ou bien : */
MAX[I][J]=1; /* MAX[I][J] = (A[I][J]==AIDE) */
else
MAX[I][J]=0;
}
/* Construction de la matrice d'aide MIN */
/* qui indique les positions de tous les */
/* minima sur une colonne. */
for (J=0; J<M; J++)
{
/* Recherche du minimum sur la colonne J */
AIDE=A[0][J];
for (I=1; I<N; I++)
if (A[I][J]<AIDE) AIDE=A[I][J];
/* Marquage de tous les minima sur la colonne J */
for (I=0; I<N; I++)
if (A[I][J]==AIDE) /* ou bien : */
MIN[I][J]=1; /* MIN[I][J] = (A[I][J]==AIDE) */
else
MIN[I][J]=0;
}
/* Les composantes qui sont marquées comme extréma */
/* dans MAX et dans MIN sont des points-cols. */
printf("Points - cols :\n");
for (C=0, I=0; I<N; I++)
for (J=0; J<M; J++)
if (MAX[I][J]&&MIN[I][J])
{
C++;
printf("L'élément %d\test un maximum "
"sur la ligne %d\n"
" \t et un minimum "
"sur la colonne %d\n", A[I][J], I, J);
}
if (C==0)
printf("Le tableau ne contient pas de points-cols.\n");
return 0;
}
Exercice 8.11
Ecrire un programme qui lit 10 mots et les mémorise dans un tableau de chaînes de
caractères. Trier les 10 mots lexicographiquement en utilisant les fonctions strcmp et
strcpy. Afficher le tableau trié. Utilisez la méthode de tri par sélection directe (voir
Exercice 7.14).
#include <stdio.h>
#include <string.h>
main()
{
/* Déclarations */
char MOT[10][50]; /* tableau de 10 mots à trier */
char AIDE[50]; /* chaîne d'aide pour la permutation */
int I; /* rang à partir duquel MOT n'est pas trié */
int PMOT; /* indique la position du prochain mot */
/* dans la suite lexicographique. */

for (J=0; J<10; J++)
{
printf("Mot %d : ", J);
gets(MOT[J]); /* ou : scanf ("%s\n", MOT[J]); */
}
/* Tri du tableau par sélection directe du */

/* prochain mot dans la suite lexicographique. */
for (I=0; I<9; I++)
{
/* Recherche du prochain mot à droite de A[I] */
PMOT=I;
for (J=I+1; J<10; J++)
if (strcmp(MOT[J], MOT[PMOT]) < 0)
PMOT=J;
/* Echange des mots à l'aide de strcpy */
strcpy(AIDE, MOT[I]);
strcpy(MOT[I], MOT[PMOT]);
strcpy(MOT[PMOT], AIDE);
}
printf("Tableau trié lexicographiquement :\n");
for (J=0; J<10; J++)
puts(MOT[J]); /* ou : printf("%s\n",MOT[J]); */
printf("\n");
return 0;
}
Exercice 8.12
Ecrire un programme qui lit un nombre entre 1 et 7 et qui affiche le nom du jour de la
semaine correspondant:
Utiliser le premier élément du tableau pour mémoriser un petit message d'erreur.
"lundi"
pour 1
"mardi"
pour 2
...
...
"dimanche"
pour 7
#include <stdio.h>
main()
{
/* Déclarations */
int N; /* nombre entré */
char JOUR[8][9] = {"\aErreur!", "lundi", "mardi", "mercredi",
"jeudi", "vendredi", "samedi","dimanche"};
/* Saisie du nombre */
printf("Entrez un nombre entre 1 et 7 : ");
scanf("%d", &N);
/* Affichage du résultat - pour perfectionnistes */
if (N>0 && N<8)
printf("Le %de%c jour de la semaine est %s.\n",
N, (N==1)?'r':' ', JOUR[N]);
else
puts(JOUR[0]);
return 0;
}
Exercice 8.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
#include <stdio.h>
main()
{
/* Déclarations */
char MOT[5][50]; /* tableau pour les 5 mots */
/* Saisie des mots */
printf("Entrez 5 mots, séparés par des espaces :\n");
/* Après le retour à la ligne, scanf lit */
/* les 5 données à la fois. */
for (I=0; I<5; I++)
scanf("%s", MOT[I]);
/* Affichage du résultat */
for (I=4; I>=0; I--)
printf("%s ", MOT[I]);
printf("\n");
return 0;
}
Exercice 8.14
Refaire l'exercice 8.8 (Conjugaison des verbes réguliers en "er") en utilisant deux
tableaux de chaînes de caractères:
Employez les fonctions printf, scanf, strlen.
Sauf indication contraire, les exercices suivants sont à résoudre sans utiliser les
fonctions spéciales des bibliothèques <string>, <stdlib> ou <ctype>. Ils servent à
comprendre et à suivre le raisonnement de ces fonctions.
#include <stdio.h>
#include <string.h>
main()
{
/* Déclarations */
/* Sujets et terminaisons */
char SUJ[6][5] = {"je","tu","il","nous","vous","ils"};
char TERM[6][5] = {"e","es","e","ons","ez","ent"};
char VERB[20]; /* chaîne contenant le verbe */
int L; /* longueur de la chaîne */

printf("Verbe : ");
scanf("%s", VERB);
/* Contrôler s'il s'agit d'un verbe en 'er' */

L=strlen(VERB);
if ((VERB[L-2] != 'e') || (VERB[L-1] != 'r'))
printf("\"%s\" n'est pas un verbe du premier groupe.\n",VERB);
else
{
/* Couper la terminaison 'er'. */
VERB[L-2]='\0';
/* Conjuguer ... */
for (I=0; I<6; I++)
printf("%s %s%s\n",SUJ[I], VERB, TERM[I]);
}
return 0;
}
Sauf indication contraire, les exercices suivants sont à résoudre sans utiliser les
fonctions spéciales des bibliothèques <string>, <stdlib> ou <ctype>. Ils servent à
comprendre et à suivre le raisonnement de ces fonctions.
Exercice 8.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 8.5.
#include <stdio.h>
main()
{
/* Déclarations */
char CH1[50], CH2[50]; /* chaînes à comparer */

printf("Entrez la première chaîne à comparer : ");
gets(CH1);
printf("Entrez la deuxième chaîne à comparer : ");
gets(CH2);
/* Chercher la première position où */

/* CH1 et CH2 se distinguent. */
for (I=0; (CH1[I]==CH2[I]) && CH1[I] && CH2[I]; I++)
;
/* Comparer le premier élément qui */
/* distingue CH1 et CH2. */
if (CH1[I]==CH2[I])
printf("\"%s\" est égal à \"%s\"\n", CH1, CH2);
else if (CH1[I]<CH2[I])
printf("\"%s\" précède \"%s\"\n", CH1, CH2);
else
printf("\"%s\" précède \"%s\"\n", CH2, CH1);
return 0;
}
Exercice 8.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.
#include <stdio.h>
main()
{
/* Déclarations */
char CH[100]; /* chaîne à convertir */
/* Saisie de la chaîne */
printf("Entrez la chaîne à convertir : ");
gets(CH);
/* Conversion de la chaîne */
for (I=0; CH[I]; I++)
{
if (CH[I]>='A' && CH[I]<='Z')
CH[I] = CH[I]-'A'+'a';
else if (CH[I]>='a' && CH[I]<='z')
CH[I] = CH[I]-'a'+'A';
}
/* Affichage de la chaîne convertie */
printf("Chaîne convertie : %s\n", CH);
return 0;
}
Exercice 8.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.
#include <stdio.h>
#include <ctype.h>
main()
{
/* Déclarations */
char CH[100]; /* chaîne numérique à convertir */
long N; /* résultat numérique */
int OK; /* indicateur logique précisant si la */
/* chaîne a été convertie avec succès */
printf("Entrez un nombre entier et positif : ");
gets(CH);
OK=1;
N=0;
for (I=0; OK && CH[I]; I++)
if (isdigit(CH[I]))
N = N*10 + (CH[I]-'0');
else
OK=0;

if (OK)
printf("Valeur numérique : %ld\n", N);
else
printf("\a\"%s\" ne représente pas correctement "
"un entier et positif.\n", CH);
return 0;
}
Exercice 8.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.
#include <stdio.h>
#include <ctype.h>
main()
{
/* Déclarations */
long N; /* résultat numérique */
printf("Entrez un nombre hexadécimal entier et positif : ");
gets(CH);
OK=1;
N=0;
for (I=0; OK && CH[I]; I++)
if (isxdigit(CH[I]))
{
CH[I] = toupper(CH[I]);
if (isdigit(CH[I]))
N = N*16 + (CH[I]-'0');
else
N = N*16 + 10 + (CH[I]-'A');
}
else
OK=0;

if (OK)
{
printf("Valeur numérique hexadécimale : %lX\n", N);
printf("Valeur numérique décimale : %ld\n", N);
}
else
printf("\a\"%s\" n'est pas une valeur "
"hexadécimale correcte.\n", CH);
return 0;
}
Exercice 8.19
En se basant sur l'exercice 8.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)

Exemples: -1234.234 -1234.23400
-123 45 Erreur!
123.23. Erreur!
+00123.0123 123.012300
#include <stdio.h>
#include <math.h>
#include <ctype.h>
main()
{
/* Déclarations */
double N; /* résultat numérique */
int SIG; /* signe de la valeur rationnelle */
int DEC; /* nombre de décimales */
printf("Entrez un nombre rationnel : ");
gets(CH);
/* Conversion de la chaîne : */
/* Initialisation des variables */
OK=1;
N=0.0;
I=0;
SIG=1;
/* Traitement du signe */
if (CH[I]=='-') SIG=-1;
if (CH[I]=='-' || CH[I]=='+')
I++;
/* Positions devant le point décimal */
for ( ; isdigit(CH[I]); I++)
N = N*10.0 + (CH[I]-'0');
/* Traitement du point décimal */
if (CH[I]=='.')
I++;
else if (CH[I])
OK=0;
/* Traitement et comptage des décimales */

for (DEC=0; isdigit(CH[I]); I++, DEC++)
N = N*10.0 + (CH[I]-'0');
if (CH[I]) OK=0;
/* Calcul de la valeur à partir du signe et */
/* du nombre de décimales. */
N = SIG*N/pow(10,DEC);
if (OK)
printf("Valeur numérique : %f\n", N);
else
"rationnelle correcte.\n", CH);
return 0;
}
Exercice 8.20
En se basant sur l'exercice 8.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.234000

-1234. 234 Erreur!
123E+02 123400.000000
123E-02 1.230000
123.4e 123.400000
-12.1234e02 -1212.340000
123.4e3.4 Erreur!
12.12E1 121.200000
12.12 E1 Erreur!
#include <stdio.h>
#include <math.h>
#include <ctype.h>
main()
{/* Déclarations */
double N; /* résultat numérique */
int SIG; /* signe de la valeur rationnelle */
int DEC; /* nombre de décimales */
int SIGE; /* signe de l'exposant */
int EXP; /* valeur de l'exposant */
printf("Entrez un nombre rationnel : ");
gets(CH);
/* Initialisation des variables */
OK=1;
N=0.0;
I=0;
SIG=1;
SIGE=1;
/* Traitement du signe */
if (CH[I]=='-') SIG=-1;
if (CH[I]=='-' || CH[I]=='+') I++;
/* Positions devant le point décimal */
for ( ; isdigit(CH[I]); I++)
N = N*10.0 + (CH[I]-'0');
/* Traitement du point décimal */
if (CH[I]=='.')
I++;
/* Traitement et comptage des décimales */
for (DEC=0; isdigit(CH[I]); I++, DEC++)
N = N*10.0 + (CH[I]-'0');
/* Traitement de la marque exponentielle */
if (CH[I]=='e'||CH[I]=='E')
I++;
else if (CH[I])
OK=0;
/* Traitement du signe de l'exposant */
if (CH[I]=='-') SIGE=-1;
if (CH[I]=='-' || CH[I]=='+') I++;
/* Traitement de la valeur de l'exposant */
for (EXP=0; isdigit(CH[I]); I++)
EXP = EXP*10 + (CH[I]-'0');
if (CH[I]) OK=0;
/* Calcul de l'exposant à partir du signe */
/* SIGE, de la valeur de l'exposant EXP et */
/* du nombre de positions rationnelles DEC */
EXP = SIGE*EXP - DEC;
/* Calcul de la valeur à partir du signe et */
/* de l'exposant. */
N = SIG*N*pow(10,EXP);

if (OK)
printf("Valeur numérique : %f\n", N);
else
"rationnelle correcte.\n", CH);
return 0;
}
Exercice 8.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 ALSE

EI PIERRE PIERRE
T TOTALEMENT OTALEMENT
HELLO HELLO
#include <stdio.h>
main()
{
/* Déclarations */
char SUJ[100]; /* chaîne à transformer */
char OBJ[100]; /* chaîne à supprimer dans SUJ */
int I; /* indice courant dans SUJ */
int J; /* indice courant dans OBJ */
int TROUVE; /* indicateur logique qui précise */
/* si la chaîne OBJ a été trouvée */

printf("Introduisez la chaîne à supprimer : ");
gets(OBJ);
printf("Introduisez la chaîne à transformer : ");
gets(SUJ);
/* Recherche de OBJ dans SUJ */
TROUVE=0;
for (I=0; SUJ[I] && !TROUVE; I++)
/* Si la première lettre est identique, */
if (SUJ[I]==OBJ[0])
{
/* alors comparer le reste de la chaîne */
for (J=1; OBJ[J] && (OBJ[J]==SUJ[I+J]); J++)
;
if (OBJ[J]=='\0') TROUVE=1;
}
/* Si la position de départ de OBJ dans SUJ a été trouvée */
/* alors déplacer le reste de SUJ à cette position. */
if (TROUVE)
{
I--;
/* Maintenant I indique la position de OBJ */
/* dans SUJ et J indique la longueur de OBJ */
for (; SUJ[I+J]; I++)
SUJ[I]=SUJ[I+J];
SUJ[I]='\0';
}
printf("Chaîne résultat : \"%s\"\n", SUJ);
return 0;
}
Exercice 8.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.
Exemples: PHON OY ALPHONSE ALOYSE

IE EI PIERRE PEIRRE
IE ARTE PIERRE PARTERRE
EI IE PIERRE PIERRE
TOT FIN TOTALEMENT FINALEMENT
TTT HELLO HELLO
#include <stdio.h>
main()
{
/* Déclarations */
char CH1[100]; /* chaîne à rechercher */
char CH2[100]; /* chaîne de remplacement */
char FIN[100]; /* chaîne de sauvegarde pour */
/* la fin de SUJ. */
int J; /* indice courant dans CH1 et CH2 */
int K; /* indice d'aide pour les copies */
int TROUVE; /* indicateur logique qui précise */
/* si la chaîne OBJ a été trouvée */

printf("Introduisez la chaîne à rechercher CH1 : ");
gets(CH1);
printf("Introduisez la chaîne à remplacer CH2 : ");
gets(CH2);
printf("Introduisez la chaîne à transformer SUJ : ");
gets(SUJ);
/* Recherche de CH1 dans SUJ */

TROUVE=0;
for (I=0; SUJ[I] && !TROUVE; I++)
if (SUJ[I]==CH1[0])
{
for (J=1; CH1[J] && (CH1[J]==SUJ[I+J]); J++)
;
if (CH1[J]=='\0') TROUVE=1;
}
/* Si CH1 a été trouvée dans SUJ alors sauvegarder la fin */

/* de SUJ dans FIN, copier ensuite CH2 et FIN dans SUJ. */
if (TROUVE)
{
I--;
/* Maintenant I indique la position de CH1 */
/* dans SUJ et J indique la longueur de CH1 */
/* Sauvegarder la fin de SUJ dans FIN */
for (K=0; SUJ[K+I+J]; K++)
FIN[K]=SUJ[K+I+J];
FIN[K]='\0';
/* Copier CH2 dans SUJ */
for (K=0; CH2[K]; K++,I++)
SUJ[I]=CH2[K];
/* Recopier FIN dans SUJ */
for (K=0; FIN[K]; K++,I++)
SUJ[I]=FIN[K];
/* Terminer la chaîne SUJ */
SUJ[I]='\0';
}
return 0;
}
Exercice 8.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 ALOYSE

AN ONT BANANE BONTONTE
T Y TOTALEMENT YOYALEMENY
TTT HELLO HELLO
L HELLO HEO
#include <stdio.h>
main()
{
/* Déclarations */
char CH1[100]; /* chaîne à rechercher */
char CH2[100]; /* chaîne de remplacement */
char FIN[100]; /* chaîne de sauvegarde pour */
/* la fin de SUJ. */
int J; /* indice courant dans CH1 et CH2 */
int K; /* indice d'aide pour les copies */

printf("Introduisez la chaîne à rechercher CH1 : ");
gets(CH1);
printf("Introduisez la chaîne à remplacer CH2 : ");
gets(CH2);
printf("Introduisez la chaîne à transformer SUJ : ");
gets(SUJ);
/* Recherche de CH1 dans SUJ */

for (I=0; SUJ[I]; I++)
if (SUJ[I]==CH1[0])
{
for (J=1; CH1[J] && (CH1[J]==SUJ[I+J]); J++)
;
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; SUJ[K+I+J]; K++)
FIN[K]=SUJ[K+I+J];
FIN[K]='\0';
/* Copier CH2 dans SUJ et déplacer */
/* I derrière la copie de CH2. */
for (K=0; CH2[K]; K++,I++)
SUJ[I]=CH2[K];
/* Recopier FIN dans SUJ */
for (K=0; FIN[K]; K++)
SUJ[I+K]=FIN[K];
/* Terminer la chaîne SUJ */
SUJ[I+K]='\0';
I--; /* réajustement de l'indice I */
}
}
return 0;
}
Exercice 10.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.
#include <stdio.h>
main()
{
/* Prototypes des fonctions appelées */
void TRI_SHELL(int *T, int N);
void LIRE_TAB (int *TAB, int *N, int NMAX);
void ECRIRE_TAB (int *TAB, int N);
/* Variables locales */
int T[100]; /* Tableau d'entiers */
int DIM; /* Dimension du tableau */
/* Traitements */
LIRE_TAB (T, &DIM, 100);
ECRIRE_TAB (T, DIM);
TRI_SHELL(T, DIM);
printf("Tableau trié : \n");
return 0;
}
void TRI_SHELL(int *T, int N)
{
/* Trie un tableau T d'ordre N par la méthode de Shell */
void PERMUTER(int *A, int *B);
int SAUT, M, K;
int TERMINE;
/* Traitements */
SAUT = N;
while (SAUT>1)
{
SAUT /= 2;
do
{
TERMINE=1;
for (M=0; M<N-SAUT; M++) /* Attention aux indices! */
{
K=M+SAUT;
if (*(T+M) > *(T+K))
{
PERMUTER(T+M,T+K);
TERMINE=0;
}
}
}
while(!TERMINE); /* Attention: utiliser la négation de */
} /* la condition employée en lang algorithmique */
}
void PERMUTER(int *A, int *B)

{
int AIDE;
AIDE = *A;
*A = *B;
*B = AIDE;
}
void LIRE_TAB (int *TAB, int *N, int NMAX)

{
. . .
}
void ECRIRE_TAB (int *TAB, int N)

{
. . .
}
Exercice 10.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.
Déterminer le maximum de N éléments d'un tableau TAB d'entiers de trois façons

différentes:
a) la fonction MAX1 retourne la valeur maximale

int MAX1(int *TAB, int N)
{
int MAX,I; /* variables d'aide */
MAX=*TAB;
for (I=1; I<N; I++)
if (MAX < *(TAB+I))
MAX = *(TAB+I);
return MAX;
}
b) la fonction MAX2 retourne l'indice de l'élément maximal
{
int I,MAX; /* variables d'aide */
MAX=0;
for (I=1; I<N; I++)
if (*(TAB+MAX) < *(TAB+I))
MAX = I;
return MAX;
}
c) la fonction MAX3 retourne l'adresse de l'élément maximal
int *MAX3(int *TAB, int N)

{
int *MAX, *P; /* pointeurs d'aide */
MAX=TAB;
for (P=TAB; P<TAB+N; P++)
if (*MAX < *P)
MAX=P;
return MAX;
}
Ecrire un programme pour tester les trois fonctions:
#include <stdio.h>
main()
{
int MAX1 (int *TAB, int N);
int MAX2 (int *TAB, int N);
int *MAX3(int *TAB, int N);
/* Traitements */
printf("MAX1 : %d \n", MAX1(T,DIM) );
printf("MAX2 : %d \n", T[MAX2(T,DIM)] );
printf("MAX3 : %d \n", *MAX3(T,DIM) );
return 0;
}

{
. . .
}

{
. . .
}
{
. . .
}

{
. . .
}

{
. . .
}
Exercice 10.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).
Ecrire un programme pour tester la fonction TRI_SELECTION.
#include <stdio.h>
main()
{
void TRI_SELECTION(int *T, int N);
/* Traitements */
TRI_SELECTION(T, DIM);
return 0;
}
void TRI_SELECTION(int *T, int N)

{
int *MAX3(int *TAB, int N);
int I; /* rang à partir duquel T n'est pas trié */
/* Tri par sélection directe du maximum */

for (I=0 ; I<N-1 ; I++)
PERMUTER(T+I, MAX3(T+I,N-I) );
}

{
. . .
}
{
. . .
}

{
. . .
}

{
. . .
}
Exercice 10.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
#include <stdio.h>
main()
{
void INSERER(int X, int *T, int *N);
int A; /* Nombre à insérer */
/* Traitements */
printf("Introduire le nombre à insérer : ");
scanf("%d", &A);
INSERER(A, T, &DIM);
printf("Tableau résultat : \n");
return 0;
}
void INSERER(int X, int *T, int *N)

{
int I;
/* 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. */
for (I=*N ; I>0 && *(T+I-1)>X ; I--)
*(T+I) = *(T+I-1);
/* X est copié à la position du dernier élément déplacé */
*(T+I)=X;
/* Nouvelle dimension du tableau: */
(*N)++; /* Attention aux parenthèses ! */
}

{
. . .
}

{
. . .
Exercice 10.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.
#include <stdio.h>
main()
{
void TRI_INSERTION(int *T, int N);
/* Traitements */
TRI_INSERTION(T, DIM);
return 0;
}
void TRI_INSERTION(int *T, int N)
{
void INSERER(int X, int *T, int *N);
/* Tri de T par insertion */
I=1;
while (I<N)
INSERER(*(T+I), T, &I);
}
void INSERER(int X, int *T, int *N)

{
. . .
}

{
. . .
}

{
. . .
}
Exercice 10.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.
int RANGER(int *X, int *Y)
{
int AIDE;
if (*X>*Y)
{
AIDE = *X;
*X = *Y;
*Y = AIDE;
return 1;
}
else
return 0;
}
Exercice 10.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 ci-dessus.
Ecrire un programme pour tester la fonction TRI_BULLE.
#include <stdio.h>
main()
{
void TRI_BULLE(int *T, int N);
/* Traitements */
TRI_BULLE(T, DIM);
return 0;
}
void TRI_BULLE(int *T, int N)

{
int RANGER(int *X, int *Y);
int FIN; /* position où la dernière permutation a eu lieu */
/* permet de ne pas trier un sous-ensemble déjà trié. */
/* Tri de T par propagation de l'élément maximal */
for (I=N-1 ; I>0 ; I=FIN)
{
FIN=0;
for (J=0; J<I; J++)
if (RANGER(T+J, T+J+1)) FIN = J;
}
}

{
. . .
}
{
. . .
}
{
. . .
}
Exercice 10.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)
Ecrire un programme qui teste la fonction FUSION à l'aide de deux tableaux lus au
clavier et triés à l'aide de TRI_BULLE.
#include <stdio.h>
main()
{
void FUSION(int *A, int *B, int *FUS, int N, int M);
void TRI_BULLE(int *T, int N);
int A[100], B[100], FUS[200];
int N, M;
/* Traitements */
printf("*** Tableau A ***\n");
LIRE_TAB (A, &N, 100);
printf("*** Tableau B ***\n");
LIRE_TAB (B, &M, 100);
TRI_BULLE(A, N);
printf("Tableau A trié : \n");
ECRIRE_TAB (A, N);
TRI_BULLE(B, M);
printf("Tableau B trié : \n");
ECRIRE_TAB (B, M);
FUSION(A,B,FUS,N,M);
printf("Tableau FUS : \n");
ECRIRE_TAB (FUS, N+M);
return 0;
}
void FUSION(int *A, int *B, int *FUS, int N, int M)

{
/* Indices courants dans A, B et FUS */
int IA,IB,IFUS;
/* Fusion de A et B dans FUS */
IA=0, IB=0; IFUS=0;
while ((IA<N) && (IB<M))
if (*(A+IA)<*(B+IB))
{
*(FUS+IFUS)=*(A+IA);
IFUS++;
IA++;
}
else
{
FUS[IFUS]=B[IB];
IFUS++;
IB++;
}
/* Si A ou B sont arrivés à la fin, alors */
/* copier le reste de l'autre tableau. */
while (IA<N)
{
*(FUS+IFUS)=*(A+IA);
IFUS++;
IA++;
}
while (IB<M)
{
*(FUS+IFUS)=*(B+IB);
IFUS++;
IB++;
}
}
void TRI_BULLE(int *T, int N)

{
int RANGER(int *X, int *Y);
. . .
}
{
. . .
}
{
. . .
}
{
. . .
}
Exercice 10.37
a) Ecrire la fonction LIRE_DIM à quatre paramètres L, LMAX, C, CMAX qui lit les
dimensions L et C d'une matrice à deux dimensions. Les dimensions L et C doivent
être inférieures à LMAX respectivement CMAX.
b) Ecrire la fonction LIRE_MATRICE à quatre paramètres MAT, L, C, et CMAX qui

lit les composantes d'une matrice MAT du type int et de dimensions L et C.
Implémenter les fonctions en choisissant bien le type des paramètres et utiliser un

dialogue semblable à celui de LIRE_TAB.
void LIRE_DIM (int *L, int LMAX, int *C, int CMAX)
{
/* Saisie des dimensions de la matrice */
do
{
printf("Nombre de lignes de la matrice (max.%d) : ",LMAX);
scanf("%d", L);
}
while (*L<0 || *L>LMAX);
do
{
printf("Nombre de colonnes de la matrice (max.%d) : ",CMAX);
scanf("%d", C);
}
while (*C<0 || *C>CMAX);
}
b) Ecrire la fonction LIRE_MATRICE à quatre paramètres MAT, L, C, et CMAX qui

lit les composantes d'une matrice MAT du type int et de dimensions L et C.
void LIRE_MATRICE (int *MAT, int L, int C, int CMAX)

{
int I,J;
/* Saisie des composantes de la matrice */
for (I=0; I<L; I++)
for (J=0; J<C; J++)
{
printf("Elément[%d][%d] : ", I, J);
scanf("%d", MAT + I*CMAX + J);
}
}
Exercice 10.38
Ecrire la fonction ECRIRE_MATRICE à quatre paramètres MAT, L, C et CMAX qui

affiche les composantes de la matrice de dimensions L et C.
void ECRIRE_MATRICE (int *MAT, int L, int C, int CMAX)

{
int I,J;
/* Affichage des composantes de la matrice */
for (I=0; I<L; I++)
{
for (J=0; J<C; J++)
printf("%7d", *(MAT + I*CMAX + J));
printf("\n");
}
}
Exercice 10.39
Ecrire la fonction SOMME_MATRICE du type long qui calcule la somme des

éléments d'une matrice MAT du type int. Choisir les paramètres nécessaires. Ecrire
un petit programme qui teste la fonction SOMME_MATRICE.
#include <stdio.h>
main()
{
long SOMME_MATRICE (int *MAT, int L, int C, int CMAX);
void LIRE_DIM (int *L, int LMAX, int *C, int CMAX);
void LIRE_MATRICE (int *MAT, int L, int C, int CMAX);
void ECRIRE_MATRICE (int *MAT, int L, int C, int CMAX);
int M[30][30]; /* Matrice d'entiers */
int L, C; /* Dimensions de la matrice */
/* Traitements */
LIRE_DIM (&L, 30, &C, 30);
LIRE_MATRICE ( (int*)M, L,C,30);
printf("Matrice donnée : \n");
ECRIRE_MATRICE ( (int*)M, L,C,30);
printf("Somme des éléments de la matrice : %ld\n",
SOMME_MATRICE( (int*)M, L,C,30));
return 0;
}
long SOMME_MATRICE(int *MAT, int L, int C, int CMAX)

{
int I,J;
long SOMME = 0;
for (I=0; I<L; I++)
for (J=0; J<C; J++)
SOMME += *(MAT + I*CMAX + J);
return SOMME;
}
{
. . .
}

{
. . .
}

{
. . .
}
Exercice 10.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.
#include <stdio.h>
main()
{
void ADDITION_MATRICE (int *MAT1, int *MAT2, int L, int C, int
CMAX);
/* Les matrices et leurs dimensions */
int M1[30][30], M2[30][30];
int L, C;
/* Traitements */
LIRE_DIM (&L,30,&C,30);
printf("*** Matrice 1 ***\n");
LIRE_MATRICE ((int*)M1,L,C,30 );
LIRE_MATRICE ((int*)M2,L,C,30 );
printf("Matrice donnée 1 : \n");
ECRIRE_MATRICE ((int*)M1,L,C,30);
ADDITION_MATRICE( (int*)M1 , (int*)M2 ,L,C,30);
printf("Matrice résultat : \n");
return 0;
}
void ADDITION_MATRICE (int *MAT1, int *MAT2, int L, int C, int CMAX)
{
int I,J;
/* Ajouter les éléments de MAT2 à MAT1 */
for (I=0; I<L; I++)
for (J=0; J<C; J++)
*(MAT1+I*CMAX+J) += *(MAT2+I*CMAX+J);
}
{
. . .
}

{
. . .
}

{
. . .
}
Exercice 10.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.
#include <stdio.h>
main()
{
void MULTI_MATRICE(int X, int *MAT, int L, int C, int CMAX);
int X;
/* Traitements */
LIRE_DIM (&L,30,&C,30);
LIRE_MATRICE ((int*)M,L,C,30 );
printf("Introduire le multiplicateur (entier) : ");
scanf("%d", &X);
ECRIRE_MATRICE ((int*)M,L,C,30);
MULTI_MATRICE (X,(int*)M,L,C,30);
return 0;
}
void MULTI_MATRICE(int X, int *MAT, int L, int C, int CMAX)

{
int I,J;
/* Multiplication des éléments */
for (I=0; I<L; I++)
for (J=0; J<C; J++)
*(MAT+I*CMAX+J) *= X;
}
{
. . .
}

{
. . .
}

{
. . .
}
Exercice 10.42
Ecrire la fonction TRANSPO_MATRICE à cinq paramètres MAT, L, LMAX, C,

CMAX qui effectue la transposition de la matrice MAT en utilisant la fonction
PERMUTER. TRANSPO_MATRICE retourne une valeur logique qui indique si les
dimensions de la matrice sont telles que la transposition a pu être effectuée. Ecrire un
petit programme qui teste la fonction TRANSPO_MATRICE.
#include <stdio.h>
main()
{
int TRANSPO_MATRICE (int *MAT, int *L, int LMAX, int *C, int CMAX);
/* Traitements */
LIRE_DIM (&L,30,&C,30);
LIRE_MATRICE ((int*)M,L,C,30 );
if (TRANSPO_MATRICE ((int*)M,&L,30,&C,30))
{
printf("Matrice transposée : \n");
}
else
printf("\aLa matrice n'a pas pu être transposée\n");
return 0;
}
int TRANSPO_MATRICE (int *MAT, int *L, int LMAX, int *C, int CMAX)
{
int I,J;
int DMAX; /* la plus grande des deux dimensions */
/* Transposition de la matrice */
if (*L>CMAX || *C>LMAX)
return 0;
else
{
DMAX = (*L>*C) ? *L : *C;
for (I=0; I<DMAX; I++)
for (J=0; J<I; J++)
PERMUTER (MAT+I*CMAX+J, MAT+J*CMAX+I);
PERMUTER(L,C); /* échanger les dimensions */
return 1;
}
}

{
. . .
}
{
. . .
}

{
. . .
}

{
. . .
}
Exercice 10.43
Ecrire la fonction MULTI_2_MATRICES qui effectue la multiplication de deux

matrices MAT1 (dimensions N et M) et MAT2 (dimensions M et P) en une troisième
matrice MAT3 (dimensions N et P):
MAT3 = MAT1 * MAT2
Supposez que les dimensions maximales des trois matrices soient toutes égales à 30
lignes et 30 colonnes. Ecrire un petit programme qui teste la fonction
MULTI_2_MATRICES. (Méthode de calcul: voir exercice 7.22.)
#include <stdio.h>
main()
{
void MULTI_2_MATRICES (int *MAT1, int *MAT2, int *MAT3,
int N, int M, int P, int CMAX);
/* Les matrices et leurs dimensions */
int M1[30][30], M2[30][30], M3[30][30];
int N, M, P;
int DUMMY; /* pour la lecture de la première dimension de */
/* MAT2 à l'aide de LIRE_DIM. */
/* Traitements */
LIRE_DIM (&N,30,&M,30);
LIRE_MATRICE ((int*)M1,N,M,30 );
LIRE_DIM (&DUMMY,30,&P,30);
LIRE_MATRICE ((int*)M2,M,P,30 );
ECRIRE_MATRICE ((int*)M1,N,M,30);
ECRIRE_MATRICE ((int*)M2,M,P,30);
MULTI_2_MATRICES ((int*)M1 , (int*)M2 , (int*)M3 , N,M,P,30);
ECRIRE_MATRICE ((int*)M3,N,P,30);
return 0;
}
void MULTI_2_MATRICES (int *MAT1, int *MAT2, int *MAT3,

int N, int M, int P, int CMAX)
{
int I,J,K;
/* Multiplier MAT1 et MAT2 en affectant le résultat à MAT3 */
for (I=0; I<N; I++)
for (J=0; J<P; J++)
{
*(MAT3+I*CMAX+J)=0;
for (K=0; K<M; K++)
*(MAT3+I*CMAX+J) += *(MAT1+I*CMAX+K) * *(MAT2+K*CMAX+J);
}
}
{
. . .
}

{
. . .
}

{
. . .
}

Exercices en C

Transféré par

Droits d'auteur :

Formats disponibles

Exercices en C

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Exercices en C

Transféré par

Droits d'auteur :

Formats disponibles

EXERCICES EN C

a) if - else et une variable d'aide MAX

b) if - else if - ... - else sans variable d'aide

c) les opérateurs conditionnels et une variable d'aide MAX

d) les opérateurs conditionnels sans variable d'aide

a) if - else et une variable d'aide MAX

b) if - else if - ... - else sans variable d'aide

c) opérateurs conditionnels et une variable d'aide MAX

d) opérateurs conditionnels sans variable d'aide

val(A) val(B) val(C)

Affichez les trois valeurs.

/* Calcul du discriminant b^2-4ac */

/* Distinction des différents cas */

d) Laquelle des trois variantes est la plus naturelle pour ce problème?

printf("Nombre de données : ");

printf("La somme des %d nombres est %ld \n", N, SOM);

Complétez la 'meilleure' des trois versions de l'exercice 6.1 :

Quelle structure répétitive utilisez-vous? Pourquoi?

Remplacer les lignes

printf("Nombre de données : ");

Quelle structure répétitive utilisez-vous? Pourquoi?

Calculez par des soustractions successives le quotient entier et le reste de la division

printf("Introduisez le numérateur : ");

Calculez la factorielle N! = 123...(N-1)N d'un entier naturel N en respectant que 0!=1.

printf ("%d! = %.0f\n", N, FACT);

Calculez par multiplications successives XN de deux entiers naturels X et N entrés au

/* Pour N=0, le résultat sera automatiquement X^0=1 */

/* Attention: Pour X=0 et N=0 , 0^0 n'est pas défini */

Exercice 6.6 Calculez la somme des N premiers termes de la série harmonique :

Solution (une de plusieurs solutions possibles) :

NOMB += pow(10, N)*X;

printf("Le nombre 'inversé' est : %d\n", NINV);

P(X) = AnXn + An-1Xn-1 + ... + A1X + A0

Les valeurs de n, des coefficients An, ... , A0 et de X seront entrées au clavier.

printf("Entrer le degré N du polynôme : ");

for(P=0.0 ; N>=0 ; N--)

printf("Valeur du polynôme pour X = %.2f : %.2f\n", X, P);

Calculez le P.G.C.D. de deux entiers naturels entrés au clavier en utilisant

for (RESTE=A, X=A, Y=B ; RESTE ; X=Y, Y=RESTE)

printf("Le PGCD de %d et de %d est %d\n", A, B, X);

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

- le type long double

U1=U2=1; /* Initialisation des deux premiers termes */

Rang et terme maximal calculable en utilisant les déclarations :

int U1, U2, UN; (spéc. de format : %d) U23 = 28657

a) Calculez la racine carrée X d'un nombre réel positif A par approximations

XJ+1 = (XJ + A/XJ) / 2 X1 = A

La précision du calcul J est à entrer par l'utilisateur.

c) Affichez lors du calcul toutes les approximations calculées :

La 1ère approximation de la racine carrée de ... est ...

for(X=A, J=1 ; J<=N ; J++)

Affichez un triangle isocèle formé d'étoiles de N lignes (N est fourni au clavier):

for (L=0 ; L<LIG ; L++)

Affiche la table des produits pour N variant de 1 à 10 :

Calculer et afficher ensuite la somme des éléments du tableau.

/* Saisie des données */

/* Saisie des données */

/* Saisie des données */