COURS d’INTRODUCTION A L’ALGORITHMIQUE ET A LA

PROGRAMMATION
CLASSE DE MPCI

PLAN
Introduction
Chapitre I. Notions de base de la programmation
Chapitre II. Les Structures de contrôle
Chapitre III. Les Structures de données élémentaires : tableaux et structures

Introduction

La science informatique couvre deux grands domaines : Le domaine du matériel et le

domaine des logiciels et des programmes. De façon générale, les programmes informatiques
permettent de piloter le matériel pour l’exécution de tâches spécifiques. Ces programmes sont
constitués des ordres appelés instructions destinées au matériel, notamment au
microprocesseur qui est le composant interne chargé par excellence de l’exécution de toutes
les directives. Ces ordres sont exprimés dans une série de langages qui finissent par créer une
hiérarchie.
La programmation est un processus permettant d’écrire des programmes dont la
finalité est de donner à l’ordinateur des capacités de résolution de problèmes spécifiques. Elle
est initialement liée à la connaissance de la séquence d’étapes qui permet de résoudre le
problème de départ posé en langage naturel. De ce problème posé et des séquences de sa
résolution, les programmeurs sont appelés à utiliser les outils que leur offre d’abord le langage
algorithmique. Il s’agit des mots réservés et des syntaxes qui composent les instructions
simples ou complexes de ce langage. Ces instructions matérialisent la démarche structurée à
partir de laquelle le problème posé peut être résolu par la machine.
Du point de vu de l’exécution d’un programme à l’intérieur de la machine, les
instructions agissent sur des cases mémoires ou variables perçues à l’image des récipients.
Ces actions vont modifier progressivement le contenu de ces cases pour fournir à la fin le
résultat auquel il est possible de parvenir. L’ensemble des contenus des cases mémoires à un
instant donné représente l’état du programme à cet instant. Cet état est complété par les
instructions qui sont en cours d’exécution et le niveau de l’évolution de cette exécution.

A. Problème Posé

B. Analyse du problème

C. Ecriture de l’algorithme

D. Traduction de l’algorithme dans un

Langage de Programmation (LP)

Choix de l’environnement Choix de l’environnement

interprété (I) compilé (II)

1
 Chapitre I. Notions de base de la programmation

I.1. Le Langage Algorithmique

I.1.1. Notion de variable et d’instruction

Une variable est une case mémoire destinée à contenir des valeurs d’un type
particulier. Elle est définie par son nom composé des lettres de l’alphabet et des chiffres, avec
l’obligation de commencer par des lettres ou le caractère "_". Il est recommandé d’avoir des
noms significatifs et moins long. Les caractères suivants sont interdits : l’espace, les
opérateurs arithmétiques, les caractères de ponctuation, (, ), {, }, [, ], …
Les types algorithmiques de base :
Le type entier
Le type réel
Le type caractère
Eventuellement, le type booléen

Syntaxe de déclaration des variables :

Type NomVariable ;
Type NomVar1, NomVar2, … , NomVarN ;
Exemple :
entier I, J, K ;
car choix ;
reel moyenne123 ;

Notion d’instruction
C’est un ordre donné à la machine qui peut être : une déclaration de variables, une
affectation, une opération d’entrée/sortie, …

I.1.2. L’affectation et les opérateurs arithmétiques disponibles

L’affectation
Elle consiste à placer une valeur dans une variable.
Syntaxe :
NomVariable ← Valeur ;
NomVariable ← Variable ;
NomVariable ← Expression ;
Exemple :
I ← 100 ;
J ← I;
K ← J + I;
I ← I + K;

Les opérateurs arithmétiques : *, /, +, -, mod

2
 I.1.3. L’instruction de lecture

Elle consiste à lire une valeur au clavier et à l’affecter à une variable.

Syntaxe : lire(NomVar) ;
lire(NomVar1, NomVar2, …, NomVarN) ;
Exemple :
lire(I) ;
lire(choix, moyenne123) ;

I.1.4. L’instruction d’écriture

Elle permet d’afficher à l’écran, la valeur contenue dans une variable ou une chaine de
caractères placée entre double quottes ".
Syntaxe : ecrire(I) ;
ecrire(K, J, choix) ;
ecrire("Bonjour") ;

I.1.5. Notion de données et résultats

Les données d’un programme sont constituées de l’ensemble d’information qu’il est
nécessaire d’avoir ou de disposer au préalable pour résoudre le problème posé par un énoncé.
Elles sont déterminées sous forme de variables dont les valeurs sont obtenues au début de
l’exécution du programme, généralement en sollicitant l’intervention de l’utilisateur à partir
du clavier.
Les résultats sont constitués de l’ensemble d’information que le programme doit
fournir à la fin de son exécution. Il peut s’agir également de variables portant des valeurs
finales recherchées ou des messages informant l’utilisateur de la conclusion à laquelle le
programme est parvenu à la fin de l’exécution de toutes les instructions.

I.1.6. Structure générale d’un programme algorithmique

Données :
Résultats :
Début
/* Déclaration des variables */
/* Lecture des données */
/* Calcul des résultats */
/* Affichage des résultats */
Fin

I.1.7. Exercices d’application

1. Ecrire un programme qui permet de résoudre une équation du second degré dans IR,
de la forme ax2+bx+c=0
Données : ………………………………………………………………………………………
Résultats : ………………………………………………………………………………………
2. Ecrire un programme algorithmique qui permet d’évaluer la fonction entière à valeur
entière f(x) suivante :
F(x) = 15x4 + 3x3 + x – 4
Données : ………………………………………………………………………………………

3
Résultats : ………………………………………………………………………………………
3. Ecrire un programme algorithmique qui permet d’évaluer la fonction réelle à valeur
réelle g(x) suivante :
g(x,y) = x3 - 3y2
Données : ………………………………………………………………………………………
Résultats : ………………………………………………………………………………………
4. Ecrire un programme qui calcule la moyenne arithmétique simple d’un étudiant dans
les matières suivantes : Informatique, Math, Physique, Anglais
Données : ………………………………………………………………………………………
Résultats : ………………………………………………………………………………………
5. Ecrire un programme qui calcule la moyenne arithmétique pondérée d’un étudiant
dans les matières suivantes : Informatique, Math, Physique, Anglais
Données : ………………………………………………………………………………………
Résultats : ………………………………………………………………………………………
6. Un mur clôture une parcelle de long x larg (en mètre) avec 3 couches de briques
pleines et 11 couches de briques creuses. Dans ces dernières couches, un portail de 3m
est programmé. Ecrire un programme algorithmique qui détermine le nombre de
briques à utiliser pour clôturer cette parcelle pour des briques longues de 40cm.
Données : ………………………………………………………………………………………
Résultats : ………………………………………………………………………………………
7. Le service de solde d’une société établit les bulletins de salaire en utilisant les
formules suivantes :
Salaire de base = taux x indice
Salaire brut = salaire de base + indemnités
Salaire net = Salaire brut – IUTS
Ecrire un programme qui calcule le salaire d’un employé et détermine sa catégorie :
Si Salaire net <= 50 000, l’employé est PAT
Si 50 000 < Salaire net < 300 000, l’employé est cadre
Si Salaire net > 300 000, l’employé est du STAFF
Données : ………………………………………………………………………………………
Résultats : ………………………………………………………………………………………

