Exercices

Algorithmique et programmation

Assurée par :
Emna Ammar Elhadjamor
Exercices Algorithmiques
1. Donnez toutes les raisons pour lesquelles l'algorithme suivant est incorrect :
Algoritme Incorrect
x,y : Entier
z : Réel
Début
zx + 2
yz
x * 23 + z
y 5y + 3
Fin.
Cet algorithme est incorrect pour plusieurs raisons:
Ligne 1 : le mot Algorithme s'écrit avec un "h" au milieu.
Ligne 2 : la déclaration des variables commence par le mot "Var".
Ligne 5 : la valeur de x est indéterminée.
Ligne 6 : incompatibilité de type (un réel affecté à une variable de type entier).
Ligne 7 : le membre gauche d'une affectation doit être une variable.
Ligne 8 : il faut écrire 5 *y et non 5y.
2. Ecrivez un algorithme qui calcule et affiche la valeur absolue d'un entier quelconque lu
au clavier.
Algorithme Val_Abs
Var
x, va : Entier
Début
Ecrire("Entrer un entier="), Lire(x)
Si ( x >= 0 ) Alors
va x
Sinon
va-x
FinSi
Ecrire("|",x,"|=",va)
Fin.
3. Ecrivez un algorithme permettant d’afficher la saison en introduisant le numéro du mois.
Algorithme Saison;
Var M :entier ;
Début Ecrire(‘Donner un numéro de mois 1--12’) ;
Répéter Lire(M) ;
Jusqu’à M>0 et M<13
selon M faire
3,4,5 : Ecrire(‘La saison est : PRINTEMPS’) ;
6,7,8 : Ecrire(‘La saison est : ETE’) ;
9,10,11 : Ecrire(‘La saison est : AUTOMNE’) ;
12,1,2 : Ecrire(‘La saison est : HIVER’) ;
Finselon ;
Fin
4. Ecrivez un algorithme qui lit un entier positif et vérifie si ce nombre est premier ou non. Un
nombre premier n'est divisible que par 1 ou par lui-même.

2
 Algorithme Premier
Var
n,i,nb_div: Entier
Début
Ecrire("Entrer un entier possitif="), Lire(n)
nb_div0 /* initialisation du nombre de diviseurs*/
i 1
Tant que (i <= n) Faire
Si ( n Mod i = 0 ) Alors
nb_divnb_div + 1 /* incrémentation du nombre de diviseurs */
FinSi
i i +1
Fin Tant que
Si (nb_div <= 2) Alors
Ecrire("C'est un nombre premier")
Sinon
Ecrire("Ce n'est pas un nombre premier")
Fin Si
Fin.
5. Ecrivez un algorithme avec trois versions qui lit un entier positif n puis calcule et
affiche son factoriel selon la formule n! = 1 x 2 x … x n.
Pour…Faire
Tant que … Faire
Répéter … Jusqu'à…
Version Pour… Faire
Algorithme Facto
Var
n,i,f : Entier
Début
Ecrire("Entrer un entier positif="), Lire(n)
f 1 /* initialisation de la factorielle à 1 puisque 1!=1 */
Pour i de 2 à n Faire
ff * i /* Pour chaque parcours on multiplie l'ancienne valeur de f par
i*/
Fin Pour
Ecrire(n,"!=",f)
Fin.
Version Tant que… Faire
Algorithme Facto
Var
n,i,f : Entier
Début
Ecrire("Entrer un entier positif="), Lire(n)
f1 /* initialisation de la factorielle à 1 puisque 1!=1 */
i2 /* initialisation du compteur i */
Tant que(i≤n) Faire
f f * i /* Pour chaque parcours on multiplie l'ancienne valeur de f par
i*/
i i + 1 /* incrémentation du compteur i */
Fin Pour

3
 Ecrire(n,"!=",f)
Fin.
Version Répéter… Jusqu'à
Algorithme Facto
Var
n,i,f : Entier
Début
Ecrire("Entrer un entier positif="), Lire(n)
f1 /* initialisation de la factorielle à 1 puisque 1!=1 */
i 2 (* initialisation du compteur i *)
Répéter
f f * i /* Pour chaque parcours on multiplie l'ancienne valeur de f par
i*/
ii + 1 /* incrémentation du compteur i */
Jusqu'à (i=n)
Ecrire(n,"!=",f)
Fin.
6. Ecrivez un algorithme qui lit un entier positif n puis affiche tous ses diviseurs.
Algorithme Diviseurs
Var
n,i : Entier
Début
Ecrire("Entrer un entier positif="), Lire(n)
Pour i de 1 à n Faire
Si ( n Mod i = 0 ) Alors /* Si le reste de la valeur de n est égale à 0 */
Ecrie(i)
Fin Si
Fin Pour
Fin.
7. Ecrivez un algorithme qui affiche tous les nombres parfais inférieurs à 1000. Un nombre parfait
est un nombre présentant la particularité d'être égal à la somme de tous ses diviseurs, excepté lui-
même. Le premier nombre parfait est 6 = 3 + 2 + 1. les nombres parfait inférieurs à 1000 sont : 6,
28, 496.
Algorithme parfaits
Var
i, n, s, j: Entier
Début
Pour i de 1 à 1000 Faire
s 0
Pour j de 1 à ( i Div 2 ) Faire
Si (i Mod j = 0) Alors
s s + j
Fin Si
Pour
Fin Pour
Si ( s= i) Alors
Ecrire(i, " est un nombre parfait")
Fin Si
Fin.

