GENERALITES

INFORMATIQUE: Science de traitement automatique

de l ’information.
Deux disciplines:
•Hardware (Matériel)
•Software (Ensemble de programmes qui exploitent le

matériel. Le système d ’exploitation en fait

une partie essentielle) 1

 SOFTWARE = LOGICIEL
Ensemble de programmes ayant pour fonction de traiter
des informations en entrées pour sortir les résultats désirés.
 Programme: suite d ’instructions exprimées dans un langage
donné.
 Instruction: Ordre ou consigne compréhensible par la machine.
 Langage:Alphabet, vocabulaire, syntaxe et sémantique d ’écriture
des programmes.
 Langage machine: Alphabet = {0,1}
 Compilateur: Programme qui traduit un texte écrit dans un
langage de programmation en un code (sous forme de 0 et 1) qui
directement exécutable par la machine.
2
 HARDWARE = MATERIEL
Ordinateur:Machine électronique programmable pour le traitement
de l’information. Elle peut recevoir des données, (fonction
d'entrée), effectuer sur ces données des opérations de calculs, de
mise en ordre (fonction de traitement) et restituer les résultats
(fonction de sortie).

3
 Mémoire interne
Cmos Rom Ram Mémoire
cache
I Souris
n
CARTE MÈRE t
Horloge Disque
e dur
BUS r
f
Micro a
processeur BUS c Imprimante
e
s
Interfaces Clavier

Modem
Lecteur de disquette
Moniteur
Lecteur de bande Lecteur
optique Scanner

schéma simplifié du micro-ordinateur

4
L'unité centrale: elle se présente sous la forme
d'un boîtier métallique dont le fond est occupé par
un circuit imprimé d'assez grande taille (carte
mère) sur laquelle sont enfichés des composants
électroniques.

la mémoire interne : c'est un dispositif matériel

capable d'enregistrer, de conserver (du moins
pendant un certain laps de temps) et de restituer
(par lecture de son contenu) des informations.
Il y en a deux types:RAM et ROM
5
• RAM: random access memory
C'est une mémoire où l'on peut enregistrer et effacer les
informations à volonté; en conséquence le contenu est
modifiable en permanence. C'est une mémoire adressable,
c'est-à-dire qu'il est possible de localiser chaque emplacement
utilisé pour stocker les informations par une adresse.
• ROM ( read only memory )
La mémoire ROM contient un programme le BIOS
(basic input output system) qui s’active au démarrage
de la machine. Il fait référence à tous les réglages de
base concernant la carte mère et contrôle également le
processus de démarrage de la machine. 6
La mémoire cache:
C’est un dispositif qui permet de conserver des informations
dont le micro-processeur a besoin plusieurs fois de suite. La
mémoire cache ayant un temps d’accès plus rapide que la
RAM, le micro-processeur mettra moins de temps à
rechercher une information dans la mémoire cache que dans
la RAM.
Le microprocesseur:
Le microprocesseur est le cœur du micro-ordinateur.
C ’est une puce qui permet de traiter, de gérer et de
faire circuler l’information. De ses capacités et de sa
vitesse dépendent les performances du PC. 7
l'horloge:
Sa vitesse s’exprime en MEGA HERTZ. Cette unité de
mesure désigne un nombre de vibrations par seconde. Un
MHZ correspond à 1 million de cycles / seconde.

L’horloge du processeur et de tous les autres composants

de la carte mère donne le rythme de l’ordinateur. Le
processeur exécute une instruction à l’intérieur d’un
cycle. La vitesse de l’horloge influe directement sur la
rapidité du travail du microprocesseur.

8
Les bus :
A l’intérieur de l’ordinateur, les différentes données
transitent sur des groupes de conducteurs parallèles que l’on
appelle des bus.
• bus de données : pour le transfert des données. Celles qui
transitent entre le processeur et la mémoire centrale
utilisent un bus nommé bus système.
• bus de contrôle : qui transmettent des signaux
spécifiques à tous les modules avec lesquels le processeur
est en relation.
• bus d’adresse : qui contient les adresses des données.
9
Les interfaces : elles se présentent sous la
forme de prises permettant de raccorder l’unité
centrale avec les périphériques.
Les périphériques : outils de communication
entre l’unité centrale et l’utilisateur, les
périphériques permettent :
• l’entrée des informations dans la mémoire de
l’unité centrale : clavier, souris, scanner etc...
• la sortie des résultats de la mémoire de
l’ordinateur : imprimante, écran
• le stockage d’informations : disquettes, disques
durs, etc... 10
 LE SYSTEME D'EXPLOITATION
