1. Ecrire un programme qui permute deux valeurs entières. Ces valeurs sont connues lors de la déclaration.

Même
question pour trois valeurs flottantes et caractères.
2. Déclarez 8 variables de type différents (selon votre choix), avec ces variables effectuez les opérations suivantes:
a. Opérateurs arithmétiques : +, -, *, /, %
b. Opérateurs relationnels : ==, !=, <=, >=
c. Opérateurs logiques : &&, ||, !
d. Opérateurs bit-à-bit : &, ˆ , ~ ,<<, >>
e. Affectation composée : +=, -=, *=, /=, %=, &=, ^=, |=, <<=,>>=
f. Incrément et décrément : x++, ++x, x--, --x
3. Observer l’effet de la conversion de type entre des valeurs int et unsigned int, en particulier dans le cas de
valeurs négatives. Utiliser la fonction sizeof ainsi que les formats d’affichage d, u, ld, lu, x, lx (précédés du
caractère %). Même question avec les types long et unsigned long.
4. Quelles sont les valeurs des expressions (float)i/j, (float)(i/j) et (float)i/(float)j pour int i, j; ? Donner une
réponse puis vérifier pour i=1 et j=4.
5. Utiliser l’opérateur de décallage avec des variables au format m_i = 2i, pour i = 0; … ; 5.
6. Utiliser les variables de l'exercice 5 pour réaliser les traitements suivants sur des valeurs de votre choix
a. déterminer la parité de la valeur entrée (proposer 2 solutions) ;
b. déterminer si le bit de position 3 est égal à 0 ;
c. déterminer si l’octet de poids faible est égal à 7 ;
d. mettre à 1 le bit de position 0 ;
e. mettre à 1 les bits de position 1 et 4 ;
f. mettre à 0 les bits de position 1 et 2 ;
g. afficher l’octet de poids faible ;
7. Ecrivez un programme qui affiche la taille des différents types de données en octet du langage C
8. Afficher les limites Max et Min des entiers et des réels ( Pour les limites lies aux entiers et char #include
<limits.h> / et pour les limites lies aux nombres réels #include <float.h>)
9. Qu'affiche ce pseudo_code:
a. int i=10; i = i-(i--);
b. int i=10;i = i-(--i);
10. Enlever les parenthèses des expressions suivantes lorsqu'elles peuvent être retirées.
a. a=(25*12)+b;
b. c= ((a>4) &&(b==18));
c. d=((a>=6)&&(b<18))||(c!=18)
d. e=(a=(b+10));
11. Quaffiche ce programme
#include <stdio.h>
int main()
{
// a = 5(00000101), b = 9(00001001)
unsigned char a = 5, b = 9;
printf("a = %d, b = %d\n", a, b);
printf("a&b = %d\n", a & b);
printf("a|b = %d\n", a | b);
printf("a^b = %d\n", a ^ b);
printf("~a = %d\n", a = ~a);
printf("b<<1 = %d\n", b << 1);
printf("b>>1 = %d\n", b >> 1);
return 0;
}
12. Déclarez deux entiers a=124 et i=4, donner le ième bit de a
13. Effectuez les différentes opérations de bit pour deux entiers a=16 et b=84
Exercice 5.1
Ecrire un programme qui demande à l’utilisateur un nombre compris entre 1 et 3 jusqu’à ce que la
réponse convienne.

Exercice 5.2
Ecrire un programme qui demande un nombre compris entre 10 et 20, jusqu’à ce que la réponse
convienne. En cas de réponse supérieure à 20, on fera apparaître un message : « Plus petit ! », et
inversement, « Plus grand ! » si le nombre est inférieur à 10.

Exercice 5.3
Ecrire un programme qui demande un nombre de départ, et qui ensuite affiche les dix nombres
suivants. Par exemple, si l'utilisateur entre le nombre 17, le programme affichera les nombres de 18 à
27.

Exercice 5.4
Réécrire le programme précédent, en utilisant cette fois l'instruction for

Exercice 5.5
Ecrire un programme qui demande un nombre de départ, et qui ensuite écrit la table de multiplication
de ce nombre, présentée comme suit (cas où l'utilisateur entre le nombre 7) :
Table de 7 :
7x1=7
7 x 2 = 14
7 x 3 = 21
…
7 x 10 = 70

Exercice 5.6
Ecrire un programme qui demande un nombre de départ, et qui calcule la somme des entiers jusqu’à ce
nombre. Par exemple, si l’on entre 5, le programme doit calculer :
1 + 2 + 3 + 4 + 5 = 15
NB : on souhaite afficher uniquement le résultat, pas la décomposition du calcul.

Exercice 5.7
Ecrire un programme qui demande un nombre de départ, et qui calcule son factorielle.
NB : la factorielle de 8, notée 8 !, vaut
1x2x3x4x5x6x7x8

Exercice 5.8
Ecrire un programme qui demande successivement 20 nombres à l’utilisateur, et qui lui dise ensuite
quel était le plus grand parmi ces 20 nombres :
Entrez le nombre numéro 1 : 12
Entrez le nombre numéro 2 : 14
etc.
Entrez le nombre numéro 20 : 6
Le plus grand de ces nombres est : 14
Modifiez ensuite l’programme pour que le programme affiche de surcroît en quelle position avait été
saisie ce nombre :
C’était le nombre numéro 2
Exercice 5.9
Réécrire le programme précédent, mais cette fois-ci on ne connaît pas d’avance combien l’utilisateur
souhaite saisir de nombres. La saisie des nombres s’arrête lorsque l’utilisateur entre un zéro.

Exercice 5.10
Lire la suite des prix (en Dh entiers et terminée par zéro) des achats d’un client. Calculer la somme
qu’il doit, lire la somme qu’il paye, et simuler la remise de la monnaie en affichant les textes "10 Dh",
"5 Dh" et "1 Dh" autant de fois qu’il y a de coupures de chaque sorte à rendre.

Exercice 5.11
Écrire un programme qui permette de connaître ses chances de gagner au tiercé, quarté, quinté et
autres impôts volontaires.
On demande à l’utilisateur le nombre de chevaux partants, et le nombre de chevaux joués. Les deux
messages affichés devront être :
Dans l’ordre : une chance sur X de gagner
Dans le désordre : une chance sur Y de gagner
X et Y nous sont donnés par la formule suivante, si n est le nombre de chevaux partants et p le nombre
de chevaux joués (on rappelle que le signe ! signifie "factorielle", comme dans l'exercice 5.6 ci-dessus)
:
X = n ! / (n - p) !
Y = n ! / (p ! * (n – p) !)
NB : cet programme peut être écrit d’une manière simple, mais relativement peu performante. Ses
performances peuvent être singulièrement augmentées par une petite astuce. Vous commencerez par
écrire la manière la plus simple, puis vous identifierez le problème, et écrirez une deuxième version
permettant de le résoudre.

Exercice 5.12
Pour 'N' saisi au clavier, afficher les N premiers nombres impairs positifs. Vous écrirez un
programme utilisant une boucle définie ("for"), et également deux versions traitant le même
problème utilisant respectivement une boucle "while" et "do ... while".

Exercice 5.13
Écrire un programme qui calcule A * B sans effectuer de multiplication.

Exercice 5.14
Écrire un programme qui calcule A / B sans effectuer de division

Exercice 5.15
Écrire un programme qui compte le nombre de valeurs divisibles par 7 parmi les valeurs comprises
entre 2 entiers M et N. M et N seront saisis au clavier.

Exercice 5.16
Écrire un programme qui affiche le nombre de digits à '1' d'un nombre entier (Base 10) lorsqu'il est
représenté sous son format binaire (Base 2).

Exercice 5.17
Écrire un programme qui ache un nombre entier (Base 10) sous son format binaire (Base 2).

Exercice 5.18
Les nombres de Fibonacci sont caractérisés par la série suivante :
Fib(0) = 0
Fib(1) = 1
Fib(n) = Fib(n-1) + Fib(n-2)
Écrire un programme qui calcule et affiche le Nième terme de cette suite. N sera saisi au clavier.
Exercice 5.19
On souhaite calculer le PGCD de 2 nombres entiers suivant la méthode d'Euclide.
si a > b alors pgcd(a; b) = pgcd(a-b; a)
pgcd(a; b) = a si a = b
Exemple pour 35 et 14 :
35 - 14 = 21 (on mémorise 21 et 14)
21 - 14 = 7 (on mémorise 14 et 7)
14 - 7 = 7 (on mémorise 7 et 7)
7 - 7 = 0 (on mémorise 7 et 0)
le PGCD est alors 7
Ecrire un programme réalisant ce calcul.

Exercice 5.20
Écrire un programme qui permet de saisir au clavier des notes, calculer et afficher leur somme ainsi
que leur moyenne. Les notes sont fournies au clavier avec un dialogue du type :
note 1 : 12
note 2 : 15.25
note 3 : 13.5
note 4 : 8.75
note 5 : -1
Le nombre de notes n'est pas connu à priori et l'utilisateur peut en fournir autant qu'il le souhaite.
Pour signaler qu'il a terminé, on convient qu'il fournira une note négative =-1.

Exercice 5.21
On suppose qu'il existe une fonction Alea() qui renvoie un nombre compris entre 0 et 1 (inclus).
Écrire un programme qui permet à l'utilisateur de deviner un nombre choisi au hasard compris entre
100 et 2000.

Exercice 5.22
 peut être calculé à l'aide de la série suivante : 

Écrire un programme qui prend en paramètre le rang de calcul pour l'approximation et qui retourne
la valeur approchée au rang n de π

Exercice 5.23
Écrire un programme permettant de calculer la somme des n premiers termes de la série harmonique,
i.e. la somme 1+1/2+1/ 3+1/4+1/5+…….+1/n

Exercice 5.24
Calculez la valeur du nombre e en considérant :

Exercice 5.25
Écrire un programme qui, à partir d'un nombre entier strictement positif, affichera « VRAI » ou
« FAUX » selon que le nombre est premier ou non. Pour mémoire, les nombres premiers inférieurs à
100 sont : 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97.

Exercice 5.26
Écrire un programme qui calcule le zéro d'une fonction f(x) sur l'intervalle [a; b], avec une précision .
La fonction f et les réels a; b et  sont donnés. Soit f(x) une fonction continue sur l'intervalle [a; b], où
elle ne s'annule qu'une seule et unique fois. Pour trouver ce zéro, on procède par dichotomie, c'est-à-
dire que l'on divise l'intervalle de recherche en 2 à chaque étape. Soit m le milieu de [a; b]. Si f(m) et
f(a) sont de même signe, le zéro recherché est dans l'intervalle [m; b] et dans l'intervalle [a;m] sinon.

Exercice 5.27
Écrire un programme qui affiche la suite de tous les nombres parfaits inférieurs ou égaux à un nombre
donné (saisi !) noté n. Un nombre est dit parfait s'il est égal à la somme de tous ses diviseurs stricts.
Par exemple, 28 est parfait car 28=1+2+4+7+14. Pour information, la liste des nombres parfaits
inférieurs à 10000 est : 6, 28, 496, 8128.
Exercice 5.28
Quelle est la suite d’indices décrite par la boucle suivante ? Répondre puis vérifier en
codant pour différentes valeurs de MINet MAX.

#define MIN 2
#define MAX 18
...
for (i=MIN, j=MAX; i<j; i++, j /= 2) ...

Exercice 5.29
Ecrire les programmes qui produisent les affichages suivants.
1. Avec une boucle for.

(a) 1 2 3 4 5 (b) 1
2
3
4
5

2. Avec deux boucles for.

(a) 1 (b) 1 (c) 1

1 2 3 1 1
2 2 2
1 2 3 1 2 2 4
3 3 3
1 2 3 1 2 3 3 69
4 4 4
1 2 3 1 2 3 4 4 8 12 16

Exercice 5.30
Reprendre l’exercice précédent en utilisant des boucles whileà la place des boucles for.

Exercice 5.31
Ecrire un programme qui pour une valeur de i choisie au clavier, affiche
i fois la valeur i sur la i-ème ligne. Pour i = 5, on a par exemple l’affichage suivant.
1
22
333
4444
55555

Exercice 5.32
Les suites un = n- 5 et vn = -2n + 10 varient de façon opposée. Calculer à partir de quelle valeur de
n > 0, un ≥ vn. Faire de même avec un = 10n et vn = n + 100, puis un = 2n et vn = 100n (qu' elles ne
varient pas de façon opposée).

Exercice 5.33
Ecrire un programme qui résoud l’équation du premier degré ax + b = 0 pour a, b deux float
arbitraires saisis au clavier (format de lecture %f). On affichera l’ensemble (éventuellement vide)
 des solutions calculées. Même question avec l’équation du second degré ax2 + bx + c = 0, pour a, b, c
des float.

Exercice 5.34

La fonction rand() renvoit un entier (int) pseudo-aléatoire selon une distribution uniforme dans
l’intervalle [0; RAND_MAX]. Ecrire les traitements suivants en faisant varier à votre convenance le
nombre de valeurs générées N en utilisant un #define (N = 100; 1000; 10000). Commenter
les résultats observés.
1. Observer des ensembles de valeurs générées.
2. Calculer la répartition (en pourcentage) des valeurs inférieures et supérieures à RAND_MAX/2
(moitié inférieure / moitié supérieure).
3. Calculer la répartition (en pourcentage) des valeurs sur les intervalles séparés par RAND_MAX/4,
RAND_MAX/2 et 3*RAND_MAX/4.
4. Combien de tirages sont nécessaires pour générer 5 valeurs de plus dans la moitié inférieure que
dans la moitié supérieure.
5. Généraliser le traitement précédent pour expérimenter combien de tirages sont nécessaires pour
générer i valeurs de plus dans la moitié inférieure que dans la moitié supérieure avec i = 1; 2; … ; 10.
6. Il est classique de faire varier les valeurs générées à chaque exécution en initialisant la graine
du générateur par l’heure du système. Ceci est obtenu grâce à l’appel srand(time(NULL)) qui
utilise la fonction time de la librairie time.h Observer les effets sur les résultats des questions
précédentes

Exercice 5.35
Qu'affichent les programmes suivants:
a)
#include <stdio.h>
int main(){
char c=255,c1='a';
unsigned i=1;
int j=-4;
int k=0x43ff;
printf(" %d \n",printf("%s","test"));//
printf("%10s\n","test");
printf("%c\n",c1+5);
printf("%d\n",c+10);
printf("%u\n",i+j);
printf("%x\n",k);
return 0;
}
b)
include <stdio.h>
int main(){
int i;

for(i=0;i<20;i++) {
switch (i){
case 0: i+=5;
case 1: i+=2; //No break
case 5:i+=5;
default :i+=4;

}
 printf("%d\t",i);
}
c)
#include <stdio.h>
int main(){
unsigned char i=100;
while (i++ !=0);
printf("%d\n",i);

return 0;
}
d)
#include <stdio.h>
int main(){
int i=3;
if(i==3);i=0;
if(i==3)i++;
else i+=2;
printf("i=%d\n",i);

return 0;
}
e)
#include <stdio.h>
int main(){
int i=32;

for(;i;i>>=1) //i=i>>1 32=100000

printf("salam %d\n",i);

return 0;
}
f)
#include <stdio.h>
int main(){
int i=-5;
while(i<=5){
if(i>=0)
break;
else {i++;continue;}
printf("%d\t",i);
}
return 0;
}
g)
#include <stdio.h>
int main(){
int i=0;
for( printf("un \n");i<3 && printf("");i++){
printf("dedans\n");
}
return 0;
}
Exercice 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.
Exercice 2
Ecrire un programme qui lit la dimension N d'un tableau T du type int (dimension maximale: 50
composantes), remplit le tableau par des valeurs entrées au clavier et affiche le tableau.
Effacer ensuite toutes les occurrences de la valeur 0 dans le tableau T et tasser les éléments restants.
Afficher le tableau résultant.
Exercice 3
Ecrire un programme qui lit la dimension N d'un tableau T du type int (dimension maximale: 50
composantes), remplit le tableau par des valeurs entrées au clavier et affiche le tableau.
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.
Exercice 4
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.
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.
Exercice 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.

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