4
8. Ecrivez un algorithme qui cherche du minimum et du maximum dans un ensemble de N
nombres.
Algorithme MaxMin;
Var I,N,Max,Min,X :entier ;
Début Ecrire(‘Donner un entier N>0’) ;
Répéter Lire(N) ;
Jusqu’à N>0 ; /* Lire le premier élément, puis initialiser le Min et le
Max à cette valeur Lire(X)*/ ;
Max←X ;
Min←X ;
Pour I ←2 à N Faire /* lire la suite des éléments et mettre à jour le Min
et le Max Lire(X) */;
Si Max<X Alors Max←X
Sinon Si Min>X Alors Min←X
Finsi;
Finsi;
Fin pour ;
Ecrire(‘Le Minimun des valeurs est: ’,Min,’ le Maximum est : ‘,Max) ; Fin
9. Ecrivez un algorithme qui calcul du produit de deux entiers en utilisant uniquement
l'opération d'addition '+’.
Algorithme Produit ;
Var A,B,P,I :entier ;
Début
Ecrire(‘Donner deux entiers A et B’) ;
Lire(A,B) ;
Si A=0 ou B=0
Alors P←0
Sinon P←0 ; /*initialiser le produit à 0
Pour I ←1 à B Faire
P←P+A ;
Fin pour
Finsi ;
Ecrire(‘Le produit A*B est : ’,P) ;
Fin.
On peut optimiser la solution en choisissant la boucle ayant le moins d’itérations :
Algorithme Produit ;
Var A,B,P,I :entier ;
Début
Ecrire(‘Donner deux entiers A et B’) ;
Lire(A,B) ;

5
 Si A=0 ou B=0
Alors P←0
Sinon Si A>B
Alors P←A ; /*On peut initialiser le produit à A et commencer la boucle à
2 */
Pour I ←2 à B Faire
P←P+A ;
Fin pour
Sinon P←B ;
Pour I ←2 à A Faire
P←P+B ;
Fin pour
Finsi ;
Ecrire(‘Le produit A*B est : ’,P) ;
Fin
10. Ecrivez un algorithme qui détermine si A est divisible par B. Avec A et B des entiers
positifs.
Algorithme AdivB;
Var A,B,R :entier ;
Début
Ecrire(‘Donner deux entiers positifs A,B’) ;
Répéter Lire(A,B) ; Jusqu’à A>0 et B>0 ;
R←A ;
Tantque R≥0 Faire
R ←R-B;
Fin tantque ;
Si R=0 Alors Ecrire(A,’ est divisible par ‘,B)
Sinon Ecrire(A,’ est n’’est pas divisible par ‘,B)
Finsi ;
Fin
11. Ecrivez un algorithme qui calcule la somme des chiffres qui composent un entier naturel
N.
Algorithme SommeChiff;
Var N,S,R :entier ;
Début
Ecrire(‘Donner un entier naturel N’) ;
Répéter Lire(N) ;
Jusqu’à N≥0 ;
S←0 ; R←0 ;
Tantque R>0 Faire

6
 S←S+R MOD 10;
R← R DIV 10;
Fin tantque ;
Ecrire(‘La somme des chiffres qui composent ’,N,’ est :’,S) ;
Fin.
12. Ecrivez un algorithme qui lit un mot (chaîne de caractère formée uniquement de lettres)
ensuite il lit une lettre et affiche le nombre d'apparitions de la lettre dans le mot.
Algorithme fréquence
Var
i,L,nb: Entier
mot: Chaîne
lettre : Caractère
Début
Ecrire("Entrer un mot:"), Lire(mot)
Ecrire("Entrer une lettre:"), Lire(lettre)
L Long(mot) (* longueur du mot *)
nb 0 /* initialisation du compteur d'occurrence de la lettre cherchée
*/
Pour i de 1 à L Faire
Si (mot[i] = lettre) Alors
nb nb + 1 /* incrémentation du nombre d'occurrence */
Fin Si
Fin Pour
Ecrire(lettre," apparaît ", nb, " fois dans ", mot)
Fin
13. Ecrivez un algorithme qui lit un nombre fini de notes puis il affiche la meilleure note, la
mauvaise note et la moyenne des notes.
Algorithme Notes
Var
n, i: Entier
note, min, max, s : Réel
Début
Ecrire("Entrer le nombre de notes=")
Lire(a) (* On suppose que n est toujours supérieur à zéro *)
s 0
min0
max 0
Pour i de 1 à n Faire
Ecrire("Entrer une note="), Lire(note)
ss + note (* additionner la nouvelle note *)

7
 Si ( note < min ) Alors
min note (* mémorisation de la nouvelle valeur minimale *)
Fin Si
Si ( note > min ) Alors
maxnote (* mémorisation de la nouvelle valeur maximale *)
Fin Si
Fin Pour
Ecrire("Meilleur note = ",max)
Ecrire("Mauvaise note = ",min)
Ecrire("Moyenne des notes = ",s/n)
Fin.
14. Ecrivez un algorithme qui lit les contenus de deux chaînes de caractères, permute leurs
contenus puis les affiche à l'écran.
Algorithme permuter;
Variable a,b,aux: chaine
debut
ecrire('Donner les deux chaînes à permuter ');
lire(a,b);
aux← a;
a←b;
b←aux;
ecrire(a); ecrire(b);
fin.
15. Ecrivez un algorithme qui calcule la moyenne de 3 notes.
Algorithme moyenne;
var
moy,somme,x,y,z : entier;
debut
ecrire('Donner les trois notes entiers x, y et z ');
lire(x,y,z);
somme←x+y+z;
moy ←somme/3 ;
ecrire(moy);
Fin.
16. Ecrivez un algorithme qui lit la valeur de la température de l’eau et ensuite il affiche son
état : GLACE si la température<0, LIQUIDE si la température>0 et <100, VAPEUR si la
température > 100.
Algorithme etat
Variable T: réel
Début

8
 ecrire("Veuillez donner la température de l’eau : ")