I.2. Le Langage C

I.2.1. Structure générale d’un programme C

- directives d’inclusion des bibliothèques

- définition des fonctions
- fonction principale appelée main()

exemple :
les fonctions de lecture et écriture en C sont disponibles dans la bibliothèque sous le
nom de fichier "stdio.h". D’où l’obligation d’inclure ce fichier pour l’usage de ces fonctions.

#include <stdio.h>
Equivalent à "Début"
main()
{
instructions en langage C
} Equivalent à "Fin"

4
 I.2.2. Notion de variable et d’instruction

Sa définition est la même que pour la syntaxe algorithmique.

Les types de base en langage C sont :
int : représente le type entier
float : représente le type réel
char : représente le type caractère

Syntaxe de déclaration des variables :

int I, J, K ;
char choix ;
float moyenne123 ;

Notion d’instruction
Comme dans le cas du langage algorithmique, une instruction est un ordre donné à la
machine qui peut être : une déclaration de variables, une affectation, une opération
d’entrée/sortie, …

I.2.3. L’affectation et les opérateurs arithmétiques disponibles

Notion d’affectation :
Syntaxe :
NomVariable = Valeur ;
NomVariable = Variable ;
NomVariable = Expression ;
Exemple :
I = 100 ;
J = I;
K = J + I;
I = I + K;

Les opérateurs arithmétiques : *, /, +, -, %

I.2.4. L’instruction de lecture

Syntaxe de la fonction scanf :

scanf("Chaine", &NomVar1, &NomVar2, …, &NomVarN) ;
Description : la Chaine comporte la spécification du type de la variable à lire dans l’ordre
indiqué par la liste des variables.
Si la variable est de type entier, la chaine doit comporter %d
Si la variable est de type réel, la chaine doit comporter %f
Si la variable est de type caractère, la chaine doit comporter %c
Exemple :
int x,y ;
float note;
scanf("%d", &x) ; lire(x) ;
scanf("%f %d", &note, &y) ; lire(note, y) ;

5
 I.2.5. L’instruction d’écriture

Syntaxe de la fonction printf :

printf("Chaine", NomVar1, NomVar2, …, NomVarN) ;
Description : la Chaine peut comporter une chaine de caractères et/ou la spécification du/des
type(s) de la (des) variable(s) à écrire dans l’ordre indiqué par la liste des variables.
Syntaxe :
int x = 10,y=1 ;
float note=13;

printf("%d", x) ;
à l’affichage :
10
printf("\nLa note de l’étudiant est : %f et y = %d", note, y) ;
à l’affichage :
La note de l’étudiant est : 13 et y = 1
printf("Bonjour") ;
à l’affichage :
Bonjour

I.2.6. Exemple d’illustration

Enoncé 1
Ecrire un programme qui permet d’évaluer la fonction entière f(x) suivante :
f(x) = 17x3 – 4 x² + x + 7
Données : l’entier x
Résultats : l’entier fdex = f(x)
Début
entier x, fdex ;
lire(x) ;
fdex ← 17 *(x * x* x) – (4 * x * x )+ x + 7 ;
ecrire(fdex) ;
Fin
Permet d’informer l’utilisateur de la
#include <stdio.h> donnée attendue par la machine
main()
{ int x, fdex ;
char arret; Permet d’informer l’utilisateur du
printf("\nEntrer la valeur de x : ") ; résultat obtenu par la machine
scanf("%d", &x);
fdex = 17 *(x * x* x) - (4 * x * x )+ x + 7 ;
printf("\nLa valeur de f de x = %d", fdex);
Permet d’arrêter la machine pour la
scanf("%c", &arret) ; lecture du résultat
scanf("%c", &arret) ;
}

Exercices d’application
Corriger et traduire dans la syntaxe du langage C, les exercices de la section
algorithmique précédente.

6
 Chapitre II. Les structures de contrôle

II.1. La structure conditionnelle

II.1.1. Définition

Plusieurs structures de contrôle sont utilisées dans un programme informatique et

forment des instructions composites et plus complexes que les instructions élémentaires.
Parmi ces structures, il y a la structure conditionnelle. La structure conditionnelle permet de
formaliser dans un programme des cas où des instructions ne sont exécutées que si une
expression conditionnelle préalablement évaluée prend la valeur de vérité "vrai". La syntaxe
du langage C est la suivante :
if (expression)
instruction1
else
instruction2
Légende :
- la partie de la conditionnelle représentée par le "else" (ici en italique) est facultative, et
donc peut ne pas apparaître.
- Expression : représente une expression conditionnelle composée avec les opérateurs
de comparaison >, >=, <, <=, ==, !=. Les opérateurs de jointure peuvent également
être utilisés dans l’expression : &&, ||, !
- Instruction : représente une instruction C quelconque (déclaration, affectation, …).
Lorsqu’il s’agit de plusieurs instructions, l’usage de l’accolade ouvrante "{" avant la
première instruction et celle de l’accolade fermante "}" à la fin est obligatoire.

Exemple 1 : illustration du cas d’absence du "else"

if (X > 0)
printf("\nX est positif") ;

Exemple 2 : illustration du cas d’utilisation du "else"

if (X > 0)
{ printf("\nX est positif") ;
Y=X;
}
else
printf("\nX est négatif") ;

II.1.2. Syntaxes générales d’une expression conditionnelle

Cas d’une expression simple

Une expression simple prend l’une des formes suivantes :
- Op2 Opérande : cette forme est utilisée le plus souvent dans le cas de l’usage de
l’opérateur de jointure "!". Elle exprime la négation de l’opérande. Si l’opérande est vrai,
alors l’évaluation de l’expression renvoie la valeur de vérité "faux", et vice-versa. L’opérande
sera dans ce cas-ci un nom de variable.

7
Exemple :
Soit l’instruction de déclaration suivante :
int MaVar1, MaVar2 ;
Les expressions conditionnelles suivantes sont valides :
( ! MaVar1)
( ! MaVar1+MaVar2)
- (Opérande Op1 Opérande) : dans cette expression, les opérandes peuvent être des
variables, des valeurs immédiates ou des expressions arithmétiques parenthésées ou pas.
L’opérateur utilisé est un opérateur binaire de la catégorie 1.
Exemple :
Soit les instructions de déclaration suivantes :
int MaVar1, MaVar2 ;
char MonCaractere ;
Les expressions conditionnelles suivantes sont algorithmiquement valides :
(MaVar1 > 0)
(MaVar1 - MaVar2 > 0)
(MaVar2/11 != MaVar1)
(MonCaractere != ‘a’)
- Op2 Expression : il s’agit de la même forme que précédemment, mais en remplaçant
l’opérande par une sous expression conditionnelle. Elle traduit également le cas de l’usage de
l’opérateur de jointure "!". Elle exprime la négation de la sous expression. Si celle-ci est vraie,
alors l’évaluation de l’expression globale renvoie la valeur de vérité "faux", et vice-versa.
Exemple :
Soit l’instruction de déclaration suivante :
int MaVar1, MaVar2 ;
Les expressions conditionnelles suivantes sont algorithmiquement valides :
!(MaVar1 > 0)
!(MaVar2 != MaVar1)
Ces expressions sont équivalentes respectivement à :
(MaVar1 <= 0)
(MaVar2 == MaVar1)
De ce fait, une expression conditionnelle utilisant l’opérateur de négation NON dans une
forme factorisée peut être traduite dans une forme développée par introduction de l’opérateur
NON à l’intérieur des parenthèses et en l’appliquant aux opérandes et aux opérateurs.