Exercice 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:

/ \
|abcd| / \
| e f g h | ==> | a b c d e f g h i j k l |
|ijkl| \ /
\ /
Exercice 8
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
\ / \ /
Exercice 9
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:

Exercice 10
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é.
Exercice 11
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.
Exercice 12
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.
Implémenter deux versions:
a) La recherche séquentielle
Comparer successivement les valeurs du tableau avec la valeur donnée.
b) La recherche dichotomique ('recherche binaire', 'binary search')
Condition: Le tableau A doit être trié
Comparer le nombre recherché à la valeur au milieu du tableau,
- s'il y a égalité ou si le tableau est épuisé, arrêter le traitement avec un message correspondant.
- si la valeur recherchée précède la valeur actuelle du tableau, continuer la recherche dans le demi-tableau
à gauche de la position actuelle.
- si la valeur recherchée suit la valeur actuelle du tableau, continuer la recherche dans le demi-tableau à
droite de la position actuelle.
Ecrire le programme pour le cas où le tableau A est trié par ordre croissant.
Question: Quel est l'avantage de la recherche dichotomique? Expliquer brièvement.
Exercice 13
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.

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

6 > #######
5 > ####### #######
4 > ####### ####### #######
3 > ####### ####### ####### #######
2 > ####### ####### ####### ####### #######
1 > ####### ####### ####### ####### #######
+-------+-------+-------+-------+-------+-------+-------+
I 0 - 9 I 10-19 I 20-29 I 30-39 I 40-49 I 50-59 I 60 I