lire(T)
Si(T<=0) Alors
ecrire("L’état de l’eau est GLACE " )
SinonSi(T>0 et T<100)Alors
lire("L’état de l’eau est LIQUIDE " )
Sinon
ecrire("L’état de l’eau est VAPEUR " )
Finsi
Finsi Fin
17. Ecrivez un algorithme qui lit une lettre au clavier puis affiche s'il s'agit d'une consonne
ou d'une voyelle. Les voyelles sont :"A", "a", "E", "e", "I", "i", "O", "o", "U", "u", "Y",
"y".
Algorithme Cons_Voy
Var
c : Caractère
Début
Répéter
Ecrire("Entrer une lettre:"), Lire(c) (* saisie contrôler d'une lettre *)
Jusqu'à ( c >= "A" ET c <= "Z") OU ( c>= "a" ET c<="z")
Si (Majus(c) = "A") OU (Majus(c) = "E") OU (Majus(c) = "I")
OU (Majus(c) = "O") OU (Majus(c) = "U") OU (Majus(c) = "Y") Alors
Ecrire(c," est une voyelle")
Sinon
Ecrire(c," est une consonne")
Fin Si
Fin.
18. Ecrivez une procédure permut qui permet d'échanger les valeurs de 2 entiers a et b.
Procédure Permut(var a,b : Entier)
Var
aux : Entier
Début
auxa
Ab
baux
Fin
Algorithme Test {programme principal}
Var
x,y : Entier
Début

9
 Ecrire("Entrer un entier x="), Lire(x)
Ecrire("Entrer un entier y="), Lire(y)
Permut(x,y) //appel de la procédure
Ecrire(La nouvelle valeur de x=",x, " et de y=",y)
Fin.
19. Ecrivez une fonction minimum qui retourne le minimum de 2 entiers a et b. Tester
cette fonction.
Fonction Minimum(a,b : Entier) : Entier
Var
min : Entier
Début
Si ( a<= b) Alors
mina
Sinon
min b
Fin Si
Fin
Algorithme Test {programme principal}
Var
x,y,m : Entier
Début
Ecrire("Entrer un entier x="), Lire(x)
Ecrire("Entrer un entier y="), Lire(y)
m Minimum(x,y) (* appel de la fonction *)
Ecrire(Le minimum est=",m)
Fin.
20. Ecrivez une procédure Remplir permettant le remplissage d'un tableau de n entiers.
Procédure Remplir (var T : Tab; n: Entier)
Var
i : Entier
Début
Pour i de 1 à n Faire
Ecrire("T[",i,"]="),Lire(T[i])
Fin Pour
Fin
21. Ecrivez une procédure Afficher permettant l'afficher les éléments d'un tableau de n
entiers.
Procédure Afficher (T : Tab; n: Entier)
Var
i : Entier
Début
Pour i de 1 à n Faire
Ecrire(T[i], " ")
Fin Pour
Fin

10
 22. Ecrivez une procédure qui permet de fusionner deux tableaux triés A et B contenant
respectivement n et m éléments. Le résultat est un tableau trié C à (n+m) éléments.
Exemple:

4 5
A 1 20 B 19 23 27 91
1 4

4
C 1 20 19 23 27 54 91
1

Procédure Fusion (A : Tab; B:Tab; var C:Tab; n, m:Entier; var k :Entier)

Var
i,j : Entier
Début
Tant que (i <=n) ET (j <= m) Faire
Si(A[i] <=B[j]) Alors
C[k] A[i]
i i + 1
k k +1
Fin Si
Si (B[j] <= A[i]) Alors
C[k] B[j]
j j + 1
k k +1
Fin Si
Fin Tant que
Tant que (i <=n) Faire
C[k]A[i]
i i + 1
k k +1
Fin Tant que
Tant que (j <=m) Faire
C[k]B[j]
j j + 1
k k +1
Fin Tant que
Fin

23. Ecrivez les procédures ou les fonctions permettant de résoudre les problèmes suivants :

1- Calcul de la somme de deux nombres entiers.

2- Calcul de la factorielle de N (N !).

3- Vérifier si un nombre entier A divise un nombre entier B.

11
4- Calcul du quotient et du reste de la division entière de deux nombres entiers A et B.

5- Vérifier si un caractère donné est une voyelle (voyelles : 'a', 'e', 'i', 'o', 'u', 'y').

6- Permet de permuter (d’échanger) le contenu de deux variables réelles.

7- Etant donné un entier A, calcule sa valeur absolue

1- Fonction Somme(x,y :entier) :entier ;

Debut

Somme ← x+y ;

Fin ;

2- Fonction Fact(x:entier) :entier ;

Var I,F :entier ;

Debut

F←1 ; /* on peut utiliser directement le nom de la fonction au lieu de F

Pour I←1 à x Faire F ← F*I ;

Fin pour ;

Fact ← F ;

Fin ;

3- Fonction Divise(A,B :entier) :booleen ;

Debut

Divise ← Faux ;

Si B mod A = 0 Alors Divise ← Vrai

Finsi ;

Fin ;

4- Procedure QuotRest(E/ A,B :entier ; S/ Q,R :entier) ;

Debut

Q ← 0 ; R ← A ;

12
 Tantque R>= B Faire

R ← R mod B ;

Q ← Q+1 ;

Fin tanque ;

Fin ;

5- Fonction Voyelle(C :caractère) :booleen ;

Debut

Voyelle ← Faux ;

selon C faire

'a', 'e', 'i', 'o', 'u', 'y': Voyelle ← Vrai ;

Finselon ;

Fin ;

6- Procedure Permute(E/S/ A,B :entier ) ;

Var C:entire:

Debut

C ← A ; A ← B ; B ← C ;

Fin ;

7- Fonction Vabs(A :entier) :entier ;

Debut

Vabs ← A ;

Si A<0 Alors Vabs ← A Fsi;

Fin ;

24. Soit un vecteur T (tableau à une dimension) contenant N nombres entiers (N≤100).
Ecrivez les algorithmes pour :
1- Détermine le minimum, le maximum et la moyenne des éléments d’un tableau T
2- Calcule le produit de tous les éléments de T ainsi que le nombre de valeurs
strictement positives.

13
3- Calcule la somme et le produit scalaire de deux vecteurs (T1 et T2).
4- Détermine les positions de l’apparition d’une valeur dans un vecteur T.
5- Inverse le contenu d’un vecteur T.
6- Supprime toutes les valeurs nulles d'un vecteur T.
7- Met les valeurs négatives au début et les valeurs positives à la fin en utilisant un seul
tableau.
1- Algorithme MinMax ;
Var T :Tableau[1..100] de entier ;
I,N,Max,Min,S :entier ; Moy :reel ;
Debut
/*lecture de la taille exacte
Ecrire(‘Donner la taille du tableau N≤100’) ;
Repeter Lire(N) Jusqu’à N>0 et N≤100 ;
/*Lecture des éléments de T
Pour I←1 à N Faire Lire(T[I]) ; Finpour ;
/*Initialisation
Min←T[1] ; Max←T[1] ; S←0 ;
Pour I←1 à N Faire
Si Max<T[I] Alors Max←T[I] Finsi ;
Si Min>T[I] Alors Min←T[I] Finsi ;
S←S+ T[I] ;
Finpour ;
Moy←S/N ;
Ecrire(‘Maximum=’,Max,’ Minimum=’,Min,’ Moyenne=’,Moy) ;
Fin.
2- Algorithme Prod ;
Var T :Tableau[1..100] de entier ;
I,N,P,Nbp :entier ;
Debut
/*lecture de la taille exacte
Ecrire(‘Donner la taille du tableau N≤100’) ;
Repeter Lire(N) Jusqu’à N>0 et N≤100 ;
/*Initialisation
P←1 ; Nbp←0 ;
/*Lecture des éléments de T et traitement en même temps
Pour I←1 à N Faire
Lire(T[I]) ;
Si T[I]>0 Alors Nbp←Nbp+1 Finsi ;
P←P* T[I] ;

14
Finpour ;
Ecrire(‘Produit=’,P,’ Nb val positives=’,Nbp) ;
Fin.
3- Algorithme Prod ;
Var T1,T2,T3 :Tableau[1..100] de entier ;
I,N,PS :entier ;
Debut
/*lecture de la taille exacte
Ecrire(‘Donner la taille du tableau N≤100’) ;
Repeter Lire(N) Jusqu’à N>0 et N≤100 ;
/*Lecture des éléments de T1 ensuite T2 ne pas lire dans la même
boucle
Pour I←1 à N Faire Lire(T1[I]) ; Fin pour ;
Pour I←1 à N Faire Lire(T2[I]) ; Fin pour ;
PS←0 ; /*initialiser Produit scalaire à 0
/*La somme de T1 et T2 dans T3
Pour I←1 à N Faire
T3[I]←T1[I]+ T2[I];
PS←PS+ T1[I]* T2[I];
Finpour ;
Ecrire(‘Produit Scalaire=’,PS) ;
Ecrire(‘Somme des vecteurs’) ;
Pour I←1 à N Faire Ecrire (T3[I]) ; Finpour ;
Fin.
4- Algorithme Position ;
Var T ,Pos:Tableau[1..100] de entier ;
I,J,N,Val :entier ;
Debut
/*lecture de la taille exacte
Ecrire(‘Donner la taille du tableau N≤100’) ;
Repeter Lire(N) Jusqu’à N>0 et N≤100 ;
Pour I←1 à N Faire Lire(T[I]) ; Finpour ;
Ecrire(‘Donner Val’) ; Lire(Val) ;
/*Recherche de val et sa position
J←0 ;
Pour I←1 à N Faire
Si T[I]=Val Alors J←J+1 ;Pos[J]←I Finsi ;
Fait ;
Si J=0 Alors Ecrire(Val,’non trouvée’)
Sinon Ecrire(Val,’trouvée aux positions :’) ;

15
Pour I←1 à J Faire Ecrire (Pos[I]) ; Finpour ;
Finsi ;
/* Si on initialise J à 1, son incrémentation se fait après
l’affectation et la
/*dimension de Pos devient J-1
Fin.
5- Algorithme Inverse ;
Var T :Tableau[1..100] de entier ;
I,J,X,N:entier ;
Debut
/*lecture de la taille exacte
Ecrire(‘Donner la taille du tableau N≤100’) ;
Repeter Lire(N) Jusqu’à N>0 et N≤100 ;
/*Lecture des éléments de T
Pour I←1 à N Faire Lire(T[I]) ; Finpour ;
/*Inverser
I←1 ; J←N ;
Tantque I<J
Faire
X←T[I] ; T[I]←T[J]; T[J]←X;
I←I+1 ; J←J-1;
Fintantque ;
/*Affichage du nouveau tableau T
Pour I←1 à N Faire Ecrire(T[I]) ; Fin pour ;
Fin.
6- Algorithme SupprimeZero ;
Var T :Tableau[1..100] de entier ;
I,J,N:entier ;
Debut
/*lecture de la taille exacte
Ecrire(‘Donner la taille du tableau N≤100’) ;
Repeter Lire(N) Jusqu’à N>0 et N≤100 ;
/*Lecture des éléments de T
Pour I←1 à N Faire Lire(T[I]) ; Finpour ;
/*la suppression des zéro revient à décaler les valeurs non nulles
I←1 ;
Tantque I≤N
Faire
Si T[I]=0
Alors /*boucle de décalage

16
Pour J←I à N-1 Faire T[J]←T[J+1];
Finpour ;
N←N-1 /*changer la taille du tableau
Finsi ;
I←I+1 ;
Fintantque ;
/*Affichage du nouveau tableau T
Pour I←1 à N Faire Ecrire(T[I]) ;
Finpour ;
Fin.
Solution 2 :
Algorithme SupprimeZero2 ;
Var T :Tableau[1..100] de entier ;
I,J,NBN,N:entier ;
Debut
/*lecture de la taille exacte
Ecrire(‘Donner la taille du tableau N≤100’) ;
Repeter Lire(N) Jusqu’à N>0 et N≤100 ;
/*Lecture des éléments de T
Pour I←1 à N Faire Lire(T[I]) ; Finpour ;
/*la suppression des zéro revient à déplacer les valeurs non nulles 1
après 1(sans boucle)
I←1 ; J←1 ; NBN←0 ;
Tantque J≤N Faire
Si T[J]=0 Alors NBN←NBN+1 /*nombre de valeurs nulles
Sinon /*déplacer l’élément
T[I]← T[J] ; I←I+1
Finsi ;
J←J+1;
Fintantque ;
N←N-NBN ; /*changer la taille de T
/*Affichage du nouveau tableau T
Pour I←1 à N Faire Ecrire(T[I]) ; Finpour ;
Fin.
7- Algorithme NegPuisPos ;
Var T :Tableau[1..100] de entier ;
I,J,N,X:entier ;
Debut
/*lecture de la taille exacte
Ecrire(‘Donner la taille du tableau N≤100’) ;

17
 Repeter Lire(N) Jusqu’à N>0 et N≤100 ;
/*Lecture des éléments de T
Pour I←1 à N Faire Lire(T[I]) ; Finpour ;
/*passer les valeurs négatives au début
J←1 ;
Tantque J≤N et T[J]<0 Faire J←J+1 ; Fait ;
/*déplacer les valeurs négatives au début (trouver la première valeur
positive I )
I←J ;
Tantque J≤N Faire
Si T[J]<0 Alors /*permuter
X← T[I] ; T[I]←T[J]; T[J]←X;
I←I+1
Finsi ;
J←J+1 ;
Fintantque ;
/*Affichage du nouveau tableau T
Pour I←1 à N Faire Ecrire(T[I]) ; Finpour ;
Fin.
25. Ecrivez des procédures permettant de :
1. Remplir une matrice;
2. Afficher une matrice;
3. Renvoyer la somme de deux matrices M1 et M2;
4. Renvoyer le produit de deux matrices M1 et M2;
1. Remplissage d'une matrice
Procédure Remplir (var matrice : Mat; n,m: Entier)
Var
i,j : Entier
Début
Pour i de 1 à n Faire
Pour j de 1 à m Faire
Ecrire("Entrer un entier : "),Lire(T[i,j])
Fin Pour
Fin Pour
Fin
2. Affichage d'une matrice
Procédure Afficher (matrice : Mat; n,m: Entier)
Var
i,j : Entier
Début
Pour i de 1 à n Faire
Pour j de 1 à m Faire
Ecrire(T[i,j])
Fin Pour

18
Fin Pour
Fin
3. Somme de deux matrices
Procédure SomMat (M1,M2 : Mat ; var M3 : Mat; n,m: Entier)
Var
i,j : Entier
Début
Pour i de 1 à n Faire
Pour j de 1 à m Faire
M3[i,j] M1[i,j] + M2[i,j]
Fin Pour
Fin Pour
Fin
4. Produit de deux matrices
Procédure ProdMat (M1,M2 : Mat ; var M3 : Mat; n,m: Entier; var k :
Entier)
Var
i,j : Entier
Début
Pour i de 1 à n Faire
Pour j de 1 à m Faire
M3[i,j] 0
Pour k de 1 à m Faire
M3[i,j]M3[i,j] + M1[i,k] * M2[k,j]
Fin Pour
Fin Pour
Fin Pour
Fin

19
Exercices En C
1. 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)

#include <stdio.h>
main()
{
/* Tri par ordre décroissant de trois entiers
en échangeant les valeurs
*/
int A, B, C, AIDE;
printf("Introduisez trois nombres entiers :");
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);
}

2. Ecrivez 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 la longueur L de la chaîne et le nombre
de 'e' contenus dans le texte

#include <stdio.h>
main()
{
/* Déclarations */
char TXT[201]; /* chaîne donnée */
int I,J; /* indices courants */
int L; /* longueur de la chaîne */
int C; /* compteur des lettres 'e' */
int AIDE; /* pour l'échange des caractères */
/* Saisie des données */

20
printf("Entrez une ligne de texte (max.200 caractères)
:\n");
gets(TXT); /* L'utilisation de scanf est impossible pour */
/* lire une phrase contenant un nombre variable de mots. */
/* a) Compter les caractères */
/* La marque de fin de chaîne '\0' est */
/* utilisée comme condition d'arrêt. */
for (L=0; TXT[L]; L++)
;
printf("Le texte est composé de %d caractères.\n",L);
/* b) Compter les lettres 'e' dans le texte */
C=0;
for (I=0; TXT[I]; I++)
if (TXT[I]=='e') C++;
printf("Le texte contient %d lettres \'e\'.\n",C);
/* c) Afficher la phrase à l'envers */
for (I=L-1; I>=0; I--)
putchar(TXT[I]); /* ou printf("%c",TXT[I]); */
putchar('\n'); /* ou printf("\n"); */
/* d) Inverser l'ordre des caractères */
for (I=0,J=L-1 ; I<J ; I++,J--)
{
AIDE=TXT[I];
TXT[I]=TXT[J];
TXT[J]=AIDE;
}
puts(TXT); /* ou printf("%s\n",TXT); */
return (0);
}

3. Ecrivez un programme qui lit un texte TXT (de moins de 200 caractères) et qui enlève toutes
les apparitions du caractère 'e' en tassant les éléments restants. Les modifications se feront
dans la même variable TXT.

#include <stdio.h>
main()
{
/* Déclarations */

char TXT[201]; /* chaîne donnée */

int I,J; /* indices courants */
/* Saisie des données */
printf("Entrez une ligne de texte (max.200 caractères)
:\n");
gets(TXT);
/* 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'. */
for (J=0,I=0 ; TXT[I] ; I++)
{
TXT[J] = TXT[I];
if (TXT[I] != 'e') J++;

21
}
/* Terminer la chaîne !! */
TXT[J]='\0';
/* Edition du résultat */
puts(TXT);
return (0);
}
Exemple :
Cette ligne contient quelques lettres e.
Ctt lign contint qulqus lttrs .

4. Ecrivez un programme qui calcule la moyenne de notes fournies au clavier avec un dialogue
de ce type :

note 1 : 12
note 2 : 15.25
note 3 : 13.5
note 4 : 8.75
note 5 : -1
moyenne de ces 4 notes : 12.37
Le nombre de notes n’est pas connu a priori et l’utilisateur peut en fournir autant qu’il le désire.
Pour signaler qu’il a terminé, on convient qu’il fournira une note fictive négative. Celle-ci ne devra
naturellement pas être prise en compte dans le calcul de la moyenne.
#include <stdio.h>
main()
{ float note, /* note courante */
som, /* somme des notes */
moy ; /* moyenne des notes */
int num ; /* numéro note courante */
som=0 ; num=0 ;
while ( printf("note %d : ",num+1),
scanf ("%f", &note), note>=0 )
{ num++ ;
som += note ;
}

if (num>0)
{ moy = som/num ;
printf ("moyenne de ces %d notes : %5.2f", num, moy) ;
}
else printf ("--- aucune note fournie ---") ;
}

5. Ecrivez 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. Employez la fonction
strlen.

#include <stdio.h>
#include <string.h>
main()
{

22
char NOM[40], PRENOM[40];
printf("Introduisez votre nom et votre prénom : \n");
scanf("%s %s", NOM, PRENOM);
printf("\nBonjour %s %s !\n", NOM, PRENOM);
printf("Votre nom est composé de %d lettres.\n",
strlen(NOM) + strlen(PRENOM));
/* ou bien
printf("Votre nom est composé de %d lettres.\n",
strlen(strcat(NOM,PRENOM)));
*/
return (0);
}

6. 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)

Ecrivez 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 A[50][50]; /* matrice donnée */
int B[50][50]; /* matrice donnée */
int C[50][50]; /* matrice résultat */
int N, M, P; /* dimensions des matrices */
int I, J, K; /* indices courants */
/* Saisie des données */
printf("*** Matrice A ***\n");
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("Elément[%d][%d] : ",I,J);
scanf("%d", &A[I][J]);

23
}
printf("*** Matrice B ***\n");
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++)
{
printf("Elément[%d][%d] : ",I,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("%7d", A[I][J]);
printf("\n");
}
printf("Matrice donnée B :\n");
for (I=0; I<M; I++)
{
for (J=0; J<P; J++)
printf("%7d", B[I][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];
}
/* Edition du résultat */

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

7. Ecrire un programme qui permet d'afficher à l'écran un rectangle de longueur L et de hauteur

H, formé d'astérisques '*' :

24
#include <stdio.h>
main()
{
/* Prototypes des fonctions appelées par main */
void RECTANGLE(int L, int H);
/* Déclaration des variables locales de main */
int L, H;
/* Traitements */
printf("Entrer la longueur (>= 1): ");
scanf("%d", &L);
printf("Entrer la hauteur (>= 1): ");
scanf("%d", &H);
/* Afficher un rectangle d'étoiles */
RECTANGLE(L,H);
return (0);
}
Pour que la fonction soit exécutable par la machine, il faut encore spécifier la
fonction
RECTANGLE :
void RECTANGLE(int L, int H)
{
/* Prototypes des fonctions appelées */

void LIGNE(int L);

/* Déclaration des variables locales */
int I;
/* Traitements */
/* Afficher H lignes avec L étoiles */
for (I=0; I<H; I++)
LIGNE(L);
}
Pour que la fonction RECTANGLE soit exécutable par la machine, il faut
spécifier la
fonction LIGNE :
void LIGNE(int L)
{
/* Affiche à l'écran une ligne avec L étoiles */
/* Déclaration des variables locales */
int I;
/* Traitements */
for (I=0; I<L; I++)
printf("*");
printf("\n");
}

25
 8. 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.

#include <stdio.h>
main()
{
/* Prototypes des fonctions appelées */
float MOYENNE(float X, float Y);
/* Variables locales */
float A,B;

/* Traitements */

printf("Introduire deux nombres : ");

scanf("%f %f", &A, &B);

printf("La moyenne arithmétique de %.2f et %.2f est %.4f\n",

A, B,

MOYENNE(A,B));

return (0);

float MOYENNE(float X, float Y)

return (X+Y)/2;

9. Ecrire une fonction MIN et une fonction MAX qui déterminent le minimum et le maximum
de deux nombres réels. 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.

#include <stdio.h>
main()
{
/* Prototypes des fonctions appelées */
double MIN(double X, double Y);
double MAX(double X, double Y);
/* Variables locales */
double A,B,C,D;
/* Traitements */
printf("Introduire 4 réels : ");
scanf("%lf %lf %lf %lf", &A, &B, &C, &D);
printf("Le minimum des 4 réels est %f \n",
MIN( MIN(A,B), MIN(C,D))
);
printf("Le maximum des 4 réels est %f \n",

26
MAX( MAX(A,B), MAX(C,D))
);
return (0);
}
double MIN(double X, double Y)
{
if (X<Y)
return X;
else
return Y;
}
double MAX(double X, double Y)
{
if (X>Y)
return X;
else
return Y;
}
/* ou bien */
/*
double MIN(double X, double Y)
{
return (X<Y) ? X : Y;
}

double MAX(double X, double Y)

{
return (X>Y) ? X : Y;
} «
*/

10. Ecrire une fonction C qui affiche l’aire d’un triangle dont la base et la hauteur sont
passées en paramètre. Écrire le programme principal qui saisit la base et la hauteur
d’un triangle et affiche l’aire du triangle.

void aire(float base, float hauteur)

{
printf("Aire = %f\n", (base * hauteur) / 2.0);
}
int main(void)
{
float b, h;
printf("Entrez la base et la hauteur du triangle : ");
scanf("%f %f", &b, &h);
aire(b, h);
return 0;
}

11. Écrire une fonction qui calcule la factorielle n! d’un entier n passé en paramètre.
(Rappel : n! = 1 × 2 × · · · × n)

27
int fact(int n)
{
int f = 1;
while (n > 0)
{
f = f * n;
n = n - 1;
}
return f;
}

12. Écrivez un programme qui saisit deux variables de type int, qui échange leur
contenu et qui affiche les nouvelles valeurs des variables.
On se propose de refaire la question a) en réalisant l’échange de valeurs à l’intérieur d’une
fonction. Écrivez une fonction qui échange le contenu de deux variables passées par adresse.
Écrivez le programme principal qui saisit deux variables, les échange en appelant la fonction
et affiche le nouveau contenu des variables.

a)
int main()
{
int a = 14, b = 5;
int t;
printf("a = %d; b = %d\n", a, b);
t = a;
a = b;
b = t;
printf("a = %d; b = %d\n", a, b);
return 0;
}
b)
void echange(int *a, int *b)
{
int t;
t = *a;
*a = *b;
*b = t;
}
int main()
{
int a = 14, b = 5;
printf("a = %d; b = %d\n", a, b);
echange(&a, &b);
printf("a = %d; b = %d\n", a, b);
return 0;
}