Cas d’une expression composite

La lisibilité d’une expression conditionnelle complexe est facilitée par l’usage des
parenthèses. Ces parenthèses également facilitent l’application de l’ordre de priorité entre les
différents termes de l’expression. Le respect des règles de parenthésage est une contrainte
pour la création des expressions bien parenthésées. La forme générale des expressions
composites est la suivante :
Expression [Op2 Expression]n
- Expression désigne une expression simple ou une expression composite.
- Les crochets symbolisent une partie optionnelle, qui lorsqu’elle doit apparaître,
désigne une autre expression rattachée aux précédentes au moyen d’un opérateur de
jointure de catégorie 2.
- L’exposant n symbolise la répétition plusieurs fois de la partie délimitée par les
crochets, ce qui donne une expression plus complexe qui nécessite l’usage des
parenthèses.

8
Exemple :
Soit l’instruction de déclaration suivante :
int MaVar1, MaVar2, MaVar2 ;
Les expressions conditionnelles suivantes sont algorithmiquement valides :
(MaVar1 > 0) && (MaVar2 != MaVar1)
(MaVar1 < 100) || (MaVar2 == 12)
L’expression suivante est vraie si MaVar1 ∈ [MaVar2, MaVar3]
(MaVar1 >= MaVar2) && (MaVar1 <= MaVar3)
L’expression suivante est vraie si MaVar1 ∉ [MaVar2, MaVar3]
(MaVar1 < MaVar2) || (MaVar1 > MaVar3)
Soit à proposer une expression traduisant l’assertion selon laquelle une année est bissextile si
elle est divisible par 4, pas par 100, en dehors des années multiples de 400 qui sont
bissextiles. Pour cela l’opérateur "%" est utilisé pour obtenir le reste de la division d’un
nombre par un autre.
((Année % 4 == 0) && (Année % 100 != 0)) || (Année % 400 == 0)
La première sous expression (Année % 4 = 0) permet d’évaluer si l’année est divisible par 4.
Et puisque cette seule condition ne suffit pas, il faut vérifier que l’année n’est pas divisible par
100 (Année % 100 != 0), d’où l’usage de l’opérateur de rattachement "&&". Puisque par
défaut les années multiples de 400 sont bissextiles, et que cette condition suffit à elle seule à
faire déduire le caractère bissextile de l’année, la troisième sous expression (Année % 400 =
0) sera rattachée aux autres par l’opérateur "||".

Règles de construction des expressions logiques complexes bien parenthésées :

- Une expression logique ne peut commencer que par un opérande ou une parenthèse
ouvrante "(".
- Une parenthèse ouvrante ne peut être suivie que de parenthèse ouvrante ou
d’opérande.
- Un opérande peut être une valeur numérique ou une variable, les deux éventuellement
précédés d’opérateur arithmétique unaire. Un opérande peut aussi être une sous
expression arithmétique, une sous expression logique simple ou une sous expression
logique complexe. Chaque sous expression nécessite d’être délimitée, parcourue et
vérifiée selon les règles de construction élaborées. Un opérande ne peut être suivi que
par un opérateur binaire de catégorie 2 ou par une parenthèse fermante ")".
- Un opérateur binaire ne peut être suivi que d’un opérande définit ci-dessus.
- Une parenthèse fermante ")" ne peut être suivie que de parenthèse fermante ou
d’opérateur binaire.

II.1.3. Exercice d’application

Une année est bissextile si les deux derniers chiffres sont divisibles par 4. Ecrire un
programme C qui permet de vérifier si une année est bissextile.

Données : Annee un entier représentant une année

Résultat : message Annee est bissextile ou pas
#include<stdio.h>
main()
{ int Annee, R ;
char Arret ;
printf("\nEntrer l’année :") ;
scanf("%d", &Annee) ;

9
 R = Annee % 100 ; /* Obtenir les deux derniers chiffres */
if (R % 4 == 0) /* Vérifier si les deux derniers chiffres sont divisibles par 4*/
printf("\nL’année %d est bissextile !", X) ;
else
printf("\nL’année %d n’est pas bissextile !", X) ;
}

II.1.4. Exercices sur la structure conditionnelle

1. Ecrire un programme qui lit deux entiers X et Y, et donne leur différence en valeur
absolue.
2. Ecrire un programme qui établit le bulletin de notes avec une moyenne arithmétique
simple, d’un étudiant dans les matières suivantes : Informatique, Anglais, Biologie,
Environnement.
3. Ecrire un programme qui lit 2 entiers et affiche le plus grand au sens large
4. Ecrire un pgm qui donne la différence en valeur absolue entre 2 entiers donnés
5. Ecrire un programme qui lit 2 entiers et affiche le plus grand au sens strict
6. Ecrire un programme qui indique si un entier lu est pair ou impair

II.2. Les structures de contrôle répétitives

Les programmes informatiques utilisent les structures de contrôle répétitives appelées

aussi boucle, pour résoudre des problèmes qui nécessitent d’exécuter une ou plusieurs
instructions en plusieurs cycles jusqu’à l’obtention d’un résultat recherché. Ces structures sont
de 2 types :
- la structure répétitive avec compteur à travers laquelle la répétition des itérations se
fait un nombre de fois donné à l’avance par une valeur numérique ou par une variable.
C’est le cas de la structure "pour …"
- la structure répétitive conditionnelle à travers laquelle la répétition des itérations est
contrôlée par une expression logique. Les cycles se poursuivent tant que cette
expression logique appelée aussi condition est vraie. Les cycles prennent fin dès que
l’expression est fausse. L’expression logique est évaluée à chaque itération. C’est le
cas de la structure "tant que …"

II.3. La structure répétitive avec compteur

II.3.1. Définition

Les deux aspects caractéristiques de la structure répétitive avec compteur doivent

ressortir lors de l’analyse pour imposer l’usage de cette structure. Il s’agit de :
- La limitation du nombre de répétition,
- La liste des instructions à exécuter de façon répétitive : la problématique à ce niveau
se rapporte à rechercher à l’avance, le schéma d’évolution de l’état du programme,
c'est-à-dire le contenu des variables et les instructions qui vont être exécutées pour le
faire évoluer au fur et à mesure du déroulement des itérations.

Les étapes de l’analyse qui conduisent à l’usage de la structure répétitive avec

compteur nécessitent que soit fixé le schéma d’évolution du contenu des variables qui
dépendent des itérations. Ce schéma d’évolution peut être perceptible assez simplement dans
le cas d’actions classiques, à l’image du parcours d’un tableau à l’aide d’un indice incrémenté