Exercice 13B

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

Exercice 13C

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

Exercice 13D
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 |
|efgh| |bfj|
|ijkl| |cgk|
\ / |dhl|
\ /

Exercice 13E

Ecrire un programme qui réalise la multiplication d'une matrice A par un réel X.

Rappel:
/ \ / \
| a b c d | | X*a X*b X*c X*d |
X * | e f g h | = | X*e X*f X*g X*h |
| i j k l | | X*i X*j X*k X*l |
\ / \ /
a) Le résultat de la multiplication sera mémorisé dans une deuxième matrice A qui sera ensuite affichée.
b) Les éléments de la matrice A seront multipliés par X.

Exercice 13F

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' |
|ijkl| | 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.

Exercice 13G

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 |
|klm| \ / | 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.
Exercice 13H

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

Exercice 13I

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:
/ \ / \ / \ / \
|18340| |4589| |35677| |123|
| | |3893| |42289| |456|
|67270| |3493| |63297| |789|
\ / \ / \ / \ /
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
Exercice 21. (passage-param) Coder et observer attentivement les effets du programme suivant qui
illustre le passage de paramètre par valeur et le sens de l’identificateur d’un tableau.
#include <stdio.h>
#include <stdlib.h>
#define N 4
void modif_scal(int val)
{
val = 1;
printf("Dans modif_scal, val vaut %d \n", val);
}
void afficher(int tab[], int taille)
{
for (int i=0; i<taille; i++) printf("%d \n", tab[i]);
}
void modif_tab(int tab[], int taille)
{
for (int i=0; i<taille; i++) tab[i] = i;
printf("Dans modif_tab, tab vaut \n");
afficher(tab, taille);
}
int main(void)
{
int un_i_global = 5;
int un_tab[N] = {0}; // vaut 0 par défaut
printf("Dans main, i vaut %d \n", un_i_global);
modif_scal(un_i_global);
printf("Après l’appel à modif_scal, i vaut %d \n", un_i_global);
printf("------------\n");
printf("Dans main, tab vaut \n");
afficher(un_tab, N);
modif_tab(un_tab, N);
printf("Après l’appel à modif_tab, tab vaut \n");
afficher(un_tab, N);
return EXIT_SUCCESS;
}
Exercice 22. Cet exercice s’intéresse au traitement d’une ou plusieurs séries de notes stockées dans un
tableau.
1. On considère une série de NbNotes notes sur 20. Ici NbNotes = 10. Ecrire un programme Moy0
qui effectue les traitements suivants.
(a) Déclare et initialise le tableau Notes avec les valeurs : 13, 8, 10, 4, 2, 1, 7, 10, 8, 14. Faire un
affichage de contrôle.
(b) Calcule et affiche m la moyenne empirique (moyenne de l’échantillon) et l’écart type empirique
s de cette série de N notes (ni)i — s2 =
2. Ecrire un programme Moy1 qui effectue les traitements précédents dans des fonctions indépendantes
et qui sont appelées depuis un main. Ces fonctions effectueront donc les traitements suivants.
(a) Afficher un tableau de longueur passée en paramètre ;
(b) Calculer la moyenne (des valeurs) d’un tableau passé en paramètre ;
(c) Calculer l’écart type empirique (des valeurs) d’un tableau passé en paramètre.
3. On considère maintenant NbSeries séries de NbNotes notes sur 20. Ici, NbSeries = 5 et NbNotes
= 10. Ces 50 notes sont données dans le fichier notes.txt (clé usb en circulation). Ecrire un programme
Moy2 qui effectue les traitements suivants.
(a) Déclare et initialise le tableau Notes avec les valeurs du fichier notes.txt. Faire un affichage
de contrôle.
(b) Calcule les NbSeries moyennes empiriques mk (les moyennes empiriques de chaque série
de notes). Ces moyennes mk seront stockées dans un tableau ad-hoc que l’on affichera.
(c) Calcule et affiche la moyenne empirique m de l’ensemble des NbSeries_NbNotes notes.
4. A la manière de la question 2, écrire un programme Moy3 qui effectue les traitements précédents
Exercice 23
1. Lire au clavier les dimensions d1 et d2 de deux tableaux d’entiers T1 et T2,
2. Initialise T1 avec la suite des d1 premiers entiers impairs et T2 avec la suite des d2 premiers
entiers pairs,
3. Concatène T1 et T2 dans un tableau T,
4. Affiche T.
Exercice 24
Exercice 25
Écrire un programme position.c contenant une fonction principale main déterminant si un entier est
contenu dans un tableau statique par l'appel à une fonction position.
La fonction main :

 définira et initialisera le tableau d'entier

 récupèrera dans son tableau d'argument argv le nombre à chercher.
 appellera la fonction position.
 affichera l'indice de l'élément dans le tableau ou un message indiquant que le nombre n'a pas été