Pour utiliser un ordinateur, il est nécessaire de disposer
de "PROGRAMMES" :
• Traitement de texte (WORD),
• Un tableur (EXCEL),
• Un SGBDR (ACCESS),
• etc…
Mais des logiciels - progiciels - logiciels outils ne
suffissent pas:
Sans système d’exploitation, un ordinateur ne
peut fonctionner. 11
 Rôle du système d'exploitation
• Gestion des entrées-sorties :Contrôle du flux
d’informations entre mémoire centrale et périphériques.
• Gestion des fichiers : Copier, supprimer ou renommer
un fichier (Unité de stockage d ’informations dans le système).
• Gestion des supports : les préparer, afficher leurs
catalogues, analyser leurs états.
• Gestion des travaux confiés à l'ordinateur :
Stockage des programmes en mémoire centrale et contrôle de
leur exécution.
• Communication homme - machine : l’interface
qui permet à l’utilisateur de communiquer avec le système à
l’aide de commandes. L’interface peut être textuel ou graphique
12
 Classement des systèmes d'exploitation
• Mono-poste mono-tâche : MS-DOS de MICROSOFT.
Un homme - une machine - une application.
• Multi-tâches mono-poste : WINDOWS NT
Workstation - OS/2 WARP D’IBM - WINDOWS 95.
Partage des ressources entre plusieurs programmes se déroulant en
apparence en même temps.
• Multi-postes multi-tâches : NETWARE DE NOVELL -
WINDOWS NT Server - UNIX.
Connexion simultanée à une même UC de plusieurs postes.
• Multi-postes multi-tâches avec des terminaux
passifs : UNIX.
Un terminal passif est un poste de travail composé uniquement d’un
13
écran et d’un clavier.
 ALGORITHMIQUE
Un ordinateur exécute automatiquement une série
d'opérations simples qu'on lui a demandé de faire.
Son intérêt est sa grande capacité de traitement de
l’information:
• Mémoriser des quantités numériques ou
alphabétiques,
• Rechercher une quantité mémorisée,
• Comparer ou classer des informations, ....
14
Pour résoudre un problème à l'aide d'un ordinateur,
il faut:
• Analyser ce problème: définir avec précision les
résultats, les informations dont on dispose, ...
• Déterminer les méthodes de résolution: il s'agit
de déterminer la suite des opérations à effectuer.
• Formuler l'algorithme définitif: exprimer la
suite d ’opérations dans un formalisme adéquat.
• Traduire l'algorithme dans un langage de
programmation adapté.
15
 Définition de l ’algorithme
Un algorithme est une suite finie de règles
à appliquer dans un ordre déterminé à un
nombre fini de données pour arriver, en
un nombre fini d'étapes, à un certain
résultat, et cela indépendamment des
données.
16
Exemple: Calcul de l'intérêt et de la valeur
acquise par une somme placée pendant un an à
intérêt simple.
• les données fournies: deux nombres représentant
les valeurs de la somme placée et du taux d'intérêt
• les résultats désirés: deux nombres représentant
l'intérêt fourni par la somme placée ainsi que la
valeur obtenue après placement d'un an.
• Le processus de transformation: multiplier la
somme par le taux d'intérêt divisé par cent; la
valeur acquise s'obtient en additionnant ce dernier
montant et la somme initiale 17
• Formalisation de l'algorithme :
Début
écrire (" Introduisez la somme initiale :") ;
lire (somme_initiale) ;
écrire (" Introduisez le taux d'intérêt : ") ;
lire (taux);
interet <-- somme_initiale * taux / 100 ;
valeur_acquise <-- somme_initiale + interet ;
écrire (" L'intérêt fourni est de " , interet , "DHs") ;
écrire (" La somme après un an sera de " , valeur_acquise ," DHs") ;
Fin

18
 Elaboration d ’un bon algorithme
Méthode descendante :
• préciser les données fournies et les résultats à
obtenir
• décomposer le problème en plusieurs sous-
problèmes plus simples qui seront traités
séparément et éventuellement décomposés
eux-mêmes de manière plus fine.

19
Exemple: imaginons un robot domestique à qui
nous devons fournir un algorithme lui
permettant de préparer une tasse de café soluble.
• Première version:
(1) faire bouillir de l'eau
(2) mettre le café dans la tasse
(3) ajouter l'eau dans la tasse
Pas assez détaillées pour que le robot puisse les
interpréter
Chaque étape doit donc être affinée 20
(1) faire bouillir l'eau peut être affinée en :
(1.1) remplir la bouilloire d'eau
(1.2) brancher la bouilloire sur le secteur
(1.3) attendre l'ébullition
(1.4) débrancher la bouilloire
(2) mettre le café dans la tasse est affinée en :
(2.1) ouvrir le pot à café
(2.2) prendre une cuiller à café
(2.3) plonger la cuiller dans le pot
(2.4) verser le contenu de la cuiller dans la tasse
21
(2.5) fermer le pot à café
(3) ajouter de l'eau dans la tasse pourrait être
affinée en :
(3.1) verser de l'eau dans la tasse jusqu'à ce que celle-
ci soit pleine
Certaines étapes étant encore trop complexes, il
faut les affiner davantage.
(1.1) remplir la bouilloire d'eau en :
(1.1.1) mettre la bouilloire sous le robinet
(1.1.2) ouvrir le robinet
(1.1.3) attendre que la bouilloire soit pleine
(1.1.4) fermer le robinet
22
 LA SEQUENCE