10
à chaque tour de boucle. Chaque valeur de l’indice permet d’accéder à un élément du tableau
et le nombre d’éléments est connu à priori. Dans de tels cas, le parcours de tous les éléments
stockés dans un tableau suppose nécessairement l’usage d’une structure répétitive.
Trois questions complètent la grille d’analyse à ce stade pour permettre de déterminer
l’usage possible de la structure "pour …". Les réponses aux trois questions permettront de
déterminer si l’usage de la structure répétitive avec compteur est requis dans le déroulement
d’une partie d’un programme, tout en spécifiant le schéma d’évolution de l’état du
programme :
Q5 : Y a-t-il un schéma qui illustre l’évolution progressive des valeurs des variables au fil des
itérations pour atteindre un résultat ?
Q6 : Quel est le groupe d’instructions à mettre en place pour assurer cette évolution ?
Q7 : Quelle est la limite maximale du nombre d’itérations ?

Syntaxe en langage C :
for (instruction initiale ; condition de continuation ; instruction de continuation)
instruction
- instruction : peut être une seule instruction ou un bloc d’instruction de la forme :
{ instruction1 ;
instruction2 ;
…
instructionN ;
}
Légende :
- instruction initiale : est une instruction qui sera exécutée avant la première itération
- condition de continuation : est une expression logique (la même que celle du if) qui
sera évaluée avant chaque tour de boucle, y compris le premier. Le tour de boucle est
réalisé si l’expression est vraie.
- instruction de continuation : est une instruction exécutée à la fin de chaque tour de
boucle.

II.3.2. Exercice d’application

Ecrire un pgm qui affiche N fois le message « bonjour »

Données : l’entier N
Résultats : affichage du message "bonjour" N fois
#include<stdio.h>
main()
{ int I, N ;
printf("\nEntrer la valeur de N :") ;
scanf("%d", &N) ;
for(I = 1; I <= N; I++)
printf("\nbonjour") ;
}

II.3.3. Exercices sur la structure répétitive avec compteur

1. Ecrire un programme qui calcule le factoriel d’un nombre

2. Ecrire un programme qui calcule X à la puissance Y

11
 3. Ecrire un programme qui calcule la moyenne arithmétique simple d’une série de vingt
notes réelles sans stockage des notes individuelles.
4. Ecrire un programme qui calcule la moyenne arithmétique pondérée d’une série de dix
notes réelles sans stockage des notes individuelles.
5. Reprendre l’exercice précédent en permettant à l’utilisateur de choisir n’importe quel
nombre de notes.
6. Ecrire un programme qui affiche la table de multiplication sous la forme :
1 2 3 4 5 6 7 8 9 10 11 12
1 1 2 3 4 5 6 7 8 9 10 11 12
2 2 4 6 8 10 12 14 16 18 20 22 24
3 3 6 9 12 15 18 21 24 27 30 33 36
4 4 8 12 16 20 24 28 32 36 40 44 48
5 5 10 15 20 25 30 35 40 45 50 55 60
6 6 12 18 24 30 36 42 48 54 60 66 72
7 7 14 21 28 35 42 49 56 63 70 77 84
8 8 16 24 32 40 48 56 64 72 80 88 96
9 9 18 27 36 45 54 63 72 81 90 99 108
10 10 20 30 40 50 60 70 80 90 100 110 120
11 11 22 33 44 55 66 77 88 99 110 121 132
12 12 24 36 48 60 72 84 96 108 120 132 144

II.4. La structure répétitive conditionnelle

II.4.1. Définition

Le schéma en langage C de la structure répétitive conditionnelle présente une entête et

un corps qui délimite la portée de l’entête, c'est-à-dire, l’ensemble des instructions qui seront
exécutées à chaque itération. L’entête est composée du mot réservé du langage "while" suivi
d’une expression conditionnelle de contrôle des répétitions. La syntaxe C de la structure est la
suivante :
while (expression)
instruction

- instruction : peut être une seule instruction ou un bloc d’instruction (voir "for")
- expression : est une expression logique comme celle du "if". Elle est évaluée avant la
première itération et à chaque itération ou tour de boucle. Les itérations sont arrêtées
dès que l’expression est fausse. De ce fait, l’expression doit être composée de
variables dont la valeur change dans le corps de la boucle pour éviter des boucles
infinies.

La grille d’analyse qui conduit à l’utilisation de la structure répétitive conditionnelle

est la même pour les questions Q5 et Q6. Elle est différente pour la question Q7 qui restera
exclusivement à l’usage de la structure répétitive avec compteur. Dans la structure répétitive
conditionnelle, la répétition des itérations dépend de la valeur de vérité de l’expression
conditionnelle d’entête. La question Q8 est rajoutée à la grille d’analyse et permet de
rechercher la composition de cette expression conditionnelle. Les questions Q7 et Q8
constituent les points de séparation dans le choix de l’une ou l’autre des deux structures
répétitives. Lorsque la réponse à la question Q7 est donnée, la structure avec compteur sera
utilisée, le cas échéant, la structure conditionnelle est mieux adaptée. La structure répétitive

12
avec compteur peut être remplacée par la structure répétitive conditionnelle. L’inverse n’est
pas toujours possible.

II.4.2. Exercice d’application

Exemple : écrire un pgm qui affiche N fois le message « bonjour »

Données : l’entier N
Résultat : le message « bonjour » affiché N fois

#include<stdio.h>
main()
{ int I, N ;
printf("\nEntrer la valeur de N :") ;
scanf("%d", &N) ;
I = 1;
while (I <= N)
{ printf("\nbonjour") ;
I++;
}
}

II.4.3. Exercices sur la structure répétitive conditionnelle

1. Ecrire l’algorithme d’un programme qui lit de façon itérative un entier X et indique si
X est pair ou impair, jusqu’à ce que l’utilisateur décide d’arrêter ces itérations en
tapant la valeur zéro pour X.
2. Ecrire un programme algorithmique qui lit les bornes BI et BS d’un intervalle
d’entiers. Le programme oblige l’utilisateur à respecter la contrainte BI < BS. De
même, pour quitter le programme, l’utilisateur doit taper une valeur entière N
comprise entre [BI, BS]. Le programme indique à chaque fois la position de la valeur
tapée par l’utilisateur par rapport aux bornes de l’intervalle : hors borne supérieure, en
deçà de la borne inférieure.
3. Ecrire l’algorithme d’un programme qui permet de lire un nombre dans une variable N
portant sur deux octets au maximum en représentation non signée et affiche N chiffre
par chiffre.
4. Ecrire un pgm qui affiche le numéro d’itération en demandant à l’utilisateur son avis
par ‘o’ ou ‘n’ pour arrêter l’affichage.
5. Ecrire un pgm qui présente le menu suivant à un utilisateur en affichant un message
indiquant à chaque fois l’option choisie par l’utilisateur :
MENU
1. Afficher
2. Lecture
3. Supprimer
0. Quitter

II.5. Exercices sur l’imbrication des structures de contrôle

1. Ecrire un programme qui permet de lire une série de caractères hexadécimaux X1 et X2

dans l’ordre. Les deux caractères X1 et X2 représentent à chaque fois un nombre sur un

13
 octet. Le programme donne la valeur décimale de chaque nombre de la série à chaque