trouvé.
La fonction position :

 aura pour prototype : static int position(int t[], int taille, int x).
 donnera l'indice d'un élément x dans le tableau t, ou -1 si x n'est pas trouvé.
Exercice 26
A) 1
Écrire un programme qui demande à l'utilisateur de saisir 10 entiers stockés dans un tableau. Le
programme doit afficher le nombre d'entiers supérieurs ou égaux à 10.
Solution

#include<stdio.h>

const int N=10;

int main()
{
int t[10],i,nb=0;
for(i=0;i<N;i++)
{
printf("Tapez un entier \n ");
scanf("%d",&t[i]);
}
for(i=0;i<N;i++)
if(t[i]>=10)
nb++;
printf("Le nombre d'entiers valant 10 ou davantage est : %d\n",nb );
return 0;
}

A) 2
Ecrire un programme qui demande à l'utilisateur de saisir 10 entiers stockés dans un tableau ainsi qu'un
entier V. Le programme doit rechercher si V se trouve dans le tableau et afficher "V se trouve dans le
tableau" ou "V ne se trouve pas dans le tableau".
Solution

#include<stdio.h>
const int N=10;
int main()
{
int t[N],i,V;
int trouve;
for(i=0;i<N;i++){printf("Tapez un entier: ");scanf("%d",&t[i]);}
printf("Tapez la valeur de V\n : ") ;scanf("%d",&V);

trouve=0;
i=0;
while(!trouve && i<N)
if(t[i]==V)trouve=1; else i++;
if(trouve) printf("La valeur V se trouve dans le tableau\n");
else printf("La valeur V ne se trouve pas dans le tableau\n");
return 0;
}
EXERCICE 3
Ecrire un programme qui demande à l'utilisateur de saisir 10 entiers stockés dans un tableau. Le
programme doit ensuite afficher l'indice du plus grand élément.
Solution

