Corrigé des Exercices de Programmation en C

Série N°1 et Série N°2

Université Sultan Moulay Slimane
École Supérieure de Technologie, Béni Mellal

Année universitaire : 2024/2025

Série N°1 Langage C

Exercice 1 : Afficher un nombre en hexadécimal
Énoncé : Écrire un programme en langage C qui demande à l’utilisateur un nombre
entier n et l’affiche en format hexadécimal.
Solution :
1 /* Programme pour convertir un nombre entier en h e x a d c i m a l */
2 # include < stdio .h >
3

4 int main () {
5 int n ;
6 printf ( " Entrez un nombre entier : " ) ;
7 scanf ( " % d " , & n ) ; // Lecture du nombre entier
8 printf ( " Le nombre % d en h e x a d c i m a l est : 0 x % X \ n " , n , n ) ;
// Affichage en h e x a d c i m a l
9 return 0;
10 }

Explication :
— On inclut la bibliothèque stdio.h pour utiliser printf et scanf.
— On déclare une variable n de type int pour stocker le nombre saisi.
— scanf lit l’entrée utilisateur et printf affiche le nombre en hexadécimal avec le
format %X.
— Le 0x est ajouté pour indiquer que le nombre est en hexadécimal.

Exercice 2 : Permutation de trois nombres

Énoncé : Donner un programme en langage C qui lit deux entiers entrés au clavier et
fait leur permutation. Puis qui lit trois entiers a, b et c et fait leur permutation circulaire
et affiche les nombres permutés.

1
 Solution :
1 /* Programme pour permuter deux et trois nombres */
2 # include < stdio .h >
3