itération. La série est terminée par les caractères 00.
2. Ecrire un programme qui lit trois entiers X, Y et Z et les affiche dans l’ordre croissant.
3. Ecrire un programme qui lit plusieurs fois deux entiers X et Y et indique si X est divisible
par Y tant que la variable Y n’est pas nulle.
4. Ecrire un programme qui lit plusieurs fois deux entiers X et calcule XY/Y ! tant que la
variable Y n’est pas nulle.
5. Ecrire un programme qui lit N fois trois entiers X, Y et Z et indique s’ils sont divisibles
deux à deux, de façon exclusive.
6. Ecrire un programme qui répète N fois le calcule de la moyenne arithmétique simple
d’une série de notes réelles sans stockage des notes individuelles. Le programme
indiquera l’admissibilité à chaque moyenne calculée, si elle est supérieure ou égale à 10.
7. Reprendre l’exercice sur l’affichage d’une table de multiplication par le nombre entier N.
Le programme algorithmique se répète tant que N est différent de 0.
8. Ecrire un programme qui répète N fois le calcule de la moyenne arithmétique pondérée
d’une série de notes réelles sans stockage des notes individuelles. Le programme
indiquera l’admissibilité à chaque moyenne calculée, si elle est supérieure ou égale à 10.

14
 Chapitre III. Les tableaux

III.1. Définitions

Un tableau est un regroupement d’éléments de même type désignés par un

identificateur unique (variable). Les éléments d’un tableau sont stockés en mémoire de façon
contiguë. Leur position dans cette liste est donnée par un indice.
En informatique, les tableaux sont utilisés pour résoudre des problèmes qui nécessitent
un stockage des valeurs de même type dont le nombre est connu à priori. Ce nombre désigne
la taille du tableau. Par exemple pour saisir les notes dans une matière d’une classe
d’étudiants, il ne saurait être question de déclarer autant de variables que d’étudiants de la
classe. De ce fait, l’utilisation d’un tableau est plus indiquée avec de surcroit l’effectif de la
classe qui est connu d’avance et qui constitue le nombre d’éléments du tableau.

III.2. Les vecteurs ou tableaux à une dimension

III.2.1. Syntaxe de déclaration d’un vecteur

Type NomVariable [Taille_Max] ;

Exemple : l’instruction suivante permet de déclarer un tableau de 100 entiers
int tab[100] ;

III.2.2. Opérations sur les vecteurs

Principe standard de parcours d’un vecteur

Le parcours des éléments du tableau en C se fait en utilisant un indice qui prend des
valeurs dans l’intervalle [0, TailleMax-1]. De ce fait, le premier élément du tableau précédent
est tab[0], le dernier élément est tab[99].

Principe standard de lecture des éléments d’un vecteur

La lecture des éléments d’un vecteur se fait de façon standard en utilisant la structure
répétitive "for" dont le compteur d’entête sert d’indice de parcours des cases du tableau. Cette
structure comporte dans son corps au moins deux instructions, la première qui affiche le
message d’indication de la case du tableau à renseigner et la seconde instruction permet de
lire la valeur de cet élément au clavier. Par exemple, si un tableau de dix entiers est déclaré
avec l’instruction "int Tab[10] ;" avec la déclaration du compteur I par la syntaxe "int I ;",
alors les instructions suivantes permettent de lire les éléments de ce tableau :
for (I = 0; I<=9; I++)
{ printf("\nEntrer l’élément Tab[%d]", I) ;
scanf("%d", &Tab[I]) ;
}

Principe standard d’affichage des éléments d’un vecteur

L’affichage des éléments d’un vecteur se fait de façon standard également en utilisant
la structure répétitive "for" dont le compteur d’entête sert d’indice de parcours des cases du
tableau. Cette structure comporte dans son corps moins l’instruction d’affichage d’un message
éventuel suivi de la valeur de la case du tableau avec éventuellement l’utilisation du retour à

15
la ligne à la position voulue par le programmeur. Pour afficher le vecteur de l’exemple
précédent, les instructions suivantes peuvent être utilisées :
for (I = 0; I<=9; I++)
printf("\nL’élément Tab[%d] = %d", I, Tab[I]) ;

III.2.3. Exercice d’application

Ecrire un programme qui permet avec des parcours séparés, de lire 10 entiers, de les
stocker en mémoire, de rechercher le plus grand ainsi que le plus petit des entiers stockés et
de calculer la moyenne arithmétique simple des entiers ainsi stockés.

Données : 10 entiers
Résultats : E le tableau contenant les 10 entiers stockés en mémoire
PG = Plus grand entier PP = Plus petit entier
#include<stdio.h>
main()
{ int E[10], PG, PP, i ;
float Moyenne;
/*lecture du tableau */
for (i=0; i<=9; i++)
{ printf("\nEntrer l’élément numéro %d",i) ;
scanf("%d", &E[i]) ;
}
/* Recherche du plus grand */
PG=E[0] ;
for (i=1; i<=9; i++)
{ if (E[i] > PG)
PG = E[i] ;
}
/* Recherche du plus petit */
PP=E[0] ;
for (i=1; i<=9; i++)
{ if (E[i] < PP)
PP = E[i] ;
}
/* Calcul de la moyenne des éléments du tableau*/
Moyenne=E[0] ;
for (i=1; i<=9; i++)
Moyenne = Moyenne + E[i] ;
Moyenne = Moyenne /10 ;
/* Affichage du tableau */
printf("\nLes éléments du tableau sont : ") ;
for (i=0; i<=9; i++)
printf(" %d", E[i]) ;
/* Affichage du plus grand, du plus petit et de la moyenne*/
printf("\nLe plus grand est : %d", PG) ;
printf("\nLe plus petit est : %d", PP) ;
printf("\nLa moyenne est : %f", Moyenne) ;
}

16
 III.2.4. Opération de tri sur un vecteur

Le tri d’un tableau

Le tri est une opération qui consiste à ordonner les éléments contenus dans un tableau
selon un critère d’ordre. Exemple : l’ordre croissant ou décroissant .De nombreux algorithmes
permettent de réaliser cette opération à l’image du tri-bull.

Principe du tri-bull
Soient les entiers suivants contenus dans un tableau :
3 1 24 12 6 7
Le principe du tri-bull est le suivant :
1. parcourir le tableau
2. comparer les éléments consécutifs
3. s’ils sont dans le mauvais ordre, il faut les permuter
4. s’il y a eu au moins une permutation, aller à 1
5. sinon le tableau est trié

Application pour un ordre croissant du tableau précédent

3 1 24 12 6 7
1 3 12 6 7 24 il y a au moins une permutation
1 3 6 7 12 24 il y a au moins une permutation
1 3 6 7 12 24 pas de permutation

Exercice d’application

Ecrire un programme qui lit un tableau de 10 entiers, le trie par ordre croissant et
affiche le tableau trié et non trié.

Données : E un tableau de 10 entiers

Résultats : le tableau E trié