#include<stdio.h>
const int N=10;
int main()
{
int t[N],i,indice;

for(i=0;i<N;i++){printf("Tapez un entier \n");scanf("%d",&t[i]);}

indice=0;
for(i=1;i<N;i++)
if(t[indice]<t[i])indice=i;

printf("L'indice du plus grand element est : %d \n ",indice);

return 0;

EXERCICE 4
Ecrire un programme qui demande à l'utilisateur de saisir 10 entiers stockés dans un tableau ainsi qu'un
entier V. Le programme doit rechercher si V se trouve dans le tableau et doit supprimer la première
occurrence de V en décalant d'une case vers la gauche les éléments suivants et en rajoutant un 0 à la fin
du tableau. Le programme doit ensuite afficher le tableau final.
Solution

#include<stdio.h>
# define N 10
int main()
{
int t[N],i,j,V;
int trouve;
for(i=0;i<N;i++){printf("Tapez un entier \n");scanf("%d",&t[i]);}
printf("Tapez la valeur de V : ") ;scanf("%d",&V);

trouve=0;
i=0;
while(!trouve && i<N)
if(t[i]==V)trouve=1; else i++;

if(trouve)
{
for(j=i;j<N-1;j++)t[j]=t[j+1];
t[N-1]=0;
}
for(i=0;i<N;i++)printf("%d\n",t[i]);

return 0;
}

A) 5
Ecrire un programme qui demande à l'utilisateur de saisir 10 entiers stockés dans un tableau ainsi qu'un
entier V et un entier i compris entre 0 et 9. Le programme doit décaler d'une case vers la droite tous les
éléments à partir de l'indice i (en supprimant le dernier élément du tableau) et doit mettre la valeur V dans
le tableau à l'indice i. Le programme doit ensuite afficher le tableau final.
Solution
#include<stdio.h>
const int N=10;

int main()
{
int t[N],i,indice,V;

for(i=0;i<N;i++){ printf("Tapez un entier\n ");scanf("%d",&t[i]);}

printf("Tapez un indice (de 0 à 9) \n ");scanf("%d",&indice);
printf("Tapez la valeur de V : \n ");scanf("%d",&V);

if(indice>=0 && indice<=N-1)

{
for(i=N-1;i>indice;i--)t[i]=t[i-1];
t[indice]=V;
}

for(i=0;i<N;i++)printf("%d\n",t[i]);

return 0;
}

A) 6
Ecrire un programme qui demande à l’utilisateur de taper 10 entiers qui seront stockés dans un tableau. Le
programme doit ensuite afficher soit "le tableau est croissant", soit "le tableau est décroissant", soit "le
tableau est constant", soit "le tableau est quelconque".
Solution

#include<stdio.h>
const int N=10;