4 int main () {
5 int a , b , c , temp ;
6

7 // Permutation de deux nombres

8 printf ( " Entrez deux entiers a et b : " ) ;
9 scanf ( " % d % d " , &a , & b ) ;
10 printf ( " Avant permutation : a = %d , b = % d \ n " , a , b ) ;
11 temp = a ; // Sauvegarde de a
12 a = b; // a prend la valeur de b
13 b = temp ; // b prend l ’ ancienne valeur de a
14 printf ( " A p r s permutation : a = %d , b = % d \ n " , a , b ) ;
15

16 // Permutation circulaire de trois nombres

17 printf ( " Entrez trois entiers a , b et c : " ) ;
18 scanf ( " % d % d % d " , &a , &b , & c ) ;
19 printf ( " Avant permutation : a = %d , b = %d , c = % d \ n " , a , b ,
c);
20 temp = a ; // Sauvegarde de a
21 a = b; // a prend la valeur de b
22 b = c; // b prend la valeur de c
23 c = temp ; // c prend l ’ ancienne valeur de a
24 printf ( " A p r s permutation circulaire : a = %d , b = %d , c =
%d\n", a, b, c);
25

26 return 0;
27 }

Explication :
— Pour permuter deux nombres, on utilise une variable temporaire temp pour sau-
vegarder une valeur avant de l’écraser.
— Pour la permutation circulaire de trois nombres (a → b, b → c, c → a), on utilise
aussi une variable temporaire.
— Les printf affichent les valeurs avant et après permutation pour vérifier le résultat.

Exercice 3 : Trier trois nombres

Énoncé : Écrire un programme en langage C qui lit trois nombres différents x, y et
z quels qu’ils soient, et trie ces nombres dans l’ordre croissant.
Solution :
1 /* Programme pour trier trois nombres dans l ’ ordre croissant */
2 # include < stdio .h >
3

4 int main () {
5 int x , y , z , temp ;
6 printf ( " Entrez trois nombres x , y et z : " ) ;

2
 7 scanf ( " % d % d % d " , &x , &y , & z ) ;
8

9 // Tri par comparaison et permutation

10 if ( x > y ) { // Si x > y , on permute
11 temp = x ;
12 x = y;
13 y = temp ;
14 }
15 if ( y > z ) { // Si y > z , on permute
16 temp = y ;
17 y = z;
18 z = temp ;
19 }
20 if ( x > y ) { // On v r i f i e nouveau x et y a p r s la
permutation p r c d e n t e
21 temp = x ;
22 x = y;
23 y = temp ;
24 }
25

26 printf ( " Les nombres t r i s dans l ’ ordre croissant : %d , %d ,

%d\n", x, y, z);
27 return 0;
28 }

Explication :
— On utilise une méthode de tri par comparaison et permutation (semblable au tri
à bulles pour trois nombres).
— On compare d’abord x et y, puis y et z, et enfin x et y à nouveau pour s’assurer
que les nombres sont bien triés.
— À la fin, x ≤ y ≤ z.

Exercice 4 : Résolution d’une équation du second degré

Énoncé : Écrire un programme en langage C qui résout une équation de second degré
de la forme ax2 + bx + c = 0. Il demande à l’utilisateur les coefficients a, b et c et donne
les solutions possibles.
Solution :
1 /* Programme pour r s o u d r e une quation du second d e g r */
2 # include < stdio .h >
3 # include < math .h >
4

5 int main () {
6 float a , b , c , delta , x1 , x2 ;
7

8 printf ( " Entrez les coefficients a , b et c de l ’ quation

ax ^2 + bx + c = 0 : " ) ;
9 scanf ( " % f % f % f " , &a , &b , & c ) ;
10

3
11 if ( a == 0) { // Cas o ce n ’ est pas une quation du
second d e g r
12 if ( b == 0) {
13 if ( c == 0) {
14 printf ( " quation i n d t e r m i n e ( toute solution
est possible ) \ n " ) ;
15 } else {
16 printf ( " Pas de solution \ n " ) ;
17 }
18 } else {
19 printf ( " quation du premier d e g r , solution : x =
% f \ n " , -c / b ) ;
20 }
21 } else {
22 delta = b * b - 4 * a * c ; // Calcul du discriminant
23 if ( delta > 0) { // Deux solutions r e l l e s distinctes
24 x1 = ( - b + sqrt ( delta ) ) / (2 * a ) ;
25 x2 = ( - b - sqrt ( delta ) ) / (2 * a ) ;
26 printf ( " Deux solutions r e l l e s : x1 = %f , x2 =
% f \ n " , x1 , x2 ) ;
27 } else if ( delta == 0) { // Une solution double
28 x1 = -b / (2 * a ) ;
29 printf ( " Une solution double : x = % f \ n " , x1 ) ;
30 } else { // Pas de solution r e l l e
31 printf ( " Pas de solution r e l l e \ n " ) ;
32 }
33 }
34

35 return 0;
36 }

Explication :
— On inclut math.h pour utiliser sqrt (racine carrée).
— On calcule le discriminant ∆ = b2 − 4ac.
— Si a = 0, ce n’est pas une équation du second degré, on traite les cas particuliers.
— Sinon, selon la valeur de ∆, on détermine le nombre de solutions :
— ∆ > 0 : deux solutions réelles distinctes.
— ∆ = 0 : une solution double.
— ∆ < 0 : pas de solution réelle.

Exercice 5 : Calcul d’une somme

Énoncé : Écrire un programme en langage C qui demande à l’utilisateur un nombre
entier n et calcule et affiche la somme suivante : S = 1 + 22 + 32 + 42 + . . . + n2 .
Solution :
1 /* Programme pour calculer la somme des c a r r s de 1 n */
2 # include < stdio .h >
3

4 int main () {
5 int n , i ;

4
 6 long long somme = 0; // Utilisation de long long pour
viter un d p a s s e m e n t
7

8 printf ( " Entrez un nombre entier n : " ) ;

9 scanf ( " % d " , & n ) ;
10

11 for ( i = 1; i <= n ; i ++) {

12 somme += i * i ; // Ajout de i ^2 la somme
13 }
14

15 printf ( " La somme des c a r r s de 1 % d est : % lld \ n " , n ,

somme ) ;
16 return 0;
17 }

Explication :
— On utilise une boucle for pour parcourir les nombres de 1 à n.
— À chaque itération, on ajoute i2 à la somme.
— On utilise long long pour la somme afin d’éviter un dépassement si n est grand.

Exercice 6 : Saisie et affichage d’un caractère en ASCII

Énoncé : Écrire un programme en C qui demande à l’utilisateur de saisir un caractère
au clavier puis affiche son code ASCII.
Solution :
1 /* Programme pour afficher le code ASCII d ’ un c a r a c t r e */
2 # include < stdio .h >
3

4 int main () {
5 char c ;
6 printf ( " Entrez un c a r a c t r e : " ) ;
7 scanf ( " % c " , & c ) ; // Espace avant % c pour ignorer les
espaces ou retours la ligne
8 printf ( " Le code ASCII de ’% c ’ est : % d \ n " , c , c ) ; //
Affichage du code ASCII
9 return 0;
10 }

Explication :
— On déclare une variable c de type char pour stocker le caractère.
— On utilise scanf pour lire le caractère et printf pour afficher son code ASCII.
— En C, un char est stocké comme un entier (son code ASCII), donc on peut l’afficher
directement avec %d.

Exercice 7 : Saisie et affichage d’un caractère en majuscule

Énoncé : Écrivez un programme en C qui saisit un caractère minuscule et qui l’affiche
en majuscule.
Solution :

5
 1 /* Programme pour convertir un c a r a c t r e minuscule en majuscule
*/
2 # include < stdio .h >
3

4 int main () {
5 char c ;
6 printf ( " Entrez un c a r a c t r e minuscule : " ) ;
7 scanf ( " % c " , & c ) ;
8

9 if ( c >= ’a ’ && c <= ’z ’) { // V r i f i c a t i o n si c ’ est une

lettre minuscule
10 c = c - 32; // Conversion en majuscule ( d i f f r e n c e
ASCII entre minuscules et majuscules )
11 printf ( " Le c a r a c t r e en majuscule est : % c \ n " , c ) ;
12 } else {
13 printf ( " Le c a r a c t r e saisi n ’ est pas une lettre
minuscule .\ n " ) ;
14 }
15

16 return 0;
17 }

Explication :
— On vérifie si le caractère saisi est une lettre minuscule (entre ’a’ et ’z’).
— La différence entre une lettre minuscule et sa majuscule dans la table ASCII est
de 32 (par exemple, ’a’ = 97, ’A’ = 65).
— On soustrait 32 pour convertir en majuscule.
— Si le caractère n’est pas une lettre minuscule, on affiche un message d’erreur.

Exercice 8 : Calculatrice simple

Énoncé : Écrire un programme en C réalisant une calculatrice en demandant à l’uti-
lisateur de saisir deux valeurs a et b, de type int, séparées par un opérateur op de type
char, en vérifiant qu’il s’agit de l’une des valeurs suivantes : +, -, *, /. Puis affiche le
résultat de l’opération : aopb.
Solution :
1 /* Programme pour une calculatrice simple */
2 # include < stdio .h >
3

4 int main () {
5 int a , b ;
6 char op ;
7

8 printf ( " Entrez deux nombres entiers a et b , suivis d ’ un

o p r a t e u r (+ , -, * , /) : " ) ;
9 scanf ( " % d % d % c " , &a , &b , & op ) ;
10

11 switch ( op ) {
12 case ’+ ’:
13 printf ( " % d + % d = % d \ n " , a , b , a + b ) ;

6
14 break ;
15 case ’ - ’:
16 printf ( " % d - % d = % d \ n " , a , b , a - b ) ;
17 break ;
18 case ’* ’:
19 printf ( " % d * % d = % d \ n " , a , b , a * b ) ;
20 break ;
21 case ’/ ’:
22 if ( b != 0) {
23 printf ( " % d / % d = % d \ n " , a , b , a / b ) ;
24 } else {
25 printf ( " Erreur : Division par z r o !\ n " ) ;
26 }
27 break ;
28 default :
29 printf ( " O p r a t e u r invalide !\ n " ) ;
30 }
31

32 return 0;
33 }

Explication :
— On lit deux entiers a et b et un opérateur op.
— On utilise une structure switch pour gérer les différents opérateurs.
— Pour la division, on vérifie que b n’est pas zéro pour éviter une erreur.
— Si l’opérateur n’est pas valide, on affiche un message d’erreur.

Exercice 9 : Vérification des parenthèses

Énoncé : Écrire un programme saisissant une expression arithmétique avec pa-
renthèses, de parenthèses. Dire à l’utilisateur si l’expression ne contient pas de faute
de parenthèses.
Solution :
1 /* Programme pour v r i f i e r les p a r e n t h s e s dans une expression
*/
2 # include < stdio .h >
3 # include < string .h >
4

5 int main () {
6 char expression [100];
7 int i , count = 0;
8

9 printf ( " Entrez une expression a r i t h m t i q u e : " ) ;

10 scanf ( " % s " , expression ) ;
11

12 for ( i = 0; i < strlen ( expression ) ; i ++) {

13 if ( expression [ i ] == ’( ’) {
14 count ++; // I n c r m e n t a t i o n pour une p a r e n t h s e
ouvrante
15 } else if ( expression [ i ] == ’) ’) {

7
16 count - -; // D c r m e n t a t i o n pour une p a r e n t h s e
fermante
17 }
18 if ( count < 0) { // Si on a une p a r e n t h s e fermante
avant une ouvrante
19 break ;
20 }
21 }
22

23 if ( count == 0) {
24 printf ( " L ’ expression est correcte ( p a r e n t h s e s bien
f o r m e s ) .\ n " ) ;
25 } else {
26 printf ( " L ’ expression contient une erreur de
p a r e n t h s e s .\ n " ) ;
27 }
28

29 return 0;
30 }

Explication :
— On lit une chaı̂ne de caractères représentant l’expression.
— On utilise un compteur count pour suivre le nombre de parenthèses ouvrantes non
fermées.
— Si count devient négatif, cela signifie qu’on a une parenthèse fermante avant une
ouvrante, donc une erreur.
— À la fin, si count est 0, les parenthèses sont bien formées.

Série N°2 Langage C

Exercice 1 : Plus grand et plus petit élément d’un tableau
Énoncé : Écrire un programme en C qui introduit dix nombres entiers dans un
tableau. Chercher le plus grand élément et sa position ensuite le plus petit élément et sa
position, de ce tableau.
Solution :
1 /* Programme pour trouver le plus grand et le plus petit
lment d ’ un tableau */
2 # include < stdio .h >
3

4 int main () {
5 int tableau [10] , i ;
6 int max , min , pos_max , pos_min ;
7

8 // Saisie des lments du tableau

9 printf ( " Entrez 10 nombres entiers :\ n " ) ;
10 for ( i = 0; i < 10; i ++) {
11 printf ( " lment % d : " , i + 1) ;
12 scanf ( " % d " , & tableau [ i ]) ;
13 }

8
14

15 // Initialisation avec le premier lment

16 max = tableau [0];
17 min = tableau [0];
18 pos_max = 0;
19 pos_min = 0;
20

21 // Recherche du maximum et du minimum

22 for ( i = 1; i < 10; i ++) {
23 if ( tableau [ i ] > max ) {
24 max = tableau [ i ];
25 pos_max = i ;
26 }
27 if ( tableau [ i ] < min ) {
28 min = tableau [ i ];
29 pos_min = i ;
30 }
31 }
32

33 printf ( " Le plus grand lment est % d la position % d \ n " ,

max , pos_max ) ;
34 printf ( " Le plus petit lment est % d la position % d \ n " ,
min , pos_min ) ;
35

36 return 0;
37 }

Explication :
— On déclare un tableau de 10 entiers et on le remplit avec les valeurs saisies par
l’utilisateur.
— On initialise max et min avec le premier élément du tableau.
— On parcourt le tableau pour trouver le maximum et le minimum, en mettant à
jour leurs positions.
— On affiche les résultats.

Exercice 2 : Tri d’un tableau dans l’ordre inverse

Énoncé : Écrire 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. Ranger ensuite les éléments du tableau T dans l’ordre inverse
sans utiliser de tableau d’aide. Afficher le tableau résultant.
Solution :
1 /* Programme pour trier un tableau dans l ’ ordre inverse */
2 # include < stdio .h >
3

4 int main () {
5 int T [50] , N , i , temp ;
6

7 // Saisie de la dimension
8 printf ( " Entrez la dimension du tableau ( max 50) : " ) ;

9
 9 scanf ( " % d " , & N ) ;
10 if ( N > 50 || N <= 0) {
11 printf ( " Dimension invalide !\ n " ) ;
12 return 1;
13 }
14

15 // Saisie des lments

16 printf ( " Entrez les % d lments du tableau :\ n " , N ) ;
17 for ( i = 0; i < N ; i ++) {
18 printf ( " lment % d : " , i + 1) ;
19 scanf ( " % d " , & T [ i ]) ;
20 }
21

22 // Affichage du tableau initial

23 printf ( " Tableau initial : " ) ;
24 for ( i = 0; i < N ; i ++) {
25 printf ( " % d " , T [ i ]) ;
26 }
27 printf ( " \ n " ) ;
28

29 // Inversion du tableau
30 for ( i = 0; i < N / 2; i ++) {
31 temp = T [ i ];
32 T [ i ] = T [ N - 1 - i ];
33 T [ N - 1 - i ] = temp ;
34 }
35

36 // Affichage du tableau i n v e r s
37 printf ( " Tableau i n v e r s : " ) ;
38 for ( i = 0; i < N ; i ++) {
39 printf ( " % d " , T [ i ]) ;
40 }
41 printf ( " \ n " ) ;
42

43 return 0;
44 }

Explication :
— On lit la dimension N et on vérifie qu’elle est valide.
— On remplit le tableau avec les valeurs saisies.
— Pour inverser le tableau, on parcourt la moitié du tableau et on permute les
éléments symétriques (T[i] avec T[N-1-i]).
— On affiche le tableau avant et après l’inversion.

Exercice 3 : Somme des éléments d’un tableau 2D

Énoncé : Écrire 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.
Solution :

10
 1 /* Programme pour calculer la somme des lments d ’ un tableau
2 D */
2 # include < stdio .h >
3

4 int main () {
5 int T [50][50] , L , C , i , j ;
6 long long somme = 0; // Utilisation de long long pour
viter un d p a s s e m e n t
7

8 // Saisie des dimensions

9 printf ( " Entrez le nombre de lignes ( max 50) : " ) ;
10 scanf ( " % d " , & L ) ;
11 printf ( " Entrez le nombre de colonnes ( max 50) : " ) ;
12 scanf ( " % d " , & C ) ;
13 if ( L > 50 || C > 50 || L <= 0 || C <= 0) {
14 printf ( " Dimensions invalides !\ n " ) ;
15 return 1;
16 }
17

18 // Saisie des lments

19 printf ( " Entrez les lments du tableau :\ n " ) ;
20 for ( i = 0; i < L ; i ++) {
21 for ( j = 0; j < C ; j ++) {
22 printf ( " T [% d ][% d ] = " , i , j ) ;
23 scanf ( " % d " , & T [ i ][ j ]) ;
24 somme += T [ i ][ j ]; // Ajout la somme
25 }
26 }
27

28 // Affichage du tableau
29 printf ( " Tableau saisi :\ n " ) ;
30 for ( i = 0; i < L ; i ++) {
31 for ( j = 0; j < C ; j ++) {
32 printf ( " % d " , T [ i ][ j ]) ;
33 }
34 printf ( " \ n " ) ;
35 }
36

37 printf ( " La somme de tous les lments est : % lld \ n " ,

somme ) ;
38 return 0;
39 }

Explication :
— On lit les dimensions L et C et on vérifie qu’elles sont valides.
— On remplit le tableau 2D avec les valeurs saisies, en ajoutant chaque élément à la
somme.
— On affiche le tableau et la somme totale.
— On utilise long long pour la somme afin d’éviter un dépassement.

11
 Exercice 4 : Zéro sur la diagonale principale
Énoncé : Écrire un programme qui met à zéro les éléments de la diagonale principale
d’une matrice carrée A donnée.
Solution :
1 /* Programme pour mettre z r o la diagonale principale d ’ une
matrice */
2 # include < stdio .h >
3

4 int main () {
5 int A [50][50] , N , i , j ;
6

7 // Saisie de la dimension
8 printf ( " Entrez la dimension de la matrice c a r r e ( max 50) :
");
9 scanf ( " % d " , & N ) ;
10 if ( N > 50 || N <= 0) {
11 printf ( " Dimension invalide !\ n " ) ;
12 return 1;
13 }
14

15 // Saisie des lments

16 printf ( " Entrez les lments de la matrice :\ n " ) ;
17 for ( i = 0; i < N ; i ++) {
18 for ( j = 0; j < N ; j ++) {
19 printf ( " A [% d ][% d ] = " , i , j ) ;
20 scanf ( " % d " , & A [ i ][ j ]) ;
21 }
22 }
23

24 // Affichage de la matrice initiale

25 printf ( " Matrice initiale :\ n " ) ;
26 for ( i = 0; i < N ; i ++) {
27 for ( j = 0; j < N ; j ++) {
28 printf ( " % d " , A [ i ][ j ]) ;
29 }
30 printf ( " \ n " ) ;
31 }
32

33 // Mise z r o de la diagonale principale

34 for ( i = 0; i < N ; i ++) {
35 A [ i ][ i ] = 0; // Les lments de la diagonale
principale sont ceux o i == j
36 }
37

38 // Affichage de la matrice m o d i f i e
39 printf ( " Matrice a p r s mise z r o de la diagonale
principale :\ n " ) ;
40 for ( i = 0; i < N ; i ++) {
41 for ( j = 0; j < N ; j ++) {
42 printf ( " % d " , A [ i ][ j ]) ;

12
43 }
44 printf ( " \ n " ) ;
45 }
46

47 return 0;
48 }

Explication :
— On lit la dimension N d’une matrice carrée et on remplit la matrice.
— La diagonale principale est constituée des éléments où l’indice de ligne est égal à
l’indice de colonne (A[i][i]).
— On met ces éléments à zéro et on affiche la matrice avant et après modification.

Exercice 5 : Factoriel avec récursivité

Énoncé : Écrire un programme qui calcule le factoriel de n en utilisant une fonction
récursive.
Solution :
1 /* Programme pour calculer le factoriel avec une fonction
r c u r s i v e */
2 # include < stdio .h >
3

4 // Fonction r c u r s i v e pour calculer le factoriel

5 unsigned long long factoriel ( int n ) {
6 if ( n == 0 || n == 1) { // Cas de base
7 return 1;
8 }
9 return n * factoriel ( n - 1) ; // Appel r c u r s i f
10 }
11

12 int main () {
13 int n ;
14 printf ( " Entrez un nombre entier n pour calculer son
factoriel : " ) ;
15 scanf ( " % d " , & n ) ;
16

17 if ( n < 0) {
18 printf ( " Le factoriel n ’ est pas d f i n i pour les nombres
n g a t i f s .\ n " ) ;
19 } else {
20 printf ( " Le factoriel de % d est : % llu \ n " , n ,
factoriel ( n ) ) ;
21 }
22

23 return 0;
24 }

Explication :
— On définit une fonction récursive factoriel qui calcule n!.
— Le cas de base est n = 0 ou n = 1, où 0! = 1 et 1! = 1.
— Sinon, on utilise la formule n! = n × (n − 1)!.

13
 — On utilise unsigned long long pour gérer de grands nombres.
— On vérifie que n n’est pas négatif.

Exercice 6 : Calcul d’un terme d’une suite récursive

Énoncé : Écrire un programme qui calcule le terme n de la suite suivante en utilisant
une fonction récursive : S0 = 0, S1 = −9, Sn = Sn−1 − 9 × Sn−2 pour n > 1.
Solution :
1 /* Programme pour calculer un terme d ’ une suite r c u r s i v e */
2 # include < stdio .h >
3

4 // Fonction r c u r s i v e pour calculer Sn

5 long long calculer_S ( int n ) {
6 if ( n == 0) return 0; // Cas de base S0
7 if ( n == 1) return -9; // Cas de base S1
8 return calculer_S ( n - 1) - 9 * calculer_S ( n - 2) ; // Formule
r cursive
9 }
10

11 int main () {
12 int n ;
13 printf ( " Entrez l ’ indice n pour calculer Sn : " ) ;
14 scanf ( " % d " , & n ) ;
15

16 if ( n < 0) {
17 printf ( " L ’ indice doit tre positif ou nul .\ n " ) ;
18 } else {
19 printf ( " S % d = % lld \ n " , n , calculer_S ( n ) ) ;
20 }
21

22 return 0;
23 }

Explication :
— On définit une fonction récursive calculer S pour calculer Sn .
— Les cas de base sont S0 = 0 et S1 = −9.
— Pour n > 1, on utilise la formule Sn = Sn−1 − 9 × Sn−2 .
— On utilise long long pour gérer de grands nombres.
— On vérifie que n n’est pas négatif.

Exercice 7 : Structure avec char et int

Énoncé : Créez un type structure st contenant un char appelé c et un int appelé i.
Créez deux variables x et y contenant un char appelé c et les valeurs (’a’ ; 1) et (’b’ ; 2).
Affichez-les valeurs x et y de type st. Affichez-les valeurs de tous les champs de ces deux
variables.
Solution :
1 /* Programme pour utiliser une structure avec char et int */
2 # include < stdio .h >

14
 3

4 // D f i n i t i o n de la structure
5 struct st {
6 char c ;
7 int i ;
8 };
9

10 int main () {
11 // D c l a r a t i o n et initialisation des variables x et y
12 struct st x = { ’a ’ , 1};
13 struct st y = { ’b ’ , 2};
14

15 // Affichage des valeurs

16 printf ( " Valeurs de x : c = %c , i = % d \ n " , x .c , x . i ) ;
17 printf ( " Valeurs de y : c = %c , i = % d \ n " , y .c , y . i ) ;
18

19 return 0;
20 }

Explication :
— On définit une structure st avec un char c et un int i.
— On crée deux variables x et y de type st et on les initialise.
— On affiche les champs c et i de chaque variable.

Exercice 8 : Ajout d’éléments à la fin d’un tableau

Énoncé : Écrire un programme qui lit deux tableaux d’entiers A et B et leurs di-
mensions N et M au clavier et qui ajoute les éléments de B à la fin de A. Utiliser deux
pointeurs P A et P B pour le transfert et afficher le tableau résultant A.
Solution :
1 /* Programme pour ajouter les lments de B la fin de A */
2 # include < stdio .h >
3

4 int main () {
5 int A [100] , B [50] , N , M , i ;
6 int * PA , * PB ;
7

8 // Saisie des dimensions

9 printf ( " Entrez la dimension de A ( max 50) : " ) ;
10 scanf ( " % d " , & N ) ;
11 printf ( " Entrez la dimension de B ( max 50) : " ) ;
12 scanf ( " % d " , & M ) ;
13 if ( N + M > 100 || N <= 0 || M <= 0) {
14 printf ( " Dimensions invalides !\ n " ) ;
15 return 1;
16 }
17

18 // Saisie des lments de A

19 printf ( " Entrez les % d lments de A :\ n " , N ) ;
20 for ( i = 0; i < N ; i ++) {
21 printf ( " A [% d ] = " , i ) ;

15
22 scanf ( " % d " , & A [ i ]) ;
23 }
24

25 // Saisie des lments de B

26 printf ( " Entrez les % d lments de B :\ n " , M ) ;
27 for ( i = 0; i < M ; i ++) {
28 printf ( " B [% d ] = " , i ) ;
29 scanf ( " % d " , & B [ i ]) ;
30 }
31

32 // Utilisation des pointeurs pour ajouter B la fin de A

33 PA = A + N ; // Pointeur PA pointe vers la fin de A
34 PB = B ; // Pointeur PB pointe vers le d b u t de B
35 for ( i = 0; i < M ; i ++) {
36 * PA = * PB ; // Copie de l ’ lment de B dans A
37 PA ++; // Avance le pointeur PA
38 PB ++; // Avance le pointeur PB
39 }
40

41 // Affichage du tableau A r s u l t a n t
42 printf ( " Tableau A a p r s ajout de B : " ) ;
43 for ( i = 0; i < N + M ; i ++) {
44 printf ( " % d " , A [ i ]) ;
45 }
46 printf ( " \ n " ) ;
47

48 return 0;
49 }

Explication :
— On lit les dimensions N et M et on remplit les tableaux A et B.
— On utilise deux pointeurs PA et PB :
— PA pointe vers la fin de A (position N ).
— PB pointe vers le début de B.
— On copie les éléments de B à la fin de A en incrémentant les pointeurs.
— On affiche le tableau A résultant, qui contient maintenant N + M éléments.

16