#include<stdio.h>
main()
{ int E[10], PG, PP, I, perm=1, temp ;
/*lecture du tableau */
for (i=0; i<=9; i++)
{ printf("\nEntrer l’élément numéro %d",i) ;
scanf("%d", &E[i]) ;
}
/* Affichage du tableau non trié */
printf("\nLes éléments du tableau sont : ") ;
for (i=0; i<=9; i++)
printf(" %d", E[i]) ;
/*Tri du tableau */
while(perm)
{ perm=0 ;
for (i=0; i<9; i++)
if (E[i] > E[i+1])
{ perm=1 ;
temp= E[i] ;

17
 E[i]=E[i+1] ;
E[i+1]=temp ;
}
}
/* Affichage du tableau trié */
printf("\nLes éléments du tableau sont : ") ;
for (i=0; i<=9; i++)
printf(" %d", E[i]) ;
}

III.3. Les matrices ou tableaux à deux dimensions

III.3.1. Syntaxe de déclaration d’une matrice

Type Nom_Variable [Taille_Max1] [Taille_Max2] ;

Exemple 1 : l’instruction suivante permet de déclarer un tableau de 10x10 entiers

int Tab[10][10] ;

III.3.2. Opérations sur les matrices

Principe standard de parcours d’une matrice

Le parcours des éléments d’une matrice en C se fait en utilisant les indices de ligne et
de colonne. Chaque indice prend des valeurs dans l’intervalle [0, Taille_Max-1].
Exemple 2 :
Tab[0][9] fait référence à l’élément qui est à la première ligne dernière colonne.
Tab[0][0] Tab[0][9]

Tab[7][3] Tab[2][5]

Tab[9][0] Tab[9][9]

Principe standard de lecture des éléments d’une matrice

La lecture des éléments d’une matrice se fait de façon standard en utilisant deux
structures répétitives "for" imbriquées. Dans le cas du parcours des lignes d’abord puis des
colonnes après, le compteur d’entête de la première structure "for" sert d’indice de parcours
des lignes du tableau tandis que le compteur de la deuxième structure "for" permet de
parcourir les colonnes. Cette disposition est inversée dans le cas du parcours des colonnes
d’abord puis des lignes après. Le corps de la deuxième structure "for" comporte au moins
deux instructions, la première qui affiche le message d’indication de la case du tableau à
renseigner et la seconde instruction permet de lire la valeur de cet élément au clavier. Par
exemple, si une matrice de 10x10 d’entiers est déclarée avec l’instruction "int Tab[10][10] ;"

18
avec la déclaration des compteurs Ligne et Colonne par la syntaxe "int Ligne, Colonne ;",
alors les instructions suivantes permettent de lire les éléments de cette matrice :
for (Ligne = 0; Ligne <=9; Ligne ++)
for (Colonne = 0; Colonne <=9; Colonne ++)
{ printf("\nEntrer l’élément Tab[%d, %d] : ", Ligne, Colonne) ;
scanf("%d", &Tab[Ligne][Colonne]) ;
}

Principe standard d’affichage des éléments d’une matrice

L’affichage des éléments d’un vecteur se fait de façon standard également en utilisant
deux structures répétitives "for" imbriquées. Dans le cas du parcours des lignes d’abord puis
des colonnes après, le compteur d’entête de la première structure "for" sert d’indice de
parcours des lignes du tableau tandis que le compteur de la deuxième structure "for" permet
de parcourir les colonnes. Cette disposition est inversée dans le cas du parcours des colonnes
d’abord puis des lignes après. Le corps de la deuxième structure "for" comporte au moins
l’instruction d’affichage d’un message éventuel suivi de la valeur de la case du tableau avec
éventuellement l’utilisation du retour à la ligne à la position voulue par le programmeur. Par
exemple, pour afficher la matrice de l’exemple précédent, les instructions suivantes peuvent
être utilisées :
for (Ligne = 0; Ligne <=9; Ligne ++)
for (Colonne = 0; Colonne <=9; Colonne ++)
printf("\nL’élément Tab[%d, %d] = %d", Ligne, Colonne, Tab[Ligne][Colonne]) ;

III.3.3. Exercice d’application

Soient P, M et N trois matrices carrées d’ordre 2 contenant des entiers. Ecrire un

programme qui permet de calculer la matrice P en utilisant la formule suivante :
P=M+2*N
Méthode de calcul de P :
P(0,0) = M(0,0) + 2 * N(0,0)
P(0,1) = M(0,1) + 2 * N(0,1)
…
Formule générale :
P(i,j) = M(i,j) + 2 * N(i,j)

Données : les matrices carrées d’entiers M et N

Résultats : la matrice P, affichage des matrices M, N et P

#include<stdio.h>
main()
{ int M[3][3] , N[3][3] , P[3][3], i, j ;
char r ;
/*Lecture des éléments de la matrice M*/
for(i=0 ; i<= 2 ; i++)
for(j=0 ; j<= 2 ; j++)
{ printf("\n Entrer l’élément M(%d, %d) : ", i, j);
scanf("%d", &M[i][j]) ;
}

19
/*Lecture des éléments de la matrice N*/
for(i=0 ; i<= 2 ; i++)
for(j=0 ; j<= 2 ; j++)
{ printf("\n Entrer l’élément N(%d, %d) : ", i, j);
scanf("%d", &N[i][j]) ;
}
/*Calcul des éléments de P*/
for(i=0 ; i<= 2 ; i++)
for(j=0 ; j<= 2 ; j++)
P[i][j] = M[i][j] + 2 * N[i][j] ;
/*Affichage des éléments de M*/
printf ("\n Les éléments de M sont:\n") ;
for(i=0 ; i<= 2 ; i++)
{ for(j=0 ; j<= 2 ; j++)
printf(" %d", M[i][j]) ;
printf ("\n");
}
/*Affichage des éléments de N*/
printf ("\n Les éléments de N sont:\n") ;
for(i=0 ; i<= 2 ; i++)
{ for(j=0 ; j<= 2 ; j++)
printf(" %d", N[i][j]) ;
printf ("\n");
}
/*Affichage des éléments de P*/
printf ("\n Les éléments de P sont:\n") ;
for(i=0 ; i<= 2 ; i++)
{ for(j=0 ; j<= 2 ; j++)
printf(" %d", P[i][j]) ;
printf ("\n");
}
scanf("%c", &r) ;
scanf("%c", &r) ;
}

III.4. Exercices sur les vecteurs

1. Soit T un tableau de 50 entiers. Ecrire un programme C qui calcule la moyenne

arithmétique simple des éléments contenus dans T.
2. Soient T1 un tableau de 50 entiers correspondant à des notes sur 20 et T2 comportant des
coefficients associés aux notes de même indice. Ecrire un programme qui calcule la
moyenne arithmétique pondérée des notes de T1.
3. Ecrire un programme qui lit 100 entiers, les stocke en mémoire et affiche le plus petit,
ainsi que son indice.
4. Ecrire un programme qui lit 100 entiers, les stocke en mémoire et affiche l’indice du plus
grand.
5. Ecrire un programme qui lit un entier LIMITE et 100 entiers, les stocke en mémoire et
affiche les entiers qui sont supérieurs ou égaux à LIMITE accompagnés de leurs indices.
6. Refaire le même programme avec les entiers qui sont inférieurs à LIMITE.

20
7. Ecrire un programme qui lit un entier LIMITE et 100 entiers, les stocke en mémoire puis
calcule et affiche la somme des entiers qui sont supérieurs ou égaux à LIMITE.
8. Refaire le même programme avec les entiers qui sont inférieurs à LIMITE.