28
 13. Écrivez une fonction qui calcule la somme et le produit des éléments d’un tableau passé en
paramètre. Écrivez le programme principal qui initialise le tableau par saisie ; calcule et
affiche la somme et le produit des éléments

#define NB_ELEM_MAXI 100

void calcul(int t[], int taille, int *somme, int *produit)
{
int i;
*somme = 0;
*produit = 1;
for (i = 0; i < taille; i++)
{
*somme += t[i];
*produit *= t[i];
}
}
int main()
{
int tab[NB_ELEM_MAXI];
int s, p, taille=-1, i;
while (taille < 0 || taille > NB_ELEM_MAXI)
{
printf("Entrez le nombre d’éléments : ");
scanf("%d", &taille);
}
puts("Veuillez saisir les éléments du tableau");

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

scanf("%d", &tab[i]);
calcul(tab, taille, &s, &p);
printf("somme = %d et produit = %d\n", s, p);
return 0;
}.

14. 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 */
int I, J; /* indices courants */
/* Saisie des données */
printf("Dimension de la matrice carrée (max.50) : ");
scanf("%d", &N);
for (I=0; I<N; I++)
for (J=0; J<N; J++)

29
{
printf("Elément[%d][%d] : ",I,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;

/* Edition du résultat */
printf("Matrice résultat :\n");
for (I=0; I<N; I++)
{
for (J=0; J<N; J++)
printf("%7d", A[I][J]);
printf("\n");
}
return (0);
}

15. Ecrivez 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 */
int I, J; /* indices courants */
/* Saisie des données */
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;
/* Edition du résultat */

30
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);