int main()
{
int a[N],i;

int croissant=1,decroissant=1;

for(i=0;i<N;i++)
{
printf("Veuillez taper l'entier numero %d : ",i) ;scanf(%d",&a[i]);
}
for(i=0;i<N-1;i++)
{
if(a[i]>a[i+1])croissant=0;
if(a[i]<a[i+1])decroissant=0;
}

if(croissant && decroissant) printf("le tableau est constant\n");

if(croissant && !decroissant) printf("le tableau est croissant \n");
if(!croissant && decroissant) printf("le tableau est decroissant \n");
if(!croissant && !decroissant) printf("le tableau est quelconque");

return 0;
}

Solution 2:

//
#include<stdio.h>
int const SIZE = 10;

int main()
{
int i;
int table[SIZE];
int ordre = 1;

printf( "Entre 10 entiers: \n");

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

{
scanf("%d",&table[i]);
}

if(table[0] < table[SIZE-1])

{
for( i=0; i<SIZE-1; i++)
{
if(table[i] > table[i+1])
{
printf( "le tableau est quelconque.\n");
ordre = 0;
break;
}
}
if(ordre == 1)
{
printf("le tableau est croissant.\n");
}
}
else if(table[0] > table[SIZE-1])
{
for( i=0; i<SIZE-1; i++)
{
if(table[i] < table[i+1])
{
printf("le tableau est quelconque.\n");
ordre = 0;
 break;
}
}
if(ordre == 1)
{
printf("le tableau est decroissant.\n");
}
}
else if(table[0] == table[SIZE-1])
{
for( i=0; i<SIZE-1; i++)
{
if(table[i] != table[i+1])
{
printf("le tableau est quelconque.\n");
ordre = 0;
break;
}
}
if(ordre == 1)
{
printf("le tableau est constant.\n");
}
}

return 0;
}

A) 7
Ecrire un programme qui demande à l’utilisateur de taper 10 entiers qui seront stockés dans un tableau. Le
programme doit trier le tableau par ordre croissant et doit afficher le tableau.
Algorithme suggéré :
On cherche l'indice du plus petit élément parmi les indices de 0 à 9 et on échange cet élément avec t[0].
On cherche l'indice du plus petit élément parmi les indices de 1 à 9 et on échange cet élément avec t[1].
On cherche l'indice du plus petit élément parmi les indices de 2 à 9 et on échange cet élément avec t[2].
... On cherche l'indice du plus petit élément parmi les indices de 8 à 9 et on échange cet élément avec t[8].
Solution

#include<stdio.h>

const int N=10;

int main()
{
int a[N],i,j,min,imin,tmp;

for(i=0;i<N;i++)
{
printf("Veuillez taper l'entier numero %d : ",i); scanf("%d",&a[i]);
 }

for(i=0;i<N-1;i++)
{
imin=i;min=a[i];
for(j=i+1;j<N;j++)if(a[j]<min){min=a[j];imin=j;}

tmp=a[imin];a[imin]=a[i];a[i]=tmp;
}
printf("VOICI LE TABLEAU TRIE :\n");
for(i=0;i<N;i++)printf("a[%d]= %d\n",i,a[i]);

return 0;
}

Solution 2

#include <stdio.h>
int main()
{int i;
const int taille = 10;
int tableau[taille];
int tampon;
for( i = 0; i < taille; i++) // Remplissage du tableau
{
printf( "Quelle valeur a l'indice : %d ", i );
scanf("%d",&tableau[i]);
}
int j = 0;
while(j < taille) // Boucle principale
{
int indice = j;

for( i = j; i < taille - 1; i++) // Boucle de recherche du plus petit élément

{
if(tableau[indice] > tableau[i + 1])
indice = i + 1;
}
// On inverse les éléments
tampon = tableau[j];
tableau[j] = tableau[indice];
tableau[indice] = tampon;
j++;
}
// On affiche le tableau trié
for( i = 0; i < taille; i++)
printf( "Indice %d : %d\n", i, tableau[i]);
return 0;
}
A) 8
Ecrire un programme qui demande à l’utilisateur de taper 10 entiers qui seront stockés dans un tableau. Le
programme doit trier le tableau par ordre croissant et doit afficher le tableau.
Algorithme suggéré (tri bulle) :
On parcourt le tableau en comparant t[0] et t[1] et en échangeant ces éléments s'ils ne sont pas dans le bon
ordre.
on recommence le processus en comparant t[1] et t[2],... et ainsi de suite jusqu'à t[8] et t[9].
On compte lors de ce parcours le nombre d'échanges effectués.
On fait autant de parcours que nécessaire jusqu'à ce que le nombre d'échanges soit nul : le tableau sera
alors trié.
Solution

#include<stdio.h>
const int N=10;
int main()
{
int a[N],i,nb,tmp;

for(i=0;i<N;i++)
{printf("Veuillez taper l'entier numero %d : ",i);scanf("%d",&a[i]);}

do
{
nb=0;
for(i=0;i<N-1;i++)
if(a[i]>a[i+1])
{
tmp=a[i];a[i]=a[i+1];a[i+1]=tmp;
nb++;
}
}while(nb!=0);

printf("VOICI LE TABLEAU TRIE :\n");

for(i=0;i<N;i++)printf("a[%d]=%d _n" ,i,a[i]);
return 0;
}

Solution 2

#include <stdio.h>
const int taille = 10;

int main()
{
int i;
int tableau[taille];
int tampon;

for(i= 0; i < taille; i++) // Remplissage du tableau

 {
printf( "Quelle valeur a l'indice %d : ");
scanf("%d",&tableau[i]);
}

int trie = 0; // Vérifie si un tri a eu lieu

while(!trie) // Si aucun tri n'a eu lieu, la boucle se finit

{
trie = 1;

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

{
if(tableau[i] > tableau[i + 1])
{
tampon = tableau[i];
tableau[i] = tableau[i + 1];
tableau[i + 1] = tampon;
trie = 0;
}
}
}

for( i = 0; i < taille; i++) // Affiche le tableau trié

printf( "Indice %d : %d\n" , i , tableau[i]);

return 0;
}

A) 9
Ecrire un programme qui saisit 2 tableaux de 10 entiers a et b. c est un tableau de 20 entiers. Le
programme doit mettre dans c la fusion des tableaux a et b. On copiera dans les 10 premières cases de c le
tableau a, dans les dix dernières le tableau b. Le programme affiche ensuite le tableau c.
Solution