Langage de description
 les instructions de lecture (d'entrée) notées:
lire (variables)
indiquant la saisie des données
exemples:
lire (somme_initiale);
lire (taux);
23
 les instructions d'écriture (de sortie) :
écrire (expression)
indiquant l'affichage d'un message
et/ou du contenu d'une variable (ou
du résultat d'un calcul)
exemples:
écrire (" Introduisez la somme
initiale:");
écrire (" L'intérêt fourni est de "
, intérêt, "DHs");
écrire (intérêt);
écrire (a, b, (a+b)/2); 24
 les instructions d'assignation (d'affectation)
représentées par
variable <-- expression;
exemple:
intérêt <--somme-initiale*taux/100;
a <-- 0;
i <-- i + 1;
Les expressions sont des formules mathématiques
symbolisant des opérations sur des variables et/ou
des constantes numériques.
25
– Les variables y sont représentées par un
identificateur (un nom).
– les constantes sont des nombres écrits en chiffres.
– Les opérations sur des nombres sont représentées
par +, -, *, /.
– D'autres fonctions mathématiques usuelles sont
couramment utilisées: ln x, sin x, arctg x, [x] , a
mod b , xy, loga x , ...

26
– Mais l'ordinateur peut également manipuler des
variables contenant des chaînes de caractères.
– Ces chaînes de caractères sont entre guillemets
pour les distinguer des noms de variables.
– L'opération de concaténation de 2 chaînes est
symbolisée par // séparant les 2 chaînes.
– La fonction d'extraction de sous-chaîne est
représentée par le nom de la variable avec en
indice les positions des lettres à extraire.
Exemple : prénom2<--4 .
– la fonction qui fournit la longueur de la chaîne
contenue dans la variable prénom est |prénom| 27
 Exemples
Exprimer un nombre de secondes sous forme
d'heures, minutes, secondes:
Début
écrire (" Introduisez le nombre de secondes");
lire nsec;
s <-- nsec mod 60;
m <-- (nsec div 60) mod 60;
h <-- nsec div 3600;
écrire (nsec, "valent: ", h, "heure(s) ", m, "minute(s) et", s,
"seconde(s)");
Fin
28
Transformer un prénom et un nom en une chaîne
contenant l'initiale du prénom séparée du nom par
un point
Début
écrire ("Quel est votre prénom? ");
lire (prénom);
écrire ("et votre nom?");
lire (nom);
pr <-- prénom1;
lpr <-- |prénom|;
ident <-- pr // "." // nom;
écrire ("Votre prénom de", lpr, "lettres a été
abrégé et votre identification est : ",
ident);
Fin 29
 Déclaratives
– Il faut préciser ce que les variables utilisées
contiendront comme type de données.
– Il peut s'agir de nombres entiers, de nombres
réels, de chaînes de caractères, ...
• La partie déclarative est placée en tête de
l'algorithme et regroupe une ou plusieurs
indications de la forme:
entier variables;
ou
réel variables; 30
L'algorithme complété de l'exemple 1 devient:
entier nsec, h, m, s;
Début
écrire ("Introduisez le nombre de
secondes:");
lire (nsec);
s <-- nsec mod 60;
m <-- (nsec div 60) mod 60;
h <-- nsec div 3600;
écrire (nsec, "valent: ", h,
"heure(s)", m, "minute(s) et", s,
"seconde(s)");
Fin
31
Et l'algorithme de l'exemple 2:
Caractère pr;
entier lpr;
chaîne prénom, nom, ident;
Début
écrire ("Quel est votre prénom?");
lire (prénom);
écrire ("et votre nom?");
lire (nom);
pr <-- prénom1;
lpr <-- |prénom|;
ident <-- pr // "." // nom;
écrire ("Votre prénom de", lpr, "lettres a
été abrégé et votre identification est :
",ident);
Fin
32
 Manipulation de nombres
Il y a deux types de nombres: les types
entier et réel :
• Le type entier.
En LDA, nous placerons dans la déclaration des
variables une ligne telle que:
entier age, note_de_français;
En C on a subdivisé les entiers en 3 types pour
mieux adapter le type aux valeurs que peuvent
prendre une variable: short int, int et long int 33
• Le type réel.
En LDA, nous placerons dans la déclaration des
variables une ligne telle que:
réel taux_de_TVA, note_moyenne;
En C on a subdivisé les réels en 3 types pour
mieux adapter le type aux valeurs que peuvent
prendre une variable, et ce pour optimiser
l'occupation de la mémoire: float, double et
long double
34
• Evaluation des expressions arithmétiques.
Les opérateurs (* / DIV et MOD) sont plus
prioritaires que les opérateurs (+ et -).
lorsqu'une expression contient des opérateurs de
même priorité, les opérations sont effectuées de
gauche à droite.
Pour modifier cet ordre, il suffit d'introduire des
parenthèses.
Exemple: Ecrire(1/2*3); n'affichera pas la
valeur de 1/6 mais bien de 3/2 car la division se
35
fera avant la multiplication.
 Fonctions Mathématiques
Fonction Type de x Type du résultat Signification
ABS(x) Entier ou réel Type de x Valeur absolue de x
SQR(x) Entier ou réel Type de x Carrée de x
SQRT(x) Entier ou réel Réel Racine carrée de x
SIN(x) Entier ou réel Réel sin de x (x en radians)
COS(x) Entier ou réel Réel cos de x (x en radians)
Angle (en radians) dont la
ARCTAN(x) Entier ou réel Réel
tangente vaut x
EXP(x) Réel Réel Exponentielle de x
LN(x) Réel Réel Logarithme népérien de x
TRUNC(x) Réel Entier Partie entière de x
INT(x) Réel Réel Partie entière de x
ROUND(x) Réel Entier Entier le plus proche
36
de x
 Manipulation de chaînes de caractères.
Il existe deux types de variables alphanumériques:
les caractère et chaîne.
• Le type caractère.
Réservé aux variables contenant un seul caractère
(lettre, symbole, ponctuation, ...)
Les caractères sont codés sur un octet. Ce code
porte le nom de code ASCII (American Standard
Code for Information Interchange) et respecte,
entre autres, l'ordre alphabétique.
Exemple : 'A' a pour code ASCII 65.
37
En LDA, nous placerons dans la déclaration des
variables une ligne telle que:
caractère lettre, initiale;
• Le type chaîne.
Les variables du type chaîne peuvent contenir:
– soit une suite de caractères (un mot, une phrase)
– soit un caractère ,
– soit aucun caractère (on parle de chaîne vide).

38
En LDA, nous placerons dans la déclaration des
variables une ligne telle que:
chaîne nom, adresse;
On peut aussi préciser la taille maximale :
Chaîne(20) nom;
Chaîne(40) adresse;
En l'absence de précision de longueur, il y a
réservation automatiquement de la taille
maximale, à savoir 255 caractères.

39
 Les fonctions alphanumériques

Type du
Fonction Signification
résultat
longeur(Ch) Entier Nombre de caractères dans Ch
CONCAT(Ch1,Ch2) Chaîne Concaténation (juxtaposition) de Ch1 et Ch2
Extraction, dans Ch, de n caractères de la postion
COPIE(Ch, i, n) Chaîne
i à la position j

COPIE(Ch, i, 1) Chaîne
Extraction, dans Ch, du caractère à la postion i
Ch[i] Caractère

40
 L'ALTERNATIVE.
 La structure d ’alternative
Voici les règles d'un jeu très simple: deux joueurs
A et B se cachent la main droite derrière le dos.
Chacun choisit de tendre un certain nombre de
doigts (de 0 à 5), toujours derrière le dos.
Les deux joueurs se montrent la main droite en
même temps.
Si la somme des nombres de doigts montrés est
paire, le premier joueur a gagné, sinon c'est le
41
second.
En LDA, l'algorithme s'écrira:
entier na,nb,reste;
Début
écrire ("Entrer les nombres de doigts tendus par
les joueurs A et B");
lire (na , nb);
reste <-- (na + nb) mod 2;
si (reste = 0) alors
écrire ("Le joueur A a gagné");
sinon écrire("Le joueur B a gagné");
fsi
écrire ("Bravo pour le gagnant!");
Fin 42
• La structure alternative se présente sous la forme:
si (expression)alors première séquence
d'instructions
sinon deuxième séquence d'instructions
fsi
Si l'expression est vraie, la première séquence
d'instruction sera exécutée; si l'expression est
fausse, seule la seconde séquence d'instructions sera
effectuée.

43
• Dans certains cas, lorsque l'expression est
fausse, aucune instruction ne doit être exécutée. La
condition s'exprime alors plus simplement sous la
forme:
si (expression) alors séquence d'instructions
fsi
• Chacune des séquences d'instructions d'un
si ... fsi peut contenir des si...fsi. On dit alors que
les structures sont imbriquées.

44
• Exemple avec indentation du texte de l'algorithme:
si (a > 0) alors si (b > 0) alors c <-- a+b;
sinon c <-- a-b;
fsi
fsi
Ou
si (a > 0) alors si (b > 0) alors c <-- a+b;
fsi
sinon c <-- a-b;
fsi
Dans la première forme, si a est négatif, aucun
traitement n'est effectué et dans la seconde si a est
négatif, c vaut a-b. 45
 Expressions logiques
Les expressions logiques se construisent à partir
d'affirmations qui sont soit vraies soit fausses.
Une condition telle que "reste=0" n'aura la valeur
"vrai" que si la variable reste a été assignée à 0.
Dans les autres cas, cette condition prendra la
valeur "faux".
On peut combiner des affirmations à l'aide
d'opérateurs logiques ,à savoir: ou, et et non
46
• Par définition:
op1ou op2 n'a la valeur faux que si les deux
opérandes ont la valeur faux, sinon l'expression a
la valeur vrai.
op1et op2 n'a la valeur vrai que si les deux
opérandes ont la valeur vrai, sinon l'expression a
la valeur faux.
non opérande a la valeur vrai si l'opérande a la
valeur faux et inversement
47
• Supposons par exemple qu'on exécute les
assignations suivantes:
a <-- 1
a <-- 1
b <-- 2
c <-- 3
(b > 8) ou (c < 1) a la valeur faux
(b > a) et (c > b) a la valeur vrai
non (c < a) a la valeur vrai
non ((b > a) et (c > b)) a la valeur faux
((b > a) et (c > b)) ou (a < 0) a la valeur vrai

48
 Variables booléennes
Il est possible de stocker la valeur d'une expression
logique dans une variable.
Cette variable ne peut prendre que les valeurs vrai
et faux.
Ces variables sont appelées variables logiques ou
booléennes.
En LDA, elles se déclarent comme ceci:
booléen OK, pair ;

49
 Le choix multiple
Supposons que l'on veuille demander à l'utilisateur
de choisir dans un menu une de 3 possibilités.
C ’est un choix multiple qui s'écrit en LDA:
entier i;
Début
lire (i);
selon que i vaut
1 faire bloc1
2 faire bloc2
3 faire bloc3
autrement écrire ("Mauvais choix");
fselon
Fin
50
• La structure de choix multiple a pour forme
selon que expression vaut
const1 faire séquence1 d'instructions
const2 faire séquence2 d'instructions
...
constN faire séquenceN d'instructions
autrement séquenceN+1 d'instructions
fselon
Si expression est égale à la ième constante, la i ème
séquence d'instructions est exécutée puis il y a
51
passage aux instructions qui suivent le mot fselon
Si expression n’est égale à aucune constante, on
exécute dans la séquence d'instructions qui suit le
mot autrement .
La clause autrement est optionnel:
selon que expression vaut
const1 faire séquence1 d'instructions
const2 faire séquence2 d'instructions
...
constN faire séquenceN d'instructions
fselon 52
• STRUCTURES REPETITIVES
L'intérêt d'utiliser un ordinateur n'apparaît clairement
que lors de la manipulation de données nombreuses
ou traitées de manière répétitive.
Exemple 1: Chercher dans une liste de noms et
d'adresses, l'adresse d'une personne à partir de son
nom. Le nombre de fois qu'il faudra comparer le nom
donné aux noms de la liste est dans ce cas inconnu.
Exemple 2 : Calculer la N ème puissance entière
d'un nombre x par multiplications successives du
nombre par lui-même. Ici, le nombre de répétition
(N) de l'instruction de multiplication est connu. 53
Plusieurs structures de répétition, chacune bien adaptée à
des circonstances particulières. Ce sont les boucles tant
que, répéter ... jusqu'à et pour.
•La boucle " tant que " : Résolvons l’exemple 1
lire (nom_donné);
i <-- 1;
lire nom(i) ;
tant que NOT ((nom(i) = nom_donné) ou (fin de liste)) faire
i <-- i+1;
lire nom(i); ftant
si (nom(i) = nom_donné) alors écrire (adresse(i)); sinon écrire ("Le
nom demandé ne se trouve pas dans la liste."); fsi 54
Une boucle "tant que" se présente donc comme
suit:
tant que (expression logique) faire
séquence d'instructions
ftant
En premier lieu, l'expression logique est évaluée :
si sa valeur est vrai, le corps de la boucle est
exécuté puis l'expression logique est réévaluée.
si elle a la valeur faux, on exécute l'instruction qui
suit ftant. 55
Calcul du PGCD de deux entiers:
entier m,n,a,b,r,PGCD;
Début
lire (m, n);
a <-- m ;
b <-- n ;
tant que (NOT(b = 0)) faire
r <-- a mod b;
a <-- b ;
b <-- r; ftant
PGCD <-- a;
écrire ("Le PGCD de",m,"et",n,"est",PGCD);
Fin
56
•La boucle " pour"
En utilisant tant que une boucle "pour" est
entier N, i ;réel x, puiss ; d'un emploi plus simple:
Début entier N, i; réel x, puiss;
lire (N, x ); Début
puiss <-- 1; lire N, x;
i <-- 1 ; puiss <-- 1;
tant que (NOT(i > N)) faire pour i de 1 à N faire
puiss <-- puiss * x; puiss <-- puiss * x;
i <-- i + 1; ftant fpour
écrire ("La puissance",N,"ème écrire ("La puissance",N,"ème
de",x,"est",puiss); de",x,"est",puiss );
Fin Fin
La variable de contrôle (i dans l’exemle) est
initialisée à la première valeur.
Avant chaque exécution du corps de la boucle, la
valeur de la variable de contrôle est comparée à la
valeur finale.
Si la variable de contrôle ne dépasse pas cette
valeur, on exécute le corps de la boucle,
sinon on passe à l'instruction qui suit le mot fpour.
Après chaque exécution du corps de la boucle, la
variable de contrôle est augmentée d'une unité.
58
•La boucle " répéter ... jusqu'à "
Comme la boucle "tant que", ce type de répétitive
est utilisé lorsque le nombre de fois que la
séquence d'instructions à répéter est inconnu au
moment où cette séquence est abordée pour la
première fois mais le corps de la boucle est
toujours exécuté au moins une fois.
Sa formulation générale est:
répéter
séquence d'instructions
59
jusqu'à (expression logique)
L'expression logique est évaluée aprés l'exécution
du corps de la boucle:
si sa valeur est faux, le corps de la boucle est
exécuté à nouveau puis l'expression logique est
réévaluée.
Si elle a la valeur vrai, on exécute l'instruction qui
suit jusqu'à

60
entier m,n,a,b,r,PGCD;
Début
lire (m, n);
a <--- m ;
b <--- n ;
répéter
reste <--- a mod b;
a <--- b;
b <--- reste;
jusqu’à ce que (reste=0);
PGCD <--- a;
écrire ("Le PGCD de",m,"et",n,"est",PGCD);
fin
61
Pourquoi les tableaux ?
Imaginons que l’on veuille calculer la moyenne des notes d’une
promotion, quel
algortihme allons nous utiliser ?
Pour l’instant on pourrait avoir la procédure suivante :
entier somme, nbEleves, uneNote, i;
Début
somme <--- 0;
écrire("Nombre d’eleves :");
lire(nbEleves);
pour i de 1 à nbEleves faire
écrire("Note de l’eleve numero ",i," : ");
lire(uneNote);
somme <--- somme + uneNote;
fpour
écrire("La moyenne est de :",somme/nbEleves);
62
Fin
Pourquoi les tableaux ?
Imaginons que l’on veuille toujours calculer la moyenne des notes d’une
promotion mais
en gardant en mémoire toutes les notes des étudiants (pour par exemple faire
d’autres
calculs tels que l’écart type, la note minimale, la note maximale, etc.)
Il faudrait alors déclarer autant de variables qu’il y a d’étudiants, par exemple en
supposant qu’il y ait 3 étudiants, on aurait la procédure suivante :
réel somme, note1, note2, note3 ;
début
écrire("Les notes des trois étudiants :");
lire(note1) ;
lire(note2) ;
lire(note3);
Somme <---note1+note2+note3;
écrire("La moyenne est de :",somme/3);
fin 63
Pourquoi les tableaux ?
Le problème est que cet algorithme ne fonctionne
que pour 3 étudiants
Si on en a 10, il faut déclarer 10 variables
Si on en a n, il faut déclarer n variables
. . . ce n’est pas réaliste
Il faudrait pouvoir par l’intermédiaire d’une seule
variable stocker plusieurs valeurs de même type
. . . c’est le rôle des tableaux

64
Les tableaux à une dimension...
C’est ce que l’on nomme un type complexe (en opposition aux
types simples vus précédemment)
Pour déclarer un tableau il faut préciser:
• Le nombre d’éléments maximal que peut contenir le tableau
• le type des éléments que peut contenir le tableau
La syntaxe de déclaration est la suivante:
Type identificateur[nbmax];
Par exemple un tableau d’entiers de taille 10 est déclaré:
entier Tab[10];
Un tableau contenat les notes de 20 étudiants est déclaré:
Réel Notes[20];

65
Les tableaux à une dimension...
On accède (en lecture ou en écriture) à la i ème valeur d’un tableau en
utilisant la syntaxe suivante :
nom de la variable[indice] avec 0 comme indice de la première valeur
Par exemple si tab est un tableau de 10 entiers (entier Tab[10])
tab[2] <--- -5;
met la valeur -5 dans la 3 ème case du tableau
En considérant le cas où a est une variable de type Entier
a <--- tab[5];
met la valeur de la 6 ème case du tableau tab dans a
lire(tab[0]);
met l’entier saisi par l’utilisateur dans la première case du tableau
écrire(tab[0]);
affiche la valeur de la première case du tableau
66
Exemple...
Ecrire un algorithme permettant d’afficher les notes
d’une promotion, notes saisies par un l’enseignant :
L’analyse descendante de ce problème dit qu’il faut des
opérations pour :
Demander à l’enseignant quel est le nombre d’étudiants
Demander à l’enseignant les notes des étudiants
Calculer la moyenne des notes
Afficher la moyenne des notes

67
Constante MAX = 100;
Réel lesNotes[MAX], somme;
Entier nb,i ;
Début
répéter
écrire("Nombre d’élèves (compris entre 1 et",MAX,") :");
lire(nb);
jusqu’à ce que (nb>=1 et nb<=MAX);
Somme <--- 0;
pour i de 0 à nb-1 faire
écrire("Note de l’étudiant numéro ",i," : ");
lire(lesNotes[i]);
somme <---somme+lesNotes[i];
Fpour
écrire("La moyenne de la promotion est de :", somme/nb);
Fin

68
Les tableaux à deux dimensions...
On peut aussi avoir des tableaux à deux dimensions (permettant
ainsi de représenter par exemple des matrices à deux dimensions)
On déclare une matrice à deux dimensions de la façon suivante :
Type Tableau[nblignes][nbcolonnes]
On accède (en lecture ou en écriture) à la i+1 ème ,j+1 ème valeur
du tableau en utilisant la syntaxe suivante :
Tableau[i][j]
Tableau[0][j] est la valeur de la première ligne et la j ème colonne
Tableau[i][0] est la valeur de la i ème ligne et la première colonne

69
Les tableaux à deux dimensions...
Par exemple si tab est défini par :
Réel Tab[3][2]
tab[2][1] <--- -1.2;
met la valeur -1.2 dans la case 2,1 du tableau
En considérant le cas où a est une variable de type Réel,
a <--- tab[2][1];
met -1.2 dans a
0 1
0 7.2 5.4
1 -1.2 2
2 4 -8.5

70
 Tri d’un tableau
Combien de fois en tant que developpeur a-t-on
besoin de ranger des valeurs dans un ordre
donné ? C’est inimaginable. Aussi, plutôt qu’avoir
à réinventer à chaque fois la roue, vaut-il mieux
avoir assimilé une ou deux techniques solidement
éprouvées, même si elles paraissent un peu ardues
au départ.

Il existe plusieurs stratégies possibles pour trier les

éléments d’un tableau ; nous en verrons deux : le
tri par insertion, et le tri à bulles.

71
1. Tri par insertion
Admettons que le but de la manœuvre soit de trier un tableau
de 12 éléments dans l’ordre croissant. La technique du
tri par sélection est la suivante : on met en bonne
position l’élément numéro 1, c’est-à-dire le plus petit.
Puis en met en bonne position l’élément suivant. Et ainsi
de suite jusqu’au dernier. Par exemple, si l’on part de :

45 122 12 3 21 78 64 53 89 28 84 46
On commence par rechercher, parmi les 12 valeurs, quel est
le plus petit élément , et où il se trouve. On l’identifie en
quatrième position (c’est le nombre 3), et on l’échange
alors avec le premier élément (le nombre 45). Le tableau
devient ainsi :

3 122 12 45 21 78 64 53 89 28 84 46
72
On recommence à chercher le plus petit élément, mais cette
fois, seulement à partir du deuxième (puisque le premier est
maintenant correct, on n’y touche plus). On le trouve en
troisième position (c’est le nombre 12). On échange donc le
deuxième avec le troisième :
3 12 122 45 21 78 64 53 89 28 84 46

On recommence à chercher le plus petit élément à partir du

troisième (puisque les deux premiers sont maintenant bien
placés), et on le place correctement, en l’échangeant, ce qui
donnera in fine :

3 12 21 45 122 78 64 53 89 28 84 46
Et cetera, et cetera, jusqu’à l’avant dernier.

73
En bon français nous pourrions décrire le processus
de la manière suivante :

• Boucle principale : prenons comme point de

départ le premier élément, puis le second, etc,
jusqu’à l’avant dernier.
• Boucle secondaire : à partir de ce point de départ
mouvant, recherchons jusqu’à la fin du tableau
quel est le plus petit élément. Une fois que nous
l’avons trouvé, nous l’échangeons avec le point de
départ.
Cela s’écrit :
74
Pour i de 0 à 10 /*boucle principale : le point de départ se
décale à chaque tour*/
posmini ← i ;/* on considère provisoirement que t(i) est le

plus petit élément*/

Pour j de i + 1 à 11 /*on examine tous les éléments
suivants*/
Si (t(j) < t(posmini)) Alors
posmini ← j;
Fsi
Fpour
/*A cet endroit, on sait maintenant où est le plus petit
élément. Il ne reste plus qu'à effectuer la permutation.*/
temp ← t(posmini);
t(posmini) ← t(i);
t(i) ← temp ;
Fpour 75
2. la recherche dans un tableau
Le flag, en anglais, est un petit drapeau, qui va rester baissé aussi
longtemps que l’événement attendu ne se produit pas. Et,
aussitôt que cet événement a lieu, le petit drapeau se lève (la
variable booléenne change de valeur). Ainsi, la valeur finale
de la variable booléenne permet au programmeur de savoir
si l’événement a eu lieu ou non.

Tout ceci peut vous sembler un peu fumeux, mais cela

devrait s’éclairer à l’aide d’un exemple extrêmement
fréquent : la recherche de l’occurrence d’une valeur dans un
tableau. On en profitera au passage pour corriger une erreur
particulièrement fréquente chez le programmeur débutant.

76
Soit un tableau comportant, disons, 20 valeurs. On doit écrire un algorithme
saisissant un nombre au clavier, et qui informe l’utilisateur de la
présence ou de l’absence de la valeur saisie dans le tableau.
Et voilà le programmeur raisonnant hâtivement qui se vautre en
écrivant :
réel Tab(20);
réel N ;
entier i;
Début
Ecrire ("Entrez la valeur à rechercher");
Lire (N);
Pour i de 0 à 19
Si (N = Tab(i)) Alors
Ecrire (N, "fait partie du tableau");
Sinon
Ecrire (N, "ne fait pas partie du tableau");
FSi
Fpour
Fin

77
Il suffit d'ailleurs de le faire tourner mentalement pour
s'en rendre compte. De deux choses l'une : ou bien la
valeur N figure dans le tableau, ou bien elle n'y
figure pas. Mais dans tous les cas, l'algorithme ne
doit produire qu'une seule réponse, quel que soit
le nombre d'éléments que compte le tableau. Or,
l'algorithme ci-dessus envoie à l'écran autant de
messages qu'il y a de valeurs dans le tableau, en
l'occurrence pas moins de 20 !
Il y a donc une erreur manifeste de conception :
l'écriture du message ne peut se trouver à
l'intérieur de la boucle : elle doit figurer à
l'extérieur. On sait si la valeur était dans le tableau
ou non uniquement lorsque le balayage du
tableau est entièrement accompli.
78
l'algorithme complet – et juste ! – donne :
réel Tab(20);
réel N;
entier i;
Début
Ecrire ("Entrez la valeur à rechercher");
Lire (N);
Trouvé ← Faux;
Pour i de 0 à 19
Si (N = Tab(i)) Alors
Trouvé ← Vrai;
FSi
Fpour
Si Trouvé Alors
Ecrire (N, "fait partie du tableau");
Sinon
Ecrire (N, "ne fait pas partie du tableau");
Fsi
Fin 79
3. Tri à bulles
L’idée de départ du tri à bulles consiste à se dire
qu’un tableau trié en ordre croissant, c’est un
tableau dans lequel tout élément est plus petit
que celui qui le suit.
En effet, prenons chaque élément d’un tableau, et
comparons-le avec l’élément qui le suit. Si
l’ordre n’est pas bon, on permute ces deux
éléments. Et on recommence jusqu’à ce que l’on
n’ait plus aucune permutation à effectuer. Les
éléments les plus grands « remontent » ainsi peu
à peu vers les dernières places.

80
Nous utiliserons un flag Yapermute, c’est une variable
booléenne qui va nous indiquer si nous venons ou non de
procéder à une permutation au cours du dernier balayage
du tableau (dans le cas contraire, c’est signe que le tableau
est trié, et donc qu’on peut arrêter la machine à bulles).
La solution complète donne donc :
Yapermut ← Vrai;
TantQue (Yapermut)
Yapermut ← Faux;
Pour i de 0 à 10
Si t(i) > t(i+1) alors
temp ← t(i);
t(i) ← t(i+1);
t(i+1) ← temp;
Yapermut ← Vrai;
Fsi
Fpour
FTant

81