16. Écrivez un programme qui utilise une fonction pour calculer la moyenne de cinq valeurs de
type float, données par l’utilisateur.

/* Calcul de la moyenne des cinq nombres entrés par l’utilisateur */

#include <stdio.h>
#include <stdlib.h>
float v, w, x, y, z, reponse;
float moyenne(float a, float b, float c, float d, float e);
int main()
{
puts("Entrez cinq nombres :");
scanf("%f%f%f%f%f", &v, &w, &x, &y, &z);
reponse = moyenne(v, w, x, y, z);
printf(("La moyenne est %f.\n", reponse);
exit(EXIT_SUCCESS);
}
float moyenne(float a, float b, float c, float d, float e)
{
return((a+b+c+d+e)/5);
}

17. Écrivez une fonction C qui calcule la moyenne de trois nombres passés en paramètre. Écrire
le programme principal qui saisit trois nombres au clavier et affiche leur moyenne.

float moyenne(float a, float b, float c)

{
return (a + b + c) / 3.0;
}
int main(void)
{
float n1, n2, n3;
printf("Entrez trois nombres : ");
scanf("%f %f %f", &n1, &n2, &n3);
printf("La moyenne des nombres vaut %f\n", moyenne(n1, n2, n3));

31
return 0;
}

18. Ecrivez un programme qui permet de mémoriser différentes valeurs saisies au clavier et de
les réafficher dans l’ordre où elles ont été saisies. Le nombre de valeurs, ou nombre
d’éléments du tableau, est fixé à 15.

#include <stdio.h>
#define NB_ELEM 15 /* Nombre d’éléments du tableau */
/* ******** Fonction Affichage ********** */
/* Affiche un tableau */
void Affichage(float tableau[NB_ELEM])
{
int i;
for (i=0 ; i<NB_ELEM ; i++)
{
printf("l’élément numéro %d vaut %f\n", i, tableau[i]);
}
}
/* ********* Fonction main ********** */
/* Lit un tableau et le fait afficher */
int main()
{
int i; /* indice */
float tableau[NB_ELEM]; /* déclaration du tableau */
for (i=0 ; i<NB_ELEM ; i++)
{
printf("Entrez l’élément %d : ", i);
scanf("%f", &tableau[i]); /* lecture d’un élément */
}
Affichage(tableau); /* Affichage du tableau */
return 0;
}

19. Ecrivez un programme qui permet aussi de lire des éléments au clavier et de les réafficher,
mais cette fois le nombre d’éléments est lu au clavier. Ce nombre d’éléments doit toutefois
rester inférieur à une valeur maximale constante fixée.

#include <stdio.h>
#define NB_ELEM_MAXI 100 /* Nombre maximum d’éléments */
/* du tableau */
/* ******** Fonction Affichage ********** */
/* Affiche un tableau de taille n */
void Affichage(float tableau[], int n)
{
int i;
for (i=0 ; i<n ; i++)
{
printf("l’élément numéro %d vaut %f\n", i, tableau[i]);
}
}

32
/* ********* Fonction main ********** */
/* Lit un tableau et le fait afficher */
int main()
{
int n, i; /* nombre d’éléments et indice */
float tableau[NB_ELEM_MAXI]; /* déclaration du tableau */
printf("Entrez le nombre d’éléments à taper : ");

/* lecture du nombre d’éléments au clavier (variable) */

scanf("%d", &n);
if (n > NB_ELEM_MAXI)
{ /* test d’erreur */
puts("Erreur, nombre trop grand !");
return 1;
}
for (i=0 ; i<n ; i++)
{ /* n éléments */
printf("Entrez l’élément %d : ", i);
scanf("%f", &tableau[i]); /* lecture d’un élément */
}
Affichage(tableau, n); /* Affichage du tableau */
return 0;
}

20. Écrivez une fonction qui prend en paramètre un tableau de taille NB_MAX, son nombre
d’éléments n < NB_MAX, un entier i ≤ n, et un entier m. La fonction doit insérer l’élément
m en position i dans le tableau (sans supprimer d’élément).

#define NB_MAX 100

void insertion(int t[NB_MAX], int n, int i, int m)
{
int j = n;
while (j > i)

{
t[j] = t[j - 1];
j--;
}
t[i] = m;
}

21. Écrivez une fonction qui initialise toutes les valeurs d’un tableau à 0. Écrivez le programme
principal qui déclare le tableau, appelle la fonction et affiche les éléments du tableau.

#define NB_ELEM_MAXI 100

void raz(int *t, int taille)
{
int i;
for (i = 0; i < taille; i++)
t[i] = 0;
}

33
int main()
{
int tab[NB_ELEM_MAXI];
int i;
for (i = 0; i < NB_ELEM_MAXI; i++)
printf("tab[%d] = %d\n", i, tab[i]);
raz(tab, NB_ELEM_MAXI);
for (i = 0; i < NB_ELEM_MAXI; i++)
printf("tab[%d] = %d\n", i, tab[i]);
return 0;
}

22. Quel est l’ordre de priorité des différents opérateurs de l’expression suivante :
((3 * a) – x ^ 2) – (((c – d) / (a / b)) / d)

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

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

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

24. 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);
}