#include<stdio.h>
const int N=10;

int main()
{
int a[N],b[N],c[2*N],i;

printf("SAISIE DU TABLEAU a\n");

for(i=0;i<N;i++){printf("Tapez un entier ");scanf("%d",&a[i]);}

printf("SAISIE DU TABLEAU b\n");

for(i=0;i<N;i++){printf("Tapez un entier ");scanf("%d",&b[i]);}

for(i=0;i<2*N;i++)if(i<N)c[i]=a[i];else c[i]=b[i-N];
printf("VOICI LE TABLEAU c\n");
for(i=0;i<2*N;i++)printf(" %d \n",c[i]);
return 0;
}

solution 2 :

#include<stdio.h>

const int Na=10;

const int Nb=10;

int main()
{
int a[Na],b[Nb],c[Na + Nb],i;

printf("SAISIE DU TABLEAU a\n");

for(i=0;i<Na;i++){printf("Tapez un entier ");scanf("%d",&a[i]);}

printf("SAISIE DU TABLEAU b\n");

for(i=0;i<Nb;i++){printf("Tapez un entier ");scanf("%d",&b[i]);}

for(i=0;i<Na + Nb;i++)if(i<Na)c[i]=a[i];else c[i]=b[i-Na];

printf("VOICI LE TABLEAU c\n");

for(i=0;i< Na + Nb;i++)printf(" %d \n",c[i]);
return 0;
}

A) 10
Ecrire un programme qui saisit 2 tableaux de 10 entiers a et b qui doivent être triés dans l'ordre croissant.
Le programme devra tout d'abord vérifier que les deux tableaux sont triés. Le tableau c est un tableau de
20 entiers. Le programme doit mettre dans c la fusion des tableaux a et b. Le tableau c devra contenir les
éléments de a et ceux de b et devra être trié. Le programme affiche ensuite le tableau c.
Solution

#include<stdio.h>
const int N=10;
int main()
{
int a[N],b[N],c[2*N],i,trie,indicea,indiceb;
printf("SAISIE DU TABLEAU a\n");
for(i=0;i<N;i++){printf("Tapez un entier ");scanf("%d",&a[i]);}
printf("SAISIE DU TABLEAU b\n");
for(i=0;i<N;i++){printf("Tapez un entier ");scanf("%d",&b[i]);}
trie=1;
i=0;
while(trie && i<N-1)if(a[i]>a[i+1])trie=0; else i++;

if(!trie)printf("Le tableau a n'est pas trié\n");

else
{
trie=1;
i=0;
while(trie && i<N-1)if(b[i]>b[i+1])trie=0; else i++;
if(!trie) printf("Le tableau a n'est pas trié\n");
else
{
indicea=0;indiceb=0;
for(i=0;i<2*N;i++)
{
if(indicea==N){c[i]=b[indiceb];indiceb++;}
else if(indiceb==N){c[i]=a[indicea];indicea++;}
else if(a[indicea]<b[indiceb]){c[i]=a[indicea];indicea++;}
else {c[i]=b[indiceb];indiceb++;}
}
}
}

printf("VOICI LE TABLEAU c\n");

for(i=0;i<2*N;i++)printf(" %d \n",c[i]);
return 0;
}

A) 11
Ecrire un programme qui gère une liste d'entiers grâce au menu suivant :
1. Ajouter un entier
2. Afficher la liste des entiers
3. Supprimer dernier entier de la liste.
4. Afficher la dernière note tapée
5. Quitter
Il y aura au maximum 10 entiers. Lorsqu'on rajoute un entier, il sera rajouté à la fin de la liste.
Solution

#include<stdio.h>

const int N=10;

int main()
{

int t[N],nb=0,choix,e,i;
int fini=0;

while(fini==0)
{
printf("1. Ajouter un entier\n");
 printf("2. Afficher la liste des entier\n");
printf("3. Supprimer le dernièr entier de la liste\n");
printf("4. Afficher le dernier entier de la liste\n");
printf("5. Quitter\n");
printf("Votre choix : %d "); scanf("%d",choix);
switch(choix)
{
case 1 : printf("Tapez un entier : ");scanf("%",&e);
if(nb<N){t[nb]=e; nb++; printf("ENTIER AJOUTE\n");}
else printf("IMPOSSIBLE LE TABLEAU EST PLEIN\n");
break;

case 2 : if(nb==0)printf("LA LISTE EST VIDE\n");

else {
printf("VOICI LA LISTE\n");
for(i=0;i<nb;i++)printf("%d \n",t[i]);

break;

case 3 : if(nb>0){nb--; printf("ENTIER SUPPRIME\n");}

else printf("LA LISTE EST VIDE\n");
break;

case 4 : if(nb>0) printf("lLE DERNIER ENTIER EST %d\n",t[nb-1]);

else printf("LA LISTE EST VIDE\n");
break;

case 5 : fini=1;
break;
}

}
return 0;
}

A) 12
Ecrire un programme qui gère une liste d'entiers grâce au menu suivant :
1. Ajouter un entier
2. Afficher la liste des entiers
3. Supprimer le premier entier ayant une valeur donnée.
4. Supprimer tous les entiers ayant une valeur donnée
5. Quitter
Il y aura au maximum 10 entiers. La liste devra être en permanence triée : lorqu'on rajoute un entier, il
sera inséré au bon endroit dans la liste pour que celle-ci reste triée.
Solution