III.5. Exercices sur les matrices

1. Ecrire un programme qui lit une matrice carrée M d’ordre x<=10 et calcule la matrice N
sa transposée.
2. Reprendre l’exercice précédent sans utilisation de la matrice N.
3. Ecrire un programme qui stocke et affiche dans une matrice, la table de multiplication par
un entier N<=20.
4. Ecrire un programme qui lit un vecteur V de taille TV<=10 et une matrice M de LxC
avec L et C<=30, et affiche les colonnes dont le parcours verticale des lignes contient au
moins une occurrence de V.
5. Ecrire un programme qui lit un vecteur V de taille TV<=10 et une matrice M de LxC
avec L et C<=30, et affiche les lignes dont le parcours horizontal des colonnes contient au
moins une occurrence de V.
6. Ecrire un programme qui lit un vecteur V de taille TV<=10 et une matrice M de LxC
avec L et C<=30, et affiche le nombre d’occurrences de V dans chaque colonne
parcourue de façon verticale.
7. Ecrire un programme qui lit un vecteur V de taille TV<=10 et une matrice M de LxC
avec L et C<=30, et affiche le nombre d’occurrences de V dans chaque ligne parcourue
de façon horizontale.

21
 Chapitre IV. Les structures et les tableaux de
structures

IV.1. Les structures

IV.1.1. Définition

En fonction des problèmes à résoudre, certains traitements nécessitent le stockage de

plusieurs valeurs élémentaires de types différents. Ces valeurs élémentaires regroupées
permettent par exemple de décrire un objet de façon générale qui dispose de plusieurs
propriétés. C’est le cas par exemple de la description d’un étudiant identifié par son numéro
matricule de type entier, son nom et son prénom de type chaine de caractères et son genre de
type caractère avec "M" pour masculin et "F" pour féminin.
Les structures permettent de désigner sous un seul nom de variable, un ensemble de
champs ou propriétés ou attributs qui sont des sous-variables de type différent.

IV.1.2. Syntaxe de déclaration du type

struct nom_de_la_structure Exemple :

{ type1 NomVariable1 ; struct Etud
type2 NomVariable2 ; { int matricule ;
… char nom[50] ;
typeN NomVariableN ; char prenom[50] ;
}; char genre ;
};
Représentation schématique de la structure représentant un étudiant

matricule nom
prenom genre

Cette déclaration crée un modèle, pour l’utiliser, il faut déclarer les variables de ce type.

IV.1.3. Syntaxe de déclaration des variables

1. Syntaxe de déclaration des variables après la déclaration de la structure :

struct nom_de_la_structure NomVariable1, … , NomVariableX ;
Exemple :
struct Etud E, MP ;

2. Syntaxe de déclaration des variables pendant la déclaration de la structure :

struct nom_de_la_structure
{ type1 NomVariable1 ;
…
typeN NomVariableN ;
} NomVariable1, … , NomVariableX ;
Exemple :

22
 struct Etud
{ int matricule ;
char nom[50] ;
char prenom[50] ;
char genre ;
} E, MP ;

E et MP deviennent des variables utilisables par le programmeur.

IV.1.4. Syntaxe d’accès aux champs d’une variable de type structure

Opérateur : "."
Syntaxe :
NomVariable.nomchamp
Exemple :
E.matricule=1 ;
scanf("%s", &E.nom) ;
E.genre= 'F' ;

IV.1.5. Usage de la primitive typedef

La primitive "typedef" permet de créer un alias d’un type. De ce fait, l’alias peut être
utilisé partout à la place du type initial. Par exemple, avec l’instruction "typedef int entier ;"
placée dans la liste des déclarations, "entier" peut dorénavant être utilisé à la place de "int".
Lors du processus de compilation, le pré-compilateur se chargera de remplacer par "int",
toutes les occurrences du mot "entier".
Exemple :
typedef int entier ; ⇒ entier i ; int i ;

La déclaration d’une structure peut elle même être associée à l’usage de la primitive
"typedef" par une déclaration directe ou différée :
- Par usage du modèle de déclaration directe, un alias peut être défini pour éviter le
rappel constant de l’entête de la structure pour toute nouvelle déclaration de variable.
typedef struct nom_de_la_structure
{ type1 NomVariable1 ;
type2 NomVariable2 ;
…
typeN NomVariableN ;
} NomTYPE ;
Exemple : Soit à définir "E" comme nom d’alias de la structure précédente représentant un
étudiant par le modèle de la déclaration directe :
typedef structure Etud
{ int matricule ; char nom[50] ;
char prenom[50] ; char genre ;
}E;
- Par usage du modèle de déclaration différée.
Exemple : Soit à définir "E" comme nom d’alias de la structure précédente représentant un
étudiant par le modèle de déclaration différée :
typedef structure Etud E ;

23
 Quelle que soit l’une des deux formes utilisées par usage de "typedef", les variables
"E3" et "Etudiant3" peuvent être déclarées de la façon suivante après la création du type E :
E E3, Etudiant3 ;

Exercice d’application
Ecrire un programme qui lit et qui affiche les caractéristiques d’un seul étudiant.
#include<stdio.h>
main()
{ /* Déclaration de la structure de données */
typedef struct Etud
{ int matricule ; char nom[50] ;
char prenom[50] ; char genre ;
}E;
E Etudiant ;
/* Lecture des caractéristiques de l’étudiant */
printf("\nEntrer le matricule de l’étudiant :");
scanf("%d", &Etudiant.matricule) ;
printf ("\nEntrer le nom de l’étudiant :");
scanf("%s", &Etudiant.nom) ;
printf ("\nEntrer le prénom de l’étudiant :");
scanf("%s", &Etudiant.prenom) ;
printf("\nEntrer le genre de l’étudiant :");
scanf("%c", &Etudiant.genre) ;
scanf("%c", &Etudiant.genre) ;
/* Affichage des caractéristiques de l’étudiant */
printf("\nLe matricule de l’étudiant est : %d", Etudiant.matricule) ;
printf("\nLe nom de l’étudiant est : %s", Etudiant.nom) ;
printf("\nLe prénom de l’étudiant est : %s", Etudiant.prenom) ;
printf("\nLe genre de l’étudiant est : %c", Etudiant.genre) ;
}

IV.2. Les tableaux de structures

IV.2.1. Définition

Certains problèmes nécessitent le stockage de plusieurs valeurs d’une part, ce qui

nécessite l’utilisation des tableaux, et d’autre part, de regrouper dans chaque case du tableau,
plusieurs champs de types différents, conduisant ainsi à l’usage des structures. L’association
de ces deux parties crée les tableaux de structure. Les tableaux de structure peuvent être
associés à des méta-structures qui regroupent dans une seule variable, plusieurs valeurs de
types différents. C’est le cas par exemple du stockage des informations qui décrivent tous les
étudiants d’une même classe dont l’effectif est connu à priori, sachant que chaque étudiant est
identifié par des propriétés telles que son numéro matricule de type entier, son nom et son
prénom de type chaine de caractères et son genre de type caractère (avec "M" pour masculin
et "F" pour féminin).