35
 25. Ecrivez 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.
Affichez le résultat.
#include <stdio.h>
#include <string.h>
main()
{
/* Déclarations */
char CH1[100], CH2[100]; /* chaînes données */
char CH3[100]=""; /* chaîne résultat */
/* Saisie des données */
printf("Introduisez la première chaîne de caractères : ");
gets(CH1);
printf("Introduisez la deuxième chaîne de caractères : ");
gets(CH2);
/* Traitements */
strncpy(CH3, CH1, strlen(CH1)/2);
strncat(CH3, CH2, strlen(CH2)/2);
/* Affichage du résultat */
printf("Un demi \"%s\" plus un demi \"%s\" donne \"%s\"\n",
CH1, CH2,
CH3);
return (0);
}

26. Écrivez une fonction qui prend en paramètre un tableau d’entiers et calcule le maximum de
tous les éléments du tableau.
#define NB_ELEM_MAXI 100
int max(int t[NB_ELEM_MAXI])
{
int i;
int max = t[0];
for (i = 1; i < NB_ELEM_MAXI; i++)
{
if (max < t[i])
max = t[i];
}
return max;
}
27. Écrivez une fonction qui prend en paramètre un tableau d’entiers et calcule la somme des
éléments.
#define NB_ELEM_MAXI 100
int somme(int t[NB_ELEM_MAXI])
{
int i;
int somme = t[0];
for (i = 1; i < NB_ELEM_MAXI; i++)
somme += t[i];

36
return somme;
}
28. A) Écrivez un programme qui saisit deux variables de type int, qui échange leur
contenu et qui affiche les nouvelles valeurs des variables.
B) On se propose de refaire la question a) en réalisant l’échange de valeurs à l’inté-
rieur d’une fonction. Écrire une fonction qui échange le contenu de deux variables passées
par adresse. Écrire le programme principal qui saisit deux variables, les échange en appelant
la fonction et affiche le nouveau contenu des variables.
a)
int main()
{
int a = 14, b = 5;
int t;
printf("a = %d; b = %d\n", a, b);
t = a;
a = b;
b = t;
printf("a = %d; b = %d\n", a, b);
return 0;
}
b)
void echange(int *a, int *b)
{
int t;
t = *a;
*a = *b;
*b = t;
}
int main()
{
int a = 14, b = 5;
printf("a = %d; b = %d\n", a, b);
echange(&a, &b);
printf("a = %d; b = %d\n", a, b);
return 0;
}

37