#include<stdio.h>
const int N=10;
int main()
{

int t[N],nb=0,choix,e,V,i,j,trouve;
int fini=0;

while(fini==0)
{
printf("1. Ajouter un entier\n");
printf("2. Afficher la liste des entier\n");
printf("3. Supprimer le premier entier ayant une valeur donnée\n");
printf("4. Supprimer tous les entiers ayant une valeur donnée\n");
printf("5. Quitter\n");
printf("Votre choix : ");scanf("%d",&choix);
switch(choix)
{
case 1 : if(nb<N)
{
printf("Tapez un entier : %d ");scanf("%d",e);
i=0;
while(i!=nb && t[i]<e)i++;
for(j=nb;j>i;j--)t[j]=t[j-1];
t[i]=e;
nb++;
}
else printf("IMPOSSIBLE LE TABLEAU EST PLEIN\n");
break;

case 2 : if(nb==0)printf("LA LISTE EST VIDE\n");

else {
printf("VOICI LA LISTE\n");
for(i=0;i<nb;i++)printf(" %d ",t[i]);
}
break;

case 3 : printf("Tapez la valeur à supprimer : ");scanf("%d",&V);

trouve=0;
i=0;
while(!trouve && i<nb)if(t[i]==V)trouve=1; else i++;
if(trouve)
{
for(j=i;j<nb-1;j++)t[j]=t[j+1];
nb--;
}
break;

case 4 : printf("Tapez la valeur à supprimer : ");scanf("%d",&V);

j=0;
for(i=0;i<nb;i++)
if(t[i]!=V){t[j]=t[i];j++;}
nb=j;
break;
 case 5 : fini=1;
break;
}

}
return 0;
}

A) 13
Ecrire un programme qui demande à l'utilisateur de taper un entier N<=20 et qui affiche la N-ième ligne
du triangle de pascal.
ligne 1 : 1 1
ligne 2 : 1 2 1
ligne 3 : 1 3 3 1
ligne 4 : 1 4 6 4 1
et ainsi de suite ...
Solution

#include<stdio.h>
int main()
{ int a[21],i,j,N;
printf("Veuillez taper N : ");scanf("%d",&N);
a[0]=1;
for(i=1;i<=N;i++)
{
a[i]=1;
for(j=i-1;j>=1;j--)a[j]=a[j]+a[j-1];
}
for(i=0;i<=N;i++)printf("%d",a[i]);
return 0;
}

A) 14
Ecrire un programme qui demande à l'utilisateur de taper 10 entiers compris entre 0 et 20 qui seront
stockés dans un tableau et qui affiche le nombre de fois qu'on a tapé un 0, le nombre de 1, le nombre de 2,
..., le nombre de 20.
Solution

#include<stdio.h>

int main()
{
int a[10],nb[21],i;

for(i=0;i<10;i++)
{
 do {printf("Veuillez taper l'entier numero %d : ",i);scanf("%d",&a[i]);}
while (a[i]>20 || a[i]<0);
}

for(i=0;i<21;i++)nb[i]=0;
for(i=0;i<10;i++)nb[a[i]]++;

for(i=0;i<21;i++){printf("Il y a %d fois l'entier %d\n",nb[i],i);}

return 0;
}

A) 15
Ecrire un programme qui demande à l'utilisateur de taper le contenu d'un tableau de réels de 3 lignes et 3
colonnes et qui affiche ce tableau mais en affichant la moyenne des éléments de chaque ligne, de chaque
colonne et la moyenne globale.
Solution

#include<stdio.h>
const int N=3;
const int M=3;

int main()
{
double t[N][M],moyL[N],moyC[M],moy;
int i,j;

for(i=0;i<N;i++)
for(j=0;j<M;j++)
{
printf("Tapez la valeur de la ligne %d et la colonne %d : ",i,j);
scanf("%lf",&t[i][j]); }

for(i=0;i<N;i++)moyL[i]=0;
for(j=0;j<M;j++)moyC[j]=0;
moy=0;

for(i=0;i<N;i++)
for(j=0;j<M;j++)
{
moyL[i]=moyL[i]+t[i][j];
moyC[j]=moyC[j]+t[i][j];
moy=moy+t[i][j];
}

for(i=0;i<N;i++)moyL[i]=moyL[i]/M;
for(j=0;j<M;j++)moyC[j]=moyC[j]/N;
moy=moy/(N*M);

for(i=0;i<N;i++)
 {
for(j=0;j<M;j++)
printf("%lf ",t[i][j]);
printf("%lf\n",moyL[i]);
}
for(j=0;j<M;j++)
printf("%lf\n",moyC[j]);

return 0;
}

Opérations sur les Tableaux

Travail à Faire :
Exercice 1.
Ecrivez un programme qui, étant donnés deux tableaux de nombres entiers A et B, de même longueur N,
calcule et imprime le nombre de valeurs de i pour lesquelles on a Ai = Bi

Exercice 2.
A. Ecrivez un programme qui cherche et imprime la valeur du plus petit élément d’un tableau T de N
nombres entiers.
2. B. Ecrivez un programme qui cherche et imprime le rang du plus petit élément d’un tableau T de N
nombres entiers.

Exercice 3
RECHERCHE SEQUENTIELLE. Ecrivez un programme qui, étant donnés un tableau U de I nombres
entiers et un nombre entier Y, cherche et imprime le plus petit rang v tel que Uv = Y, dans les deux cas
suivants :
• on est sûr qu’il existe au moins un élément égal à Y dans le tableau ;
• on n’est pas assuré qu’un tel élément existe.

Exercice 4
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.
Exercice 5
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.
Effacer ensuite toutes les occurrences de la valeur 0 dans le tableau T et tasser les éléments restants.
Afficher le tableau résultant.
Exercice 6
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.
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.

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