24
 IV.2.2. Syntaxe de déclaration d’un tableau de structure

Le tableau de structure est une variable. Il peut donc être déclaré pendant la
déclaration de la structure, après la déclaration de la structure ou après la déclaration du
nouveau type en utilisant la primitive TYPEDEF.
Exemple :
Déclaration du tableau CLASSE de 10 étudiants du type précédent.
Etudiant CLASSE[10] ;

Représentation schématique
matricule nom
CLASSE
0 prenom genre

1
matricule nom

prenom genre

9 matricule nom

prenom genre

IV.2.3. Accès aux champs dans un tableau de structure

Syntaxe :
NomTableau[indice].NomChamp
Exemple :
CLASSE[0].matricule = 11 ;

IV.2.3. Exercice d’application

Ecrire un programme C qui lit et affiche sous forme de liste, tous les étudiants de la
classe précédente
#include<stdio.h>
main()
{ /* Déclaration de la structure de données */
typedef struct Etud
{ int matricule ; char nom[50] ;
char prenom[50] ; char genre ;
}E;
E CLASSE[50] ; int i ;

25
/* SP1 : Lecture des caractéristiques des étudiants */
for(i=0 ; i<50 ; i++)
{ printf("\nEntrer le matricule de l’étudiant No : %d", i+1);
scanf("%d", &CLASSE[i].matricule) ;
printf ("\nEntrer le nom de l’étudiant No : %d", i+1);
scanf("%s", & CLASSE[i].nom) ;
printf ("\nEntrer le prénom de l’étudiant No : %d", i+1);
scanf("%s", & CLASSE[i].prenom) ;
printf("\nEntrer le genre de l’étudiant No : %d", i+1);
scanf("%c", & CLASSE[i].genre) ;
scanf("%c", & CLASSE[i].genre) ;
}
/* SP2 : Affichage en liste des étudiants de la classe */
printf ("\nMatricule Nom prénom Genre");
for(i=0 ; i<50 ; i++)
printf("\n %d %s %s %c", CLASSE[i].matricule,
CLASSE[i].nom,
CLASSE[i].prenom,
CLASSE[i].genre
);
}

IV.3. Exercices sur les structures et les tableaux de structures

1. Une classe est composée de 14 étudiants, chacun étant identifié par un matricule entier,
un nom (40 caractères max), son équipe sportive (30 caractères max). Dans un même
programme C, écrire :
- le code C de la déclaration de la variable qui permet de stocker les étudiants de cette
classe en mémoire.
- le code C qui lit, affiche la liste des étudiants et renvoie la liste des étudiants qui
jouent au football.
2. Une classe est composée de 14 étudiants, chacun étant identifié par un matricule entier,
un nom (40 caractères max), son équipe sportive (30 caractères max). Dans un même
programme C, écrire :
3. Une classe est composée de 20 étudiants identifiés chacun par un matricule entier. Dans
un même programme C :
- Donner la déclaration de la variable qui permet de stocker ces étudiants en mémoire.
- Ecrire le code C qui permet de lire la liste des étudiants
- Ecrire le code C qui permet de trier les étudiants par ordre croissant de matricule et qui
renvoie le matricule le plus élevé.
- Ecrire le code C qui permet d’afficher les matricules sous forme de liste

26
Introduction ............................................................................................................................................. 1
Chapitre I. Notions de base de la programmation .................................................................................. 2
I.1. Le Langage Algorithmique ............................................................................................................. 2
I.1.1. Notion de variable et d’instruction ........................................................................................ 2
I.1.2. L’affectation et les opérateurs arithmétiques disponibles .................................................... 2
I.1.3. L’instruction de lecture .......................................................................................................... 3
I.1.4. L’instruction d’écriture ........................................................................................................... 3
I.1.5. Notion de données et résultats .............................................................................................. 3
I.1.6. Structure générale d’un programme algorithmique .............................................................. 3
I.1.7. Exercices d’application ........................................................................................................... 3
I.2. Le Langage C .................................................................................................................................. 4
I.2.1. Structure générale d’un programme C................................................................................... 4
I.2.2. Notion de variable et d’instruction ........................................................................................ 5
I.2.3. L’affectation et les opérateurs arithmétiques disponibles .................................................... 5
I.2.4. L’instruction de lecture .......................................................................................................... 5
I.2.5. L’instruction d’écriture ........................................................................................................... 6
I.2.6. Exemple d’illustration............................................................................................................. 6
Chapitre II. Les structures de contrôle .................................................................................................... 7
II.1. La structure conditionnelle .......................................................................................................... 7
II.1.1. Définition ............................................................................................................................... 7
II.1.2. Exercice d’application ............................................................................................................ 9
II.1.3. Exercices sur la structure conditionnelle............................................................................. 10
II.2. Les structures de contrôle répétitives ........................................................................................ 10
II.3. La structure répétitive avec compteur ....................................................................................... 10
II.3.1. Définition ............................................................................................................................. 10
II.3.2. Exercice d’application .......................................................................................................... 11
II.3.3. Exercices sur la structure répétitive avec compteur ........................................................... 11
II.4. La structure répétitive conditionnelle ........................................................................................ 12
II.4.1. Définition ............................................................................................................................. 12
II.4.2. Exercice d’application .......................................................................................................... 13
II.4.3. Exercices sur la structure répétitive conditionnelle ............................................................ 13
Chapitre III. Les tableaux ....................................................................................................................... 15
III.1. Définitions ................................................................................................................................. 15
III.2. Les vecteurs ou tableaux à une dimension ............................................................................... 15
III.2.1. Syntaxe de déclaration d’un vecteur .................................................................................. 15
III.2.2. Opérations sur les vecteurs ................................................................................................ 15
III.2.3. Exercice d’application ......................................................................................................... 16
III.2.4. Opération de tri sur un vecteur .......................................................................................... 17
III.3. Les matrices ou tableaux à deux dimensions ............................................................................ 18
III.3.1. Syntaxe de déclaration d’une matrice................................................................................ 18
III.3.2. Opérations sur les matrices ................................................................................................ 18
III.3.3. Exercice d’application ......................................................................................................... 19
III.4. Exercices sur les vecteurs .......................................................................................................... 20
III.5. Exercices sur les matrices .......................................................................................................... 21
Chapitre IV. Les structures et les tableaux de structures ...................................................................... 22
IV.1. Les structures ............................................................................................................................ 22
IV.1.1. Définition............................................................................................................................ 22
IV.1.2. Syntaxe de déclaration du type.......................................................................................... 22
IV.1.3. Syntaxe de déclaration des variables ................................................................................. 22
IV.1.4. Syntaxe d’accès aux champs d’une variable de type structure ......................................... 23
IV.1.5. Usage de la primitive typedef ............................................................................................ 23
IV.2. Les tableaux de structures ........................................................................................................ 24

27
 IV.2.1. Définition............................................................................................................................ 24
IV.2.2. Syntaxe de déclaration d’un tableau de structure ............................................................. 25
IV.2.3. Accès aux champs dans un tableau de structure ............................................................... 25
IV.2.3. Exercice d’application ........................................................................................................ 25
IV.3. Exercices sur les structures et les tableaux de structures ........................................................ 26

28