Cours TD

i
Dédicace
A la mémoire,
de feu Rouam-Serik Wahbi, mon cher ami.
ii
Avant-propos
Ce document représente le cours d’informatique 1 dispensé aux étudiants de
la première année licence académique de l’institut de maintenance et de sécurité
industrielle toutes spécialités confondues. Il sert à donner à ces étudiants les
éléments de base de l’informatique, tels que : Le codage de l’information, Les
algorithmes, etc. Ce module se répartis sur un volet cours magistral et des travaux
dirigés pour permettre à ces étudiants de bien cernés les notions vues au cours,
pendant le premier semestre. Durant le deuxième semestre, on continue de voir
des notions d’informatiques plus avancées, qu’on étale pas beaucoup dans ce
polycopiés, et qu’on étaye à l’aide de séance de travaux pratiques. Ces travaux
pratiques représentent, en majorité, l’implémentation des algorithmes vu pendant
le premier semestre dans un langage de programmation (C).
Il est prévu pour ce module un test (éventuellement deux) évalué sur 40% et
un examen final sur 60%. A la fin de ce cours, l’étudiant serait en mesure d’im-
plémenter (même sous d’autres langages de programmation) les notions algorith-
miques nécessaires à la résolution des problèmes techniques qu’il peut souvent
rencontrer dans le reste de son cursus.
Table des matières
Table des matières iii
Table des figures vi
Liste des tableaux vii
1 Bureautique & Technologie Web 1

1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.1.1 Différents types d’information . . . . . . . . . . . . . . . . 1
1.2 Historique de l’informatique . . . . . . . . . . . . . . . . . . . . . 2
1.2.1 Outils primitifs . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2.2 Historiques des machines . . . . . . . . . . . . . . . . . . . 2
1.3 Matériel informatique . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.3.1 Mémoires . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.3.2 Processeurs . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.3.3 Périphériques . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.4 Logiciel informatique . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.5 Les réseaux informatiques . . . . . . . . . . . . . . . . . . . . . . 14
1.5.1 Les différents type de réseaux . . . . . . . . . . . . . . . . 14
1.5.2 Caractéristique d’un réseau local . . . . . . . . . . . . . . 16
1.6 Topologie et fonctionnement d’un réseau . . . . . . . . . . . . . . 17
1.6.1 Topologie en bus . . . . . . . . . . . . . . . . . . . . . . . 17
1.6.2 Topologie en étoile . . . . . . . . . . . . . . . . . . . . . . 17
1.6.3 Topologie en anneaux . . . . . . . . . . . . . . . . . . . . . 19
1.6.4 Topologie maillé . . . . . . . . . . . . . . . . . . . . . . . . 19
1.7 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2 Introduction à l’informatique 21
2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.2 Différents systèmes de numérations . . . . . . . . . . . . . . . . . 21
2.2.1 Définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.2.2 La numération décimale . . . . . . . . . . . . . . . . . . . 21
2.2.3 La numération binaire . . . . . . . . . . . . . . . . . . . . 22
2.2.4 La numération hexadécimale . . . . . . . . . . . . . . . . . 22
Table des matières iv
2.2.5 Conversion entre les différentes bases . . . . . . . . . . . . 22

2.3 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3 Notions d’algorithme et de programme 26

3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.2 Notions préliminaires d’algorithme . . . . . . . . . . . . . . . . . 27
3.2.1 Problème des sceaux . . . . . . . . . . . . . . . . . . . . . 27
3.2.2 Définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.2.3 Structure d’un algorithme . . . . . . . . . . . . . . . . . . 28
3.2.4 Étapes de conception d’un algorithme . . . . . . . . . . . . 29
3.3 Éléments de base . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.3.1 Données . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.3.2 Types numériques . . . . . . . . . . . . . . . . . . . . . . . 30
3.3.3 Types alphanumériques . . . . . . . . . . . . . . . . . . . . 31
3.3.4 Type logique . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.4 Actions de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.4.1 Déclaration . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.4.2 Affectation . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.4.3 Lecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.4.4 Écriture . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.5 Actions composées et expressions . . . . . . . . . . . . . . . . . . 37
3.5.1 Actions composées . . . . . . . . . . . . . . . . . . . . . . 37
3.5.2 Expressions et opérateurs . . . . . . . . . . . . . . . . . . 37
3.5.3 Hiérarchie des opérations . . . . . . . . . . . . . . . . . . . 38
3.6 Structures alternatives . . . . . . . . . . . . . . . . . . . . . . . . 39
3.6.1 Première forme d’une condition . . . . . . . . . . . . . . . 39
3.6.2 Deuxième forme d’une condition . . . . . . . . . . . . . . . 40
3.6.3 La condition composée . . . . . . . . . . . . . . . . . . . . 41
3.6.4 Les conditions imbriquées . . . . . . . . . . . . . . . . . . 42
3.6.5 La structure de contrôle Selon . . . . . . . . . . . . . . . . 44
3.7 Déroulement d’un algorithme . . . . . . . . . . . . . . . . . . . . 44
3.8 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
4 Les variables indicées 48

4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
4.2 Les structures itératives . . . . . . . . . . . . . . . . . . . . . . . 49
4.2.1 La structure itérative pour . . . . . . . . . . . . . . . . . . 49
4.2.2 L’instruction répéter . . . . . . . . . . . . . . . . . . . . . 52
Table des matières v
4.2.3 L’instruction Tant que . . . . . . . . . . . . . . . . . . . . 53

4.3 Les tableaux à une seule dimension . . . . . . . . . . . . . . . . . 54
4.3.1 Syntaxe de déclaration d’un tableau . . . . . . . . . . . . . 55
4.3.2 Opérations sur les tableaux . . . . . . . . . . . . . . . . . 56
4.4 Les tableaux à deux dimensions . . . . . . . . . . . . . . . . . . . 57
4.4.1 Syntaxe de déclaration d’une matrice . . . . . . . . . . . . 57
4.4.2 Opération sur les matrices . . . . . . . . . . . . . . . . . . 57
4.5 Structures itératives imbriquées . . . . . . . . . . . . . . . . . . . 58
4.6 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
A Exercices divers 60
A.1 Codage de l’information . . . . . . . . . . . . . . . . . . . . . . . 60
A.2 Identificateurs, expression, Si et Déroulement . . . . . . . . . . . . 61
A.3 Structures itératives . . . . . . . . . . . . . . . . . . . . . . . . . 62
Table des figures
1.1 Battons de John Napier 1617. . . . . . . . . . . . . . . . . . . . . 3

1.2 Battons de John Napier 1617. . . . . . . . . . . . . . . . . . . . . 3
1.3 Premier ordinateur ENIAC en 1946. . . . . . . . . . . . . . . . . . 4
1.4 Architecture à mémoire partagée de Von Neuman en 1948. . . . . 5
1.5 Circuit intégré. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.6 Mini-ordinateur PDP8 de 1965. . . . . . . . . . . . . . . . . . . . 7
1.7 Microprocesseur Intel C4004 de 1971. . . . . . . . . . . . . . . . . 8
1.8 Premeir odinateur personnel d’IBM. . . . . . . . . . . . . . . . . . 9
1.9 Summit IBM Power System AC922. Etats-unis Juin 2018. . . . . 9
1.10 Mémoire morte ROM. . . . . . . . . . . . . . . . . . . . . . . . . 11
1.11 Mémoire vive RAM. . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.1 Différentes variables . . . . . . . . . . . . . . . . . . . . . . . . . . 29

3.2 Prmière forme du si . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.3 Deuxième forme du si . . . . . . . . . . . . . . . . . . . . . . . . 40
3.4 Les conditions imbriquées. . . . . . . . . . . . . . . . . . . . . . . 42
3.5 Résolution d’une équation du second degré. . . . . . . . . . . . . . 43
4.1 Tableau d’entiers contenant 5 valeurs. . . . . . . . . . . . . . . . . 54

4.2 Matrice d’entiers de 3×3 valeurs . . . . . . . . . . . . . . . . . . . 57
Liste des tableaux
2.1 Table de codage entre les bases 2, 10 et 16. . . . . . . . . . . . . 24
3.1 Table ASCII pour quelques caractères. . . . . . . . . . . . . . . . 32

3.2 Table de vérité pour deux variables. . . . . . . . . . . . . . . . . . 33
3.3 Hiérarchie des opérateurs dans les expressions algebriques. . . . . 38
3.4 Hiérarchie des opérateurs dans les expressions logiques. . . . . . . 39
Liste des Algorithmes
1 Schéma type d’un algorithme. . . . . . . . . . . . . . . . . . . . . . 28

2 Ordre d’exécution dans un algorithme. . . . . . . . . . . . . . . . . 36
3 Action composée. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4 Division de deux nombres réels. . . . . . . . . . . . . . . . . . . . . 40
5 Parité d’un nombre entier. . . . . . . . . . . . . . . . . . . . . . . . 41
6 La division sur trois. . . . . . . . . . . . . . . . . . . . . . . . . . . 45
7 Un exemple simple d’instruction pour. . . . . . . . . . . . . . . . . 50

8 La somme des N premiers entiers. . . . . . . . . . . . . . . . . . . . 51
9 La somme des N premiers entiers (Répéter). . . . . . . . . . . . . . 53
10 Parité des nombres entiers. . . . . . . . . . . . . . . . . . . . . . . 54
11 La moyenne d’une promotion. . . . . . . . . . . . . . . . . . . . . . 55
12 Un tableau avec les notes d’une promotion. . . . . . . . . . . . . . 56
13 Le carré d’une matrice quelconque d’ordre 3. . . . . . . . . . . . . 59
14 Division de deux nombres réels (y 6= 0). . . . . . . . . . . . . . . . 62

15 Déroulement d’un algorithme. . . . . . . . . . . . . . . . . . . . . . 62
Chapitre 1
Bureautique & Technologie Web
La révolution informatique fait gagner un temps fou aux hommes,

mais ils le passent avec leurs ordinateurs !
1.1 Introduction
Le mot Informatique découle de la contraction des deux mots : « Information »
et « Automatique » pour signifier le traitement automatique de l’information.
L’informatique est un domaine d’activité scientifique, technique et industriel
concernant le traitement automatique de l’information par l’exécution de pro-
grammes informatiques par des machines : des systèmes embarqués, des ordina-
teurs, des robots, des automates, etc.
Ces champs d’application peuvent être séparés en deux branches, l’une, de
nature théorique, qui concerne la définition de concepts et modèles, et l’autre,
de nature pratique, qui s’intéresse aux techniques concrètes de mise en œuvre.
Certains domaines de l’informatique peuvent être très abstraits, comme la com-
plexité algorithmique, et d’autres peuvent être plus proches d’un public profane.
Ainsi, la théorie des langages demeure un domaine davantage accessible aux pro-
fessionnels formés (description des ordinateurs et méthodes de programmation),
tandis que les métiers liés aux interfaces homme-machine sont accessibles à un
plus large public.
1.1.1 Différents types d’information

Les informations représente le cœur de la vie courante, et toute la vie sur base
sur l’information. Le progrès des pays se mesure maintenant par la maitrise de
l’information sur tout ses aspect. Parmi le large éventail d’informations existantes
on peut distinguer ce qui suit :
— Chiffres, lettres, symboles, etc.
1.2. Historique de l’informatique 2
— Sons, vidéos, images.

— Signaux radar, wifi, télécommunications.
— Vitesses, températures, tensions, pressions, etc.
— etc.
On dispose cependant de différents types de machines pour traiter ces information
notamment :
— Ordinateurs, tablettes, PC.
— Téléphones, Consoles de jeux.
— Robots, radars, GPS.
— etc.
1.2 Historique de l’informatique

Dans cette section nous allons retracer l’historique de l’informatique du point
de vue machines et progrès technologique.
1.2.1 Outils primitifs

On date les pères fondateur de l’informatique avec les premiers calculateurs
mécaniques limités aux opérations de base tels que les battons de John Napier en
1617. (cf voir la figure 1.1). En 1642, Blaise Pascal conçut la Pascaline, la première
calculatrice mécanique de l’époque dénommée aussi machine arithmétique. La
conception de cette machine viens ensuite en 1645, avec comme tâche principale,
faciliter le calcul des recettes fiscales confié à son père. Parmi ces outils primitifs
de calcul, dans le métier à tisser (Métier Jacquard ) on compte les premières
machines programmables à l’aide de cartes perforées. La figure 1.2 montre une
telle machine baptisée par Joseph Marie Jacquard en 1801.
On compte après les premiers appareils analogiques, utilisant des quantités
physiques pour coder l’information (courant et vitesse).
1.2.2 Historiques des machines

On compte principalement le développement des machines informatiques en
quatre générations principales, la cinquième faisant encore l’objet de progrès
constant jusqu’à nos jours. Les dates retenues pour cet historiques seront les dates
les plus marquantes de l’histoire de l’humanité et de l’informatique en général.
Figure 1.1 – Battons de John Napier 1617.
Figure 1.2 – Battons de John Napier 1617.

Figure 1.3 – Premier ordinateur ENIAC en 1946.
Première génération (1936-1956)

1946 Pour cette époque, l’année 1946 sera la plus spéciale de part l’invention
du premier ordinateur complètement électronique, le fameux ENIAC :
"Electronic Numerical Integrator And Computer" (cf figure 1.4). Le
principe de cet ordinateur vient du physicien John William Mauchly pour
permettre de calculer des tables de tirs de façon complètement électronique.
L’armée américaine adopte l’idée et finance le projet entièrement pour le
besoins de ses travaux sur la balistique.
1948 Le mathématicien Jhon Von Neuman inventa l’architecture à mémoire cen-
tralisée ce qui va permettre de faire naître la première machine à architec-
ture de Von Neuman où les programmes seront stockées au même endroit
que les données au sein de la même mémoire.
Deuxième génération (1955-1963) Cette génération sera marqué par l’in-

vention du transistor—composant électronique utilisé dans la plus part des cir-
cuits électroniques—en 1947 par John Bardeen, William Shockley et Walter Brat-
Figure 1.4 – Architecture à mémoire partagée de Von Neuman en 1948.

Figure 1.5 – Circuit intégré.
tain, chercheurs des Laboratoires Bell.

1954 Premier langage de programmation Fortran (Formula Translator).
1955 Maurice Wilkes inventa la micro-programmation (utilisée dans la program-
mation du processeur).
1956 IBM lança son premier système à base de disque dur.
Troisième génération (1963-1971)

1963 Cette année marque les première utilisations des circuits intégrés inventés
la première fois en 1958 par l’américain Jack Kilby
1965 Le PDP8, premier mini-ordinateur de l’histoire de l’informatique. Le concept
a été ensuite popularisé par l’avènement des PDP11 à partir des années 1970
avec des machines à 16 bits.
Quatrième génération (1971-fin des années 1980 Cette époque est mar-
quée par l’invention des microprocesseurs et des ordinateurs PC.
Invention du microprocesseur Le microprocesseur a été inventé en 1971 par
Marcian Hoff, surnommé "Ted Hoff" alors ingénieur chez Intel. Le 15 no-
vembre 1971, la marque Intel lance la commercialisation d’un ordinateur
programmable dans une puce ("a microprogrammable computer on a chip").
Figure 1.6 – Mini-ordinateur PDP8 de 1965.

Figure 1.7 – Microprocesseur Intel C4004 de 1971.
Ordinateur personnel L’invention des PC ("Personnel Computers") remonte

à l’année 1972, avec l’ouverture au grand public du marché de l’informatique
avec l’introduction du HP 9820 PC.
Langages évolués C’est vers la fin des années 1980 qu’on commence à avoir une
forte consolidation des langages de programmation déjà existants comme
le langage C. Le langage C++ combine la programmation système à la pro-
grammation orientée objet. Le langage Ada vient d’être normalisé par le
gouvernement américain, à la base un langage système utilisé par des sous-
traitants de la défense américaines.
Supercalculateurs C’est seulement vers la fin des années 1980 que la technique
des systèmes massivement parallèles est adoptée, avec l’utilisation dans un
même super-ordinateur de milliers de processeurs. A la fin des années 1990,
le marché des supercalculateurs a connu un crash, et la commercialisation de
ce type de machine a connu une rupture. De nos jours les supercalculateurs
sont de nouveaux à la demande et plus ou moins accessible même par le
grand public. Le site https://www.top500.org/ met en ligne la liste des
500 superoridnateurs les plus puissants du monde. La figure 1.9 montre le
meilleur supercalculateur du mois de Juin 2018.
Figure 1.8 – Premeir odinateur personnel d’IBM.
Figure 1.9 – Summit IBM Power System AC922. Etats-unis Juin 2018.
1.3. Matériel informatique 10
1.3 Matériel informatique

Dans un Ordinateur on retrouve le mot Ordre. Le mot ORDINATEUR a été
créé par IBM en 1954 pour remplacer le mot CALCULATEUR ("computer" en
anglais). Dans l’ordinateur on distingue deux parties :
1. Logiciel ("Software").
2. Matériel ("Hardware").
Nous allons dans la suite survoler chacune de ces deux parties. Le matériel en
informatique concerne principalement ces trois parties :
1. Mémoires.
2. Processeur.
3. Périphériques.
1.3.1 Mémoires
Les mémoires sont des composantes électroniques qui servent à stocker l’in-
formation. On distingue les mémoires mortes (Une fois les informations écrites,
on ne peut pas les changer) et les mémoires vives.
ROM Read Only Memory ou mémoire à lecture seule. C’est une mémoire morte
qui sert à stocker les informations du BIOS ("Basic Input Output System")
nécessaire au démarrage du système. La ROM contient aussi les informa-
tions des périphériques tels que imprimantes, écran, etc.
RAM Random Acces Memory ou mémoire à accès aléatoire.
1.3.1.1 Organisation de la RAM

La RAM est une suite de cellules contenant une quantité d’information. Cette
information se mesure par bit ou "binary digit". C’est la plus petite unité de
mesure de l’information, un bit vaut 1 ou 0. Une RAM est divisée en emplacements
de tailles fixes, utilisés pour stocker instructions et données. La capacité de la
mémoire est le nombre d’emplacements, elle est exprimée en Ko, Mo, Go. . .
1.3.1.2 Opérations sur la RAM

Le contenu de la mémoire RAM ne peut être modifié que par le processeur.
On distingue cependant deux opérations possibles sur une RAM :
Figure 1.10 – Mémoire morte ROM.
Figure 1.11 – Mémoire vive RAM.

Lecture : Qui consiste à faire une copie de l’information ayant son adresse.
Écriture : Qui consiste à modifier une case mémoire ayant son adresse avec
une valeur donnée.
1.3.2 Processeurs
C’est un circuit électronique complexe qui exécute et traite d’une manière
rapide les instructions. Appelé aussi "CPU" (Central Processing Unit). Divisé en
deux grandes parties :
Unité de commande : (UC) responsable de la lecture en mémoire et du déco-
dage des instructions.
Unité de traitement : (UAL) responsable des traitements à faire par le pro-
cesseurs.
Cette dernière unité (Unité arithmétique et Logique) est subdivisée en deux par-
ties comme suit :
Unité arithmétique : responsable des opérations de calcul mathématique :
(+,-,*,/).
Unité logique : responsable des opérations logiques : (Et, Ou, Non).
1.3.3 Périphériques
Ce sont des organes autour de l’unité centrale d’un ordinateur. On distingue
deux catégories de périphériques :
1. périphériques d’Entrée/Sortie.
2. périphériques de stockage.
Périphériques d’Entrée/Sortie
Ils sont responsables des interactions entre l’utilisateur de la machine et la
machine. Ils servent d’interface entre la machine et l’utilisateur. On les utilise
soit pour introduire de l’information à l’ordinateur :
— Clavier.
— Souris.
— Crayon optique
— Lecteur de codes barres
1.4. Logiciel informatique 13
— Scanner
— Microphone
ou pour recevoir les informations émanant de la machine :
— Écran.
— Imprimante.
— Modem.
— Graveur DVD.
— Carte graphique.
— Webcam.
Périphériques de stockage
Ces organes servent à sauvegarder l’information traitée par la machine et
pouvoir la manipuler une autre fois, on distingue les périphériques suivants :
— Disque dur.
— Disquette, Disquette ZIP.
— Carte mémoire.
— Flash mémoire.
— CD, DVD.
— ...
1.4 Logiciel informatique

Le mot logiciel vient du mot logique. Cette dérivation fait du logiciel quelque
chose d’abstrait (immatériel) et qui fonctionne de façon logique. Le mot à été in-
troduit en 1972 pour remplacer le mot "Software". Il englobe beaucoup d’élément
tel que :
— Programme (code source).
— Données.
— Documentation.
— Scripts.
— Fichiers de configurations.
1.5. Les réseaux informatiques 14
— Bibliothèques logicielles.
On distingue deux catégories de logiciels : applicatifs et systèmes.
Logiciels applicatifs : Qui sont des logiciels conçus pour une tâche bien définie
utilisé par un utilisateur, parmi ces logiciels on cite :
— Microsoft Word (traitement de texte).
— Widows media player (Audio).
— LATEX (traitement de texte scientifique).
— Mozzilla (navigateur web).
— Gimp (traitement d’images).
Logiciels systèmes : Qui sont es logiciels qui contrôlent le fonctionnement gé-
néral et l’utilisation du matériel par les logiciels applicatifs :
— Systèmes d’exploitation : Linux, Mac/OS, Windows, etc. . .
— Drivers (pilotes) : logiciels nécessaires pour l’utilisation des logiciels
applicatifs (même les périphériques), par exemple, on a besoin d’un
pilote de son pour écouter de la musique à l’aide de Windows media
player.
1.5 Les réseaux informatiques

Le réseaux représente un système permettant à plusieurs appareils d’échanger
des informations. Ces appareils en question sont souvent des ordinateurs. Ce-
pendant il peut s’agir d’autres machines sont de façon générale des ordinateurs
comme ils peuvent être des automates d’une usine communiquant entre eux.
1.5.1 Les différents type de réseaux

On distingue différents types de réseaux (privés) selon leur taille (en terme de
nombre de machines), leur vitesse de transfert des données ainsi que leur étendue.
On fait généralement trois catégories de réseaux :
— LAN (Local Area Network)
— MAN (Metropolitan Area Network)
— WAN (Wide Area Network)
1.5.1.1 Le réseau local LAN (Local Area Network)

C’est un réseau informatique à une échelle géographique relativement res-
treinte, il est utilisé pour relier entre eux les ordinateurs : par exemple d’une
habitation particulière, d’une entreprise, d’une salle informatique, d’un bâtiment.
L’infrastructure est privée et est gérée localement. À l’intérieur, ou « sur » le ré-
seau local il y a des ordinateurs fixes ou portables connectés par des câbles ou sans
fil (Réseaux locaux sans fil : WLAN). Ces deux mondes communiquent par l’in-
termédiaire d’une box ou modem ADSL (selon le FAI). La taille d’un réseau local
peut atteindre jusqu’à 100 voire 1000 utilisateurs. En élargissant le contexte de
la définition aux services qu’apportent le réseau local, il est possible de distinguer
deux modes de fonctionnement : dans un environnement « paire à paire : P2P »
(en anglais peer to peer), dans lequel il n’y a pas d’ordinateur central et chaque
ordinateur a un rôle similaire. dans un environnement « client/serveur », dans
lequel un ordinateur central fournit des services réseau aux utilisateurs. Les MAN
(Metropolitan Area Network) interconnectent plusieurs LAN géographiquement
proches (au maximum quelques dizaines de km) à des débits importants.
Technologies utilisées : Ethernet (sur câbles de paires torsadées), ou Wifi.
1.5.1.2 Le réseau MAN (Metropolitan Area Network)

C’est un réseau métropolitain qui désigne un réseau composé d’ordinateurs
habituellement utilisés dans les campus ou dans les villes. Ainsi, un MAN per-
met à deux nœuds (ordinateurs) distants de communiquer comme si ils faisaient
partie d’un même réseau local. Un MAN est formé de commutateurs ou de rou-
teurs interconnectés par des liens hauts débits qui utilise généralement des fibres
optiques. Ces réseaux peuvent être placés sous une autorité publique ou privée
comme le réseau intranet d’une entreprise ou d’une ville. Il permet donc pour une
société, une ville, de contrôler elle-même son réseau. Ce contrôle comprend la pos-
sibilité de gérer, surveiller et effectuer des diagnostics à distance, à la différence
de la connexion WAN, pour laquelle elle doit se fier à son fournisseur d’accès
pour gérer et maintenir la liaison entre elle et son bureau distant. Par exemple,
une ville peut décider de créer un « MAN » pour relier ses différents services
disséminés et mutualiser ses ressources, sur un rayon de quelques kilomètres et
en profiter pour louer cette infrastructure à d’autres utilisateurs.
Technologies utilisées : Fibre optique, ondes radios (Wi-Fi).
1.5.1.3 Le réseau WAN (Wide Area Network)

Le réseau Internet (WAN) est un réseau couvrant une grande zone géogra-
phique, à l’échelle d’un pays, d’un continent, voire de la planète entière. Il per-
met l’interconnexion de réseaux locaux et métropolitains vers l’Internet mondial.
L’infrastructure est en général publique. Le plus grand réseau WAN est le réseau
internet.
Technologies utilisées : Câble, fibre optique, satellite, technologie sans fil 3G
et ondes hertziennes.
1.5.2 Caractéristique d’un réseau local

Ces réseaux (LAN) ont beaucoup de caractéristiques, on se réserve de citer :
Le support physique : On choisit par exemple un réseau filaire, et on aura à
déterminer le type de câblage adéquat (câble coaxial, fibre optique ou paire
torsadé), ce dernier type de câble étant le plus utilisé car il est le moins cher
et la plus parts des équipements sont dédiés pour ce câblage. En outre, on
peut opter pour un réseau sans fil (Wifi).
Le type de réseau : ce choix est le plus déterminant car il va entraîner l’achat
de matériels spécifiques au futur réseau. Le choix du type de réseau déter-
mine bien souvent le niveau d’évolution du réseau et la méthode d’accès au
réseau.
La bande passante : également appelée débit, c’est la quantité d’informations
qui pourra circuler simultanément sur le réseau. Ce débit est donné en kilo
bits par seconde (Kbps), en Méga bits par seconde (Mbps) ou même parfois
en Giga bits par seconde (Gbps). Pour chaque type de réseau et en fonction
du type de câblage utilisé, plusieurs débits différents sont disponibles.
Les protocoles de communication : ce sont les langages utilisés par les dif-
férentes machines afin d’échanger des informations. Plusieurs langages dif-
férents peuvent être employés en fonction des applications à exécuter, mais
deux machines souhaitant échanger des informations doivent utiliser le
même langage.
Le système d’exploitation : Il déterminera la façon de configurer le réseau.
De même, certains serveurs sont dédiés à un type de réseau spécifique ou
une tâche précise ( ex : Windows 2000 pour le serveur d’application, Linux
pour le Serveur Proxy et Novell pour le serveur administratif).
1.6. Topologie et fonctionnement d’un réseau 17
Les éléments d’interconnexion : Plusieurs types de matériels existent afin

de diriger l’information à l’intérieur du réseau ou vers l’extérieur comme
Internet (Ex : Routeur). Ces éléments sont généralement dédiés à un type
de réseau prédéterminé.
1.6 Topologie et fonctionnement d’un réseau

Il y a 4 architectures différentes pour les réseaux filaires. Ces architectures
sont appelées topologies. La figure 1.12 nous montre ces différentes topologies.
Elles décrivent la façon dont les machines sont organisées géographiquement
les unes par rapport aux autres dans le réseau et la façon dont elles sont inter-
connectées.
1.6.1 Topologie en bus

Les machines sont reliées par un câble coaxial (le bus) et chaque ordinateur est
connecté en série sur le bus, on dit encore qu’il forme un nœud. Le câble coaxial
relie les ordinateurs du réseau de manière linéaire. Les informations envoyées à
partir d’une station sont transmises sur l’ensemble du bus à toutes les stations.
L’information circulant sur le réseau (la trame) contient son adresse de destination
et c’est aux stations de reconnaître les informations qui leur sont destinées.
1.6.2 Topologie en étoile

Notamment utilisée par les réseaux Ethernet actuels en RJ45, elle concerne
maintenant la majorité des réseaux. Lorsque toutes les stations sont connectées
à un commutateur, on parle de topologie en étoile. Les nœuds du réseau sont
tous reliés à Câble RJ45 un nœud central. Dans cette topologie tous les hôtes
sont interconnectés grâce à un SWITCH (il y a encore quelques années c’était
par un HUB = concentrateur) : sorte de multiprise pour les câbles réseaux placés
au centre de l’étoile. Les stations émettent vers ce concentrateur qui renvoie les
données vers tous les autres ports réseaux (hub) ou uniquement au destinataire
(switch). Le câble entre les différents nœuds est désigné sous le nom de « paires
torsadées ». Si les informations qui circulent sur le câblage se font de la même
manière que dans le réseau en bus, les câbles en paires torsadées supportent un
débit de 100 Mbits/s, et les switchs (les commutateurs) peuvent diriger la trame
directement à son destinataire. Cette topologie facilite une évolution hiérarchisée
1.6. Topologie et fonctionnement d’un réseau 18
(a) (b)
(c) (d)
Figure 1.12 – Les différentes topologies en réseaux : (a) Topologie en bus ; (b)
Topologie en étoile ; (c) Topologie en anneaux ; (d) Topologie maillée.
1.7. Conclusion 19
du matériel. On peut facilement déplacer un appareil sur le réseau. La panne

d’une station (ordinateur) ne perturbe pas le fonctionnement global du réseau.
1.6.3 Topologie en anneaux

Dans un réseau possédant une topologie en anneau, les ordinateurs sont si-
tués sur une boucle et communiquent chacun à leur tour. Cela ressemble à un
bus mais qui serait refermé sur lui- même : le dernier nœud est relié au premier.
En réalité, dans une topologie en anneau, les ordinateurs ne sont pas reliés en
boucle, mais sont reliés à un répartiteur (appelé MAU, Multistation Access Unit)
qui va gérer la communication entre les ordinateurs qui lui sont reliés en répar-
tissant à chacun d’entre-eux un temps de parole. Elle utilise la méthode d’accès
à "jeton" (Token ring). Les données transitent de stations en stations en suivant
l’anneau qui chaque fois régénèrent le signal. Le jeton détermine quelle station
peut émettre, il est transféré à tour de rôle vers la station suivante.
1.6.4 Topologie maillé

Internet est une topologie maillée (sur le réseau étendu « WAN », elle garantit
la stabilité en cas de panne d’un nœud). Les réseaux maillés utilisent plusieurs
chemins de transferts entre les différents nœuds. C’est une structure réseau hy-
bride reprenant un câblage en étoile regroupant différents nœuds de réseaux.
Cette méthode garantit le transfert des données en cas de panne d’un nœud.
1.7 Conclusion
Nous avons vu dans ce chapitre, les différentes stations historiques par les-
quelles sont passées les machines informatiques et les différents acteurs clés à ce
progrès. La principale avancée est électronique, jusqu’à il y a quelques années.
L’avancée de cette dernière décennie est beaucoup plus technique ! Nous sommes
dans une ère où les algorithmes gouvernent le monde. Les sections suivantes se-
rons consacrées aux algorithmes informatiques. Nous survolerons avant d’aborder
ces algorithmes, quelques notions nécessaires à la compréhension du fonctionne-
ment des machines et même aux algorithmes eux-même. Nous avons aussi survolé
quelques composantes essentielles des ordinateurs et quelques outils logiciels très
utilisés. Nous savons en plus que l’ensemble des machines peut être relayé par ce
qu’on appelle un réseau informatique. Ce réseau peut être de différents type et
1.7. Conclusion 20
peut avoir plusieurs topologies. Ces topologies dépendent de l’objectif de l’utili-

sateur de ce réseau, de l’application que va fournir cet ensemble et de beaucoup
d’autres paramètres.
Chapitre 2
Introduction à l’informatique
2.1 Introduction
Nous allons voir dans ce chapitre les concepts de base concernant le codage de
l’information (systèmes de numération binaire, décimale et hexadécimale.) Nous
aborderons quelques notions de base puis des exercices.
2.2 Différents systèmes de numérations

2.2.1 Définitions
On appelle base d’un système de numération le regroupement des signes
différents utilisés par ces systèmes pour coder l’information. Elle correspond donc
au nombre de signes différents de ce système. Par exemple :
— Dans le système décimal on utilise les chiffres de 0 à 9. 10 chiffres et donc
la base B = 10.
— Dans le système binaire on utilise les deux chiffres 0 et 1. La base B = 2.
On appelle rang d’un chiffre, la place de ce chiffre dans un nombre en comp-
tant à partir de la droite. Dans le nombre 2548775, on a :
d
2 5 4 8 7 7 5 -
6 5 4 3 2 1 0 Rang
2.2.2 La numération décimale

Dans le système décimal, on utilise 10 chiffres de 0 à 9. Le système décimal
est donc un système de numération de base 10. Ainsi les nombres se décomposent
2.2. Différents systèmes de numérations 22
en une somme de facteurs de 10n . Exemples :
(2508)10 = (8 × 100 + 0 × 101 + 5 × 102 + 2 × 103 )10

(2604)10 = (4 × 100 + 0 × 101 + 6 × 102 + 2 × 103 )10
2.2.3 La numération binaire

Dans le système binaire, on utilise 2 chiffres le 0 et le 1. Le système binaire
est donc un système de numération de base 2. Ainsi les nombres se décomposent
en une somme de facteurs de 2n . Exemples :
(1101)2 = (1 × 20 + 0 × 21 + 1 × 22 + 1 × 23 )
= (13)10
(111001)2 = (1 × 20 + 0 × 21 + 0 × 22 + 1 × 23 + 1 × 24 + 1 × 25 )
= (57)10
2.2.4 La numération hexadécimale

Dans le système hexadécimal, on utilise 10 chiffres + 6 lettres : {0,. . . , 9,A,B,C,D,E,F}.
Le système hexadécimal est donc un système de numération de base 16. Ainsi
les nombres se décomposent en une somme de facteurs de 16n . Chaque lettre
correspond à un nombre décimal, eg :
(2F10D)16 = (13 × 160 + 0 × 161 + 1 × 162 + 15 × 163 + 2 × 164 )

= (192781)10
(2604)16 = (4 × 160 + 0 × 161 + 6 × 162 + 2 × 163 )
= (9732)10
2.2.5 Conversion entre les différentes bases

Binaire ⇒ Décimal : Il suffit d’écrire le nombre écrit en binaire en somme de
facteur de 2n . eg :
(1011)2 = 1 × 20 + 1 × 21 + 0 × 22 + 1 × 23
= (11)10
Hexadécimal ⇒ Décimal : Même principe que pour le binaire (écriture en

facteur de 16n .) eg :
(6A2)16 = 2 × 160 + 10 × 161 + 6 × 162

= (1698)10
Décimal ⇒ Binaire : On procède par des divisions successives par 2 jusqu’à

atteindre quotient égal à 0. Le nombre binaire est l’ensemble des restes à
partir de la dernière opération de division. eg :
37 = 18 × 2 + 1
18 = 9 × 2 + 0
9=4×2+1
4=2×2+0
2=1×2+0
1=0×2+1
(37)10 = (100101)2
Décimal ⇒ Hexadécimal : On procède par des divisions successives par 16

jusqu’à atteindre quotient égal à 0. Le nombre binaire est l’ensemble des
restes à partir de la dernière opération de division. eg :
400 = 25 × 16 + 0
25 = 1 × 16 + 9
9 = 0 × 16 + 9
(400)10 = (190)16
Binaire ⇔ Hexadécimal : Il existe un passage direct entre ces deux bases

(16 = 24 ). On (dé)code chaque digit hexadécimal en 4 bits comme suit :
(1101101)2 = (6D)16
(1101)2 = (13)10
(110)2 = (6)10
L’opération inverse (binaire ⇒ hexadécimal) s’opère de façon inverse. On

peut faire appel à la table 2.1 de conversion pour ces types de passage direct.
Binaire Décimal Hexadécimal

3
2 =8 2 = 4 21 = 2
2 0
2 =1 - -
0 0 0 0 0 0
0 0 0 1 1 1
0 0 1 0 2 2
0 0 1 1 3 3
0 1 0 0 4 4
0 1 0 1 5 5
0 1 1 0 6 6
0 1 1 1 7 7
1 0 0 0 8 8
1 0 0 1 9 9
1 0 1 0 10 A
1 0 1 1 11 B
1 1 0 0 12 C
1 1 0 1 13 D
1 1 1 0 14 E
1 1 1 1 15 F
Table 2.1 – Table de codage entre les bases 2, 10 et 16.

2.3. Conclusion 25
2.3 Conclusion
Nous avons vu dans ce chapitre une brève définition de l’informatique, l’évo-
lution du matériel menant aux développement technologique grandissant ainsi
que les systèmes de numération utilisés dans les différentes machines. Nous avons
vu le principe de fonctionnement d’une machine informatique et les différentes
opérations opérées entres les composantes électroniques d’un ordinateur. Nous
jugeons ces deux éléments nécessaires à l’élaboration des algorithmes (ensemble
d’opération permettant de résoudre un certain problème). Nous attaquerons le
vif du sujet dans le chapitre suivant.
Chapitre 3
Notions d’algorithme et de
programme
3.1 Introduction
Après avoir abordé l’historique de l’informatique et les outils électroniques de
chaque génération, nous allons discuter dans ce chapitre les notions d’algorith-
mique.
Nous allons parler des éléments de base intervenant dans l’écriture d’un algo-
rithme. Nous allons parler et classifier les données en types algorithmiques. Nous
détaillerons ensuite chaque type, ses caractéristiques ainsi que les opérations pos-
sibles dans chaque type.
Nous verrons ensuite, les actions de base d’un algorithme que nous appellerons
instructions. Nous discuterons de leurs classifications et nous survolerons quelques
exemples d’actions simples.
A partir des éléments qu’on pourra voir dans ces chapitres, nous propose-
rons quelques problèmes simple à résoudre et nous dégagerons les algorithmes
correspondants.
Nous clôturerons le chapitre par une conclusion et quelques exercices.
L’algorithmique est une discipline de l’informatique qui concerne les méthodes
de résolution des problèmes à l’aide des machines informatiques. Cette discipline
est plus ancienne des machines de l’informatique et de son évolution, car, de façon
plus général, un algorithme représente une manière rigoureuse pour résoudre un
problème donné. Une recette de cuisine peut être perçue comme un algorithme,
qui, à partir d’un certain nombre d’ingrédient, essaye de préparer un plat donné
en suivant des étapes bien déterminées. Les premiers algorithmes naissent en
antiquité avec les Babyloniens au iiie siècle (AJC) qui décrivaient des méthodes
de calcul et de résolution d’équations avec des exemples et puis avec les savants
grecs notamment, Euclide, Eratosthène, Archimède, etc. . .
3.2. Notions préliminaires d’algorithme 27
Le mot algorithme doit son nom au célèbre mathématicien perse Abu Abdullah
Muhammad ibn Musa al-Khwarizmi datant du ixe siècle.
Parmi les algorithmes connus bien avant l’informatique, on distingue :
L’algorithme d’Euclide qui calcul le pgcd 1 entre deux nombres entiers.
L’algorithme d’Archimède qui donne une approximation du nombre π.
L’algorithme d’Eratosthène pour trouver les nombres premiers.
L’algorithme d’Averroes qui utilise des procédés de calcul.
3.2 Notions préliminaires d’algorithme

3.2.1 Problème des sceaux
Supposant qu’on a le problème consistant à échanger les contenus de deux
sceaux A et B. Comment procéder ?
1. On commencera par ajouter un troisième sceau C.
2. On videra le contenu de A dans C.
3. On versera le contenu de B dans A.
4. On versera le contenu de C dans B.
Pour ce petit problème trivial, la solution été d’énumérer les étapes nécessaires
à la résolution de notre problème. Tout algorithme sera ensuite défini comme
étant un ensemble fini d’opération qui se termine pour aboutir à une solution.
Ces étapes doivent être en plus non ambigües.
On dira en plus pour toutes les étapes servant à résoudre un problème (même
celles pour répondre à une énigme par exemple) qu’elles forment un algorithme de
résolution de ce problème. On pourra parfois retrouver plusieurs algorithmes (ou
suite d’étapes) pour résoudre le même problème, on optera le plus souvent pour
la meilleure solution (moins d’étapes de construction, qui s’exécute rapidement,
etc). L’énigme des missionnaires et des cannibales peuvent être perçue comme
un problème à lequel il faut trouver une solution pour sauver les missionnaires.
Résoudre une grille de Sudoku représente elle aussi un problème dont l’algorithme
une fois établie, permettra de résoudre n’importe quelle grille par exemple.
1. plus grand diviseur commun
3.2. Notions préliminaires d’algorithme 28
3.2.2 Définitions
Un algorithme est une suite d’instructions(actions) traduisant la solution d’un
problème. Il sera traduit dans un langage donné et exécuté par un ordinateur, en
un temps fini, pour arriver à un résultat donné, à partir d’une situation donnée.
Il doit avoir les caractéristiques suivantes :
Lisible : L’algorithme doit être compréhensible même par un non informaticien.
De haut niveau : L’algorithme doit pouvoir être traduit dans n’importe quel
langage de programmation.
Précis : Chaque élément de l’algorithme ne doit pas porter à confusion, il est
donc important de lever toute ambiguïté.
Structuré : Un algorithme doit être composé de différentes parties facilement
identifiables.
3.2.3 Structure d’un algorithme

Un algorithme est constitué de quatre parties :
Entrée des données : Informations utilisées pour résoudre un problème.
Sorties des résultats : Informations décrivant la solution d’un problème.
Lexique : Calcul intermédiaire.
Traitements : Instructions (ou actions) constituant le traitement.
Tout algorithme qu’on écrira dans ce cours aura le schéma type suivant :
Algorithme : Nom de l’algorithme

Déclaration des structures de données ;
Déclaration des fonctions ;
var Déclaration des variables ;
Début
instruction 1;
instruction 2;
...
instruction n;
Fin.
Algorithme 1 : Schéma type d’un algorithme.
3.3. Éléments de base 29
A 10 B Vrai C ’Mehdi’
Figure 3.1 – A, B et C trois variables de type : numérique, logique et alphanu-

mériques.
3.2.4 Étapes de conception d’un algorithme

Tout algorithme doit passer par les étapes suivantes avant d’être écrit :
Analyse / spécification : Dans cette étape on doit dégager avec précision

les données en entrée, les résultats en sortie ainsi que la fonction principale du
problème posé.
Conception : La conception consiste à déterminer les instructions ( actions)

permettant de traduire les données en entrée en résultats en sortie.
Écriture de l’algorithme : On devrait en fin traduire les étapes une et deux

en langage algorithmique.
3.3 Éléments de base

En algorithmique une donnée est classée en trois types élémentaires :
1. Données numériques, eg : température, nombre de jours, etc. . .
2. Données alphanumériques, eg : un nom, une initiale d’un prénom, etc. . .
3. Données logiques, eg : état d’un interrupteur.
3.3.1 Données
Une donnée peut être considérée comme une boite ayant une étiquette, d’une
certaine forme (type) et contenant une valeur. Donc selon les types qu’on a vu
précédemment, cette forme va changer ainsi que les valeurs que va prendre cette
variable.
Tel que montré dans la figure 3.1, les lettres A, B et C représentent les étiquettes
des trois variables. Les valeurs sont à l’intérieur et les formes (on en a trois dans
l’exemple) désignent les trois types : numériques, alphanumériques et logiques.
3.3.2 Types numériques

Une variable de type numérique est destinée à recevoir des nombres entiers
ou des réels. Exemple :
Nombres entiers signés : −1, +55,+1032,. . .
Nombres entiers non signés : 0, 12, 26,. . .
Nombres réels : 1.2, 55.0, 1 × 10−3 , −2.25,. . .
On rencontre tous le temps des données de ce type comme les température d’un
moteur (nombre réel), état d’un moteur (marche/arrêt), nombre de défaillance
d’un moteur (nombre entier non singé) ou la caractéristique d’un matériau (solide,
liquide, etc.).
3.3.2.1 Les entiers

Une variable de type entier est destinée à prendre des valeurs dans l’ensemble
Z. On pourra donc manipuler des nombres entiers non signés et non signés. Ces
nombres seront représenté en binaire en complément à deux.
Sur ces nombres, on connait en plus des opérations traditionnelles (+,-,*),
le quotient de la division naturelle (noté dans ce cours par div) et le reste de
la division naturelle (notée mod), et l’opération d’exponentiation (notée ^). Voici
quelque exemples :
15 div 5 = 3
12 mod 2 = 0
17 mod 2 = 1
2 ^ 3 = 8
Quand on dispose de N bits, on pourra représenter 2N nombre différents. Dans
une représentation binaires non signées et si N = 8, on représentera 28 = 256
nombres allant de {0, 1, . . . , 255}. Par contre en représentation à complément à
2, on aura les nombres {−128, −127, . . . , 0, 1, . . . , 127}.
3.3.2.2 Les réels

Une variable de type réel prend ses valeurs dans l’ensemble R. On connait deux
façon de représenter ces nombres. La forme habituelle (2.6) et la forme scientifique
(on dispose alors, d’un signe, d’une mantisse et d’un exposant : ±3 × 10−2 ).
Les opérations permises sur les réels sont : l’addition (+), la soustraction (-),
la multiplication (*), la division (/) et la puissance (^).
3.3.3 Types alphanumériques

Ce type de données permet de représenter des caractères ou des chaines de
caractères.
3.3.3.1 Les caractères

On notera ce type car dans ce cours d’algorithmique et on se servira pour
représenter des variables qui prendront un seul caractère comme valeur. Voici
quelques exemples de caractères :
— ’M’, ’E’, ’H’, . . .
— ’d’, ’i’, ’u’, . . .
— ’0’,’1’,’2’,’3’,’4’, . . .
— ’+’,’-’,’@’, ’*’, . . .
— ’ ’ : le caractère espace, . . .
Notez dans ces caractères la présence de (’ ’), qui caractérisera les caractères.
La table 3.1 montre quelques caractères de la table ASCII, avec leurs codes cor-
respondants. L’ensemble des opérations sur les variables de type caractère sont :
l’égalité (=), la différence notée (6= ou < >), supérieur (ou égal) (>, >=), inférieur
(ou égal) (<, <=).
Les quatre dernières opérations s’opèrent à travers l’ordre des caractères dans
la table ASCII (cf. table 3.1).
On sait par exemple que :
’A’ =
6 ’l’
’a’ > ’A’ car 97 > 65
3.3.3.2 Les chaînes de caractères

Une chaine de caractères est une suite de caractères. Elle peut être vide ou
contenir un seul caractère. Exemple :
"cours d’informatique" : suite de caractères ;
"C" : chaîne composée d’un seul caractère ;
"" : chaîne vide ;
Sur les variables de type chaîne de caractères, on connait, en plus des opérations
permises sur les caractères, l’opération de concaténation notée (||). Cette opé-
ration permettras d’engendrer de nouvelles chaînes en mettant cote à cote deux
chaînes. Exemple :
Code ASCII Caractère Code ASCII Caractère

40 ( 41 )
42 * 43 +
44 , 45 -
46 . 47 /
48 0 49 1
50 2 51 3
52 4 53 5
54 6 55 7
56 8 57 9
58 : 59 ;
60 < 61 =
62 > 63 ?
64 @ 65 A
66 B 67 C
68 D 69 E
70 F 71 G
72 H 73 I
74 J 75 K
76 L 77 M
78 N 79 O
80 P 81 Q
82 R 83 S
84 T 85 U
86 V 87 W
98 b 99 c
100 d 101 e
102 f 103 g
104 h 105 i
106 j 107 k
108 l 109 m
110 n 111 o
112 p 113 q
114 r 115 s
116 t 117 u
118 v 119 w
120 x 121 y
123 z 124 |
Table 3.1 – Table ASCII pour quelques caractères.

3.4. Actions de base 33
A B Non A A Et B A Ou B
Faux Faux Vrai Faux Faux
Faux Vrai Vrai Faux Vrai
Vrai Faux Faux Faux Vrai
Vrai Vrai Faux Vrai Vrai
Table 3.2 – Table de vérité pour deux variables.
chaine1 = ’télé’
chaine2 = ’vision’
chaine3 = chaine1 || chaine2 = ’télévision’
3.3.4 Type logique

Une variable de type logique prendra seulement deux valeurs : Vrai ou Faux.
Ce type sera noté booléen dans ce cours. Sur des variables de type booléen, les
opérations suivantes sont possibles :
— La négation : ¬ ou Non
— La conjonction : Et ou ∧
— La disjonction : Ou ou ∨
Exemple : Soient A, B deux variables de type booléen, la table 3.2 (de vérité)
montre le résultat de chacune des trois opérations vues précédemment.
Notons que les opérateurs de comparaison entre les différents types ont le
type logique (booléen). Par exemple, pour deux variables A,B (de type entier
ou n’importe quel autre type préalablement défini), la comparaison A > B aura
le résultat Vrai ou Faux.
3.4 Actions de base

Une action en algorithmique est appelée aussi instruction. Dans un algorithme
on distingue quatre types d’instruction simples et d’autres composées.
Nous pourrons parler de façon générale d’une action (comme mettre des in-
grédients dans une casserole pour une recette de cuisine) ou d’instruction quand
il s’agit d’un problème qui sera résolu par une machine informatique. Nous allons
dans la suite de ce support parler beaucoup plus d’instructions que d’actions.
Les instructions simples (au nombre de quatre) sont les suivante :
1. Déclaration.
2. Affectation.
3. Lecture.
4. Écriture.
Nous allons dans les sections suivantes détailler chacune de ces quatre instructions
simples.
3.4.1 Déclaration
Une déclaration consiste à donner un identificateur (ou un nom) à une
variable. Elle doit aussi fournir un type (ou une forme) pour cette même variable.
Un identificateur (qui représentera l’étiquette de cette variable) doit être donc
unique pour chaque variable de notre problème.
3.4.1.1 L’identificateur
Cet identificateur ou nom d’une variable doit obéir à un ensemble de règles
suivantes :
— Il doit commencer par une lettre de l’alphabet obligatoirement.
— Il ne doit contenir aucun séparateur (l’espace, la tabulation, + , - , %, . . . )
sauf le caractère souligné (_).
— Il ne doit pas contenir de lettres accentuées ni de ligatures : (é, è, ç, ô, œ,
à,. . . ).
— Il ne doit pas être un mots clé.
— Il doit refléter le rôle joué par par cette variable dans le problème.
3.4.1.2 Le type d’un identificateur

Le type d’une variable indique son genre et doit être un des types prédéfinis
précédemment, à savoir, entier, réel, booléen, car, chaine.
3.4.1.3 Syntaxe d’écriture d’un identificateur

On parle de syntaxe pour dire façon générale pour écrire une phrase ou un mot.
Dans l’algorithmique, nous avons aussi une syntaxe à respecter pour écrire nos
algorithmes. Nous avons déjà vu un exemple dans le schéma type d’un algorithme
(cf. algorithme 1).
La syntaxe de déclaration d’une variable (quelque soit son type) est la sui-
vante :
var identificateur : type ;

liste_identificateurs : type ;
On pourra définir des variables de cette façon, par exemple :
var Temperature : réel ;

i,j,k : entier ;
3.4.2 Affectation
Une affectation consiste a donner à une variable une valeur correspondante.
Cette opération consiste donc à copier en mémoire la valeur dans la variable qui
se situe à gauche.
3.4.2.1 Syntaxe
On écrit de façon générale une affectation de cette manière : l’expression
identificateur ← valeur ;
identificateur ← expression ;
c’est une opération entre des valeurs ou même des variables. Voici un exemple
illustratif de quelques opérations d’affectation :
Temperature ← 37.5 ;
Taux ← (Prix*19)/100 ;
i ← i+1;
Symbole ←’%’ ;
Prenom ← "Mehdi";
Etat ← Vrai;
Remarque :
— Une affectation est une instruction qui écrase le contenu de la variable,
i.e., la variable aura la nouvelle valeur en mémoire.
— L’ordre d’exécution des instructions dans un algorithme est très important.
Problème 1. A partir de l’algorithme 2 suivant :

1. Donnez la valeur de chacune des trois variables après chaque instruction de
cet algorithme.
2. Que fait cet algorithme.
Algorithme : Exécution ;
var X,Y,Z : entier ;
Début
X ← 3;
Y ← 5;
Z ← X;
X ← Y;
Y ← Z;
Fin.
Algorithme 2 : Ordre d’exécution dans un algorithme.
3.4.3 Lecture
La lecture consiste à introduire une valeur à une variable à partir d’une unité
d’entrée (clavier).
3.4.3.1 Syntaxe
Pour effectuer une lecture, on utilise la syntaxe suivante :
lire(identificateur);
lire(liste_identificateurs);
Voici quelques exemple de lectures :
lire(Temperature);
lire(i,j,k);
3.5. Actions composées et expressions 37
3.4.4 Écriture
Cette instruction permet d’afficher la valeur d’une variable ou d’un message
sur une unité de sortie (écran).
Affichage d’un message :

ecrire("message");
Affichage du contenu d’une variable :
ecrire(identificateur);
Voici un exemple illustratif :
A ← 5;
ecrire("La valeur de A =");
ecrire(A);
3.5 Actions composées et expressions

Nous allons dans cette partie parler des actions composées et des expressions
qui vont nous servir ensuite pour concevoir la plus part de nos algorithmes.
3.5.1 Actions composées

Une action composée est une suite d’actions simples. On considère donc tout
algorithme comme action(s) composée(s) pour résoudre un problème donné. Voici
un exemple d’un algorithme simple (algo 3) :
3.5.2 Expressions et opérateurs

Une expression est un ensemble de valeurs reliées par des opérateurs où le
résultat final est une valeur. L’ensemble des opérateurs appliqués à ces valeurs
représentera le type de cette expression. On aura des expressions qu’on va appeler
algébriques pour tout les types qu’on a vu dans ce cours sauf le dernier (booléen).
Pour le type logique on définit des expressions logiques. Exemple :
— 25 div 3 mod 2
— -25+(3-6)*2+5
3.5. Actions composées et expressions 38
Algorithme : Exemple
var a,b : réel ;
Début
ecrire("Donnez la valeur de a");
lire(a);
ecrire("Donnez la valeur de b");
lire(b);
a ← a*b+a/2;
ecrire("a = ",a);
Fin.
Algorithme 3 : Action composée.
Opérateurs Hiérarchie
( ) 1
^ 2
− (signe moins) 3
*, /, div, mod 4
+, - 5
Table 3.3 – Hiérarchie des opérateurs dans les expressions algebriques.
— a*5+3*2/b
— A Et B Ou Non(C Et D)
— "Bon" || "jour" || C
3.5.3 Hiérarchie des opérations

L’ordre d’exécution des opération dans une expression est très important. Une
expression peut parfois, si on ne connais pas les priorités entre les opérations,
donner de fausses résultats. Exemple :
25*3+6 aura le résultat 225 si on exécute l’opération + en premier. Or le bon
résultat est bien 81.
Les tableaux 3.3 et 3.4 nous montrent la priorité entre les différentes opéra-
teurs dans les expressions :
Pour évaluer donc une expression, on procède de gauche à droite en respectant
les différentes priorités définies dans les tableaux cités précédemment.
3.6. Structures alternatives 39
Opérateurs Hiérarchie
( ) 1
Non 2
Et, Ou 3
Table 3.4 – Hiérarchie des opérateurs dans les expressions logiques.
Instructions
Vrai
Condition
Instructions’
Figure 3.2 – Organigramme pour la première forme d’un si.
3.6 Structures alternatives

Les structures alternatives ont deux syntaxes (ou formes) différentes. Il s’agit
dans la première forme de faire un traitement si une condition est vérifiée et rien
dans le cas contraire. Quant à la deuxième forme, on a à exécuter un traitement
si une condition est satisfaite et un autre traitement si elle ne l’est pas.
3.6.1 Première forme d’une condition

On exprime très souvent les étapes nécessaires (ou les instructions) d’un algo-
rithme sous forme d’organigramme, i-e., un ensemble de forme géométrique dans
un schéma pour représenter la résolution d’un problème. Pour les structures alter-
natives, on utilise un losange tel que montré dans la figure 3.2. Voici la première
forme d’une condition dans un algorithme :
si Condition alors
instructions’ ;
finsi;
Instructions
Vrai Faux
Condition
Instructions01 Instructions02
Figure 3.3 – Organigramme pour la seconde forme d’un si.
Maintenant que nous avons cette instruction nous pouvons écrire correctement
l’exercice de la division. Voici la solution (cf. algo 4) :
Algorithme : Division2 ;
var x, y, D : réel ;
Début
ecrire(”Donnez la valeur de x”);
lire(x);
ecrire(”Donnez la valeur de y”);
lire(y);
si y 6= 0 alors
D ← x/y;
ecrire(”D = ”,D);
finsi;
Fin.
Algorithme 4 : Division de deux nombres réels.
3.6.2 Deuxième forme d’une condition

Il s’agit de prévoir deux traitements différents suivant une condition. La fi-
gure 3.3 montre une telle situation. La syntaxe de cette forme est la suivante :
Problème 1. Écrivez un algorithme qui détermine si un nombre entier positif

si Condition alors
instructions01 ;
sinon
instructions02 ;
finsi;
(n) donné par l’utilisateur est pair ou impaire :

(
si ∃ k ∈ N, n = 2k, pair,
n:
sinon, impair.
Solution : L’algorithme 5 vérifie cette propriété pour tout nombre n entier :

Algorithme : Parity ;
var n : entier ;
Début
ecrire(”Donnez la valeur de n”);
lire(n);
si n mod 2 = 0 alors
ecrire(n, ”est un nombre paire”);
sinon
ecrire(n, ”est un nombre impaire”);
finsi;
Fin.
Algorithme 5 : Parité d’un nombre entier.
3.6.3 La condition composée

Ce que nous avons vu jusqu’à maintenant concerne simplement les conditions
simples. Dans cette section nous allons aborder les conditions composées.
Une condition composée est construite à partir d’une combinaison (à l’aide
des opérateurs logiques) de deux ou plusieurs conditions simples. Par exemple si
on veut savoir si un nombre x ∈ R appartient à un intervalle défini ainsi : [−2, 0],
on aura à vérifier si x ≥ −2 et x ≤ 0. On écrira donc ce qui suit :
A partir des opérateurs logiques (Et, Ou et Non) et des opérateurs de com-
paraisons (<, >, etc), nous pourrions donc construire nos conditions composées.
si x ≥ −2 Et x ≤ 0 alors
ecrire(”x est dans l’intervalle souhaité”);
sinon
ecrire(”x n’est pas dans l’intervalle souhaité”);
finsi;
Instructions
Vrai Faux
Condition1
Instructions0
Vrai
Condition2
Instructions00
Figure 3.4 – Imbrication de deux structures de contrôle.
3.6.4 Les conditions imbriquées

On a vu dans les sections précédentes que dans la structure de condition, on
construit des instructions. Puisque, la condition est elle même une instruction,
on pourra donc avoir une condition à l’intérieur d’une autre. C’est ce qu’on ap-
pelle l’imbrication des structures alternatives. Il est parfois primordial d’utiliser
cette imbrication pour résoudre un certain type de problème. L’organigramme 3.4
montre une imbrication de deux conditions de façon générale.
Nous allons essayer d’appliquer ça dans un problème courant.
Problème 1. Il s’agit de résoudre l’équation 3.1 du second degré suivante :
ax2 + bx + c = 0, a, b, c ∈ R (3.1)
Pour que cette équation soit du second degré, on suppose que a 6= 0. Nous
allons recevoir les valeurs des variables a, b et c par le biais du clavier de l’utili-
sateur.
Début
lire(a,b,c)
Calculer ∆
Vrai Faux
∆<0
Vrai Faux
S =∅ ∆>0
Calculer x1, x2 Calculer x
ecrire(x1,x2) ecrire(x)
Fin.
Figure 3.5 – Organigramme de la solution d’une équation du second degré (a 6=

0).
Solution : Nous savons que l’ensemble des solutions de cette équation dans R
est le suivant :
1. Aucune solution si son discriminant ∆ < 0. On dira que S = ∅, l’ensemble
des solutions est vide.
−b
2. Une solution double si ∆ = 0, i.e, S = {x}, x = .
2a
√
−b ∓ ∆
3. Sinon deux solutions distinctes : S = {x1 , x2 }, x1,2 = .
2a
A partir de ces cas, nous allons réaliser un organigramme pour résoudre n’im-
porte quelle équation du second degré, dont les valeurs a, b et c seront introduites
par un utilisateur. A l’étudiant ensuite, la tâche de traduire l’organigramme 3.5
en un algorithme.
3.7. Déroulement d’un algorithme 44
3.6.5 La structure de contrôle Selon

Nous savons maintenant qu’à partir de l’imbrication et la composition des
conditions d’une structure alternative, on peut répondre à n’importe quelle pro-
blématique de choix. Une alternative offre le choix entre deux valeurs possibles, et
si le choix se fera entre un ensemble de valeurs préalablement connus ? L’instruc-
tion Selon répond à ce type de questionnement. Regardons d’abord, la syntaxe
de cette instruction :
selon expression vaut
cas valeur 1 : instructions 1;
cas valeur 2 : instruction 2;
..
.
cas valeur n : instructions n;
autres instruction 3;
finselon;
L’expression doit avoir soit un type entier ou caractère. La partie autres de
cette instruction est optionnelle est peut donc être négligée. Nous allons essayer
de résoudre un problème qui fait appel à cette structure.
Problème 1. On souhaite dire pour un nombre entier i donné par l’utilisateur,
s’il est de la forme suivante :
ou bien

3k,

i : 3k + 1, ou bien (3.2)

3k + 2

Écrivez un algorithme qui vérifie cette propriété.
Solution :
3.7 Déroulement d’un algorithme

Le déroulement d’un algorithme est l’exécution des instruction de cet algo-
rithme, en prenant en considération l’état en mémoire (les valeurs) de toutes ces
variable, ainsi, que toutes ses sorties (affichages) sur l’écran. Cette tâche est né-
cessaire pour savoir si notre algorithme exécute bien ces instructions et résout en
conséquence, le problème pour lequel il est écrit. On parle en informatique d’un
3.7. Déroulement d’un algorithme 45
Algorithme : Multiple_de3 ;
var i : entier ;
Début
ecrire(”Donnez la valeur de i”);
lire(i);
selon (i mod 3) vaut
cas 0 : ecrire(”3k”);
cas 1 : ecrire(”3k+1”);
cas 2 : ecrire(”3k+2”);
finselon;
Fin.
Algorithme 6 : Algorithme des classes d’équivalence de 3.
déroulement en mémoire et sur écran d’un algorithme. Cette partie intervien-

dra tout le temps après avoir écrit l’algorithme pour s’assurer de sa correction.
On dira que c’est une étape nécessaire pour répondre affirmativement que notre
algorithme se termine, et rend les résultats attendues à la fin de son exécution.
Nous allons faire un déroulement de deux problèmes pour voir en détail com-
ment se fait une telle tâche. Il s’agit des exercices 9 et 8.
Problème 2.
1. Déroulez en mémoire et sur écran l’algorithme 15 du chapitre 3 précédant.
2. Déroulez en mémoire et sur écran l’algorithme 4 du chapitre ?? pour les
valeurs de x = 4 et y = 5.
3. Même question pour les de x = 12 et y = 0.
Solution : Pour tous les exercices de déroulement, on construit une table qui
contiendra toutes les variables de notre algorithme, toutes les conditions (à l’in-
térieure d’une instruction si) ainsi que l’écran.
1. Question 1 : Dans cet algorithme nous n’avons aucune instruction d’écriture,
nous aurons donc une case vide dans la partie écran.
3.8. Conclusion 46
Instr. A B C Écran
1 2
2 4
3 4 12
4 4 12 4
5 4 12 8
6 4 12 -4
7 -32 12 -4
8 140 12 -4
9 140 11 -4
2. Question 2 : Nous allons maintenant négliger les valeurs précédente et trans-

crire sur la table d’exécution que les valeurs modifiées des variables.
x y D y 6= 0 Écran
Donnez la valeur de x
4
Donnez la valeur de y
5
Vrai
0.8
D=0.8
3. Question 3 : x = 12 et y = 0
x y D y 6= 0 Écran
Donnez la valeur de x
12
Donnez la valeur de y
0
Faux
3.8 Conclusion
Nous avons jusqu’ici, les étapes préliminaires pour écrire un algorithme pro-
prement. La conception des algorithmes c’est une étape importante dans tout
3.8. Conclusion 47
processus de résolution de problèmes. L’algorithme final repose sur cette concep-

tion et des erreurs dans l’analyse des besoins ou de cette même conception faus-
sera ensuite l’algorithme. Nous allons voir dans les chapitres suivants tous les
ingrédients nécessaires à l’écriture des algorithmes.
Chapitre 4
Les variables indicées
Sommaire
1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.1.1 Différents types d’information . . . . . . . . . . . . . . . . 1
1.2 Historique de l’informatique . . . . . . . . . . . . . . . . . 2
1.2.1 Outils primitifs . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2.2 Historiques des machines . . . . . . . . . . . . . . . . . . . 2
1.3 Matériel informatique . . . . . . . . . . . . . . . . . . . . . 10
1.3.1 Mémoires . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.3.2 Processeurs . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.3.3 Périphériques . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.4 Logiciel informatique . . . . . . . . . . . . . . . . . . . . . 13
1.5 Les réseaux informatiques . . . . . . . . . . . . . . . . . . 14
1.5.1 Les différents type de réseaux . . . . . . . . . . . . . . . . 14
1.5.2 Caractéristique d’un réseau local . . . . . . . . . . . . . . 16
1.6 Topologie et fonctionnement d’un réseau . . . . . . . . . 17
1.6.1 Topologie en bus . . . . . . . . . . . . . . . . . . . . . . . 17
1.6.2 Topologie en étoile . . . . . . . . . . . . . . . . . . . . . . 17
1.6.3 Topologie en anneaux . . . . . . . . . . . . . . . . . . . . 19
1.6.4 Topologie maillé . . . . . . . . . . . . . . . . . . . . . . . 19
1.7 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.1 Introduction
Nous avons jusqu’ici vu des notions de variables simples (les cinq types vus
précédemment). Il existe un type de variable plus complexe, parmi eux, le type
tableau. Ce type permet de regrouper un ensemble de variable de même type
dans une seule variable qu’on appellera tableau de ce type.
4.2. Les structures itératives 49
Avant de parler de ces types de variables, les notions de structures itératives

s’avèrent primordiales. Les sections suivantes détailleront ces instructions avec
des exemples illustratifs.
4.2 Les structures itératives

Nous allons parler maintenant des structures itératives. Le mot itérative nous
fait penser directement à des répétitions. Pour que ce concept soit plus clair, nous
allons essayer de résoudre un problème qui fait apparaître ce besoin de répétition
sur un exemple simple.
Une structure itérative servira donc de répéter (un nombre de fois, ou suivant
certaines conditions) un ensemble d’instructions. Ce nombre de fois de répétition
va subdiviser les structures itératives en deux classes :
1. Structures itératives à nombre de répétition prédéfini :(pour).
2. Structures itératives à nombre de répétition non prédéfini : (répéter, tant
que).
4.2.1 La structure itérative pour

Dans cette instruction on connait préalablement le nombre de répétition d’une
(ou de plusieurs) instruction(s) donnée(s). La syntaxe générale d’une telle instruc-
tion est la suivante :
pour (compteur de valeur initiale à valeur finale, pas) faire

instructions;
..
.
finpour;
Ainsi nous allons exécuter les instructions à l’intérieure de cet algorithme un

nombre de fois (nombre répétition) calculé ainsi :
valeur finale − valeur initiale + 1
nombre répétition = , pas 6= 0. (4.1)
pas
Le compteur doit être une variable de type entier. De plus, si le pas est un
nombre positif, on parle d’une incrémentation de la valeur du compteur, et d’une
décrémentation dans le cas contraire. Ce pas ne doit jamais être nul.
Pour bien cerner ce concept, nous allons essayer de résoudre le problème 1

suivant :
Problème 1. On souhaite écrire sur l’écran de l’utilisateur le message ”Bonjour !”
10 fois. La solution évidente, serait d’écrire 10 instructions ecrire() au sein de
notre algorithme. Le but de cet exercice est d’expérimenter l’instruction pour.
Ce nombre de répétition pourrait être 100 par exemple. Écrivez un algorithme
qui fait cette tâche en utilisant la boucle pour.
Solution : Nous aurons besoin d’une variable de type entier qui nous servira de
compteur de la boucle. En informatique, on a l’habitude d’utiliser les lettres : (i,
j, k, . . . ). Pour respecter cette tradition nous allons déclarer une variable i de
type entier. Elle aura comme valeur initiale 1, 10 comme valeur finale et un pas
= 1. L’algorithme 7 est la solution à ce problème :
Algorithme : Exemple_pour ;
var i : entier ;
Début
pour (i de 1 à 10,1) faire
ecrire(”Bonjour !”);
finpour;
Fin.
Algorithme 7 : Un exemple simple d’instruction pour.
Ce que nous devons retenir de cet exemple simple, et que le compteur i com-
menceras par la valeur initiale (1) qui sera comparée à la valeur finale (10), si
cette condition est vrai, l’instruction (ecrire()) sera exécutée, le compteur i sera
incrémenté du pas (i devient 2), il sera comparé de nouveau avec la valeur finale.
L’exécution se termine quand la condition devienne fausse. Dans cet exercice, la
condition à vérifier est : (i ≤ valeur finale).
Nous allons imaginer un autre problème plus concret, qu’on résoudra et qu’on
déroulera, pour illustrer bien les notions de boucles.
Problème 2. On veut calculer la somme des N (donné par l’utilisateur) nombre
entier positif. Écrivez un algorithme qui réalise cette tâche.
Solution : Nous avons à calculer une certaine somme qu’on appellera S pour
un certain nombre d’entier positif (N). Si N = 4 par exemple, S sera égale à
1+2+3+4. Ainsi de façon générale pour n’importe quel nombre N on aura :
S = 1 + 2 + 3 + ··· + N − 1 + N
En notation sigma on aure :
N
X
S= i,
i=1
A partir de ça, nous saurons que nous avons affaire à une boucle pour avec i
comme compteur qui commencera par la valeur initiale 1, s’incrémentera par 1,
jusqu’à atteindre la valeur N.
Algorithme : Somme ;
var i, S, N : entier ;
Début
ecrire(”Donnez la valeur de N”);
lire(N);
S ← 0;
pour (i de 1 à N,1) faire
S←S+i;
finpour;
ecrire(”S = ”,S);
Fin.
Algorithme 8 : La somme des N premiers entiers.
Nous allons dérouler cet algorithme pour la valeur de N = 3.

i S N i≤N Écran
Donnez la valeur de N
3
0
1
V
1
2
V
3
3
V
6
4
F
S=6
4.2.2 L’instruction répéter

Après avoir vu les boucles pour, nous définissons ici les structures itératives
où le nombre d’itérations n’est pas préalablement connu. On répète un ensemble
d’instructions jusqu’à ce que certaines conditions soient satisfaites. Il s’agit dans
cette situation d’itérer les instructions à l’intérieure de cette boucle jusqu’à ce
que la Condition soit vraie.
Une syntaxe générale pour cette instruction s’écrit comme suit :
répéter
instructions;
..
.
jusqu’à Condition;
Nous pouvons reproduire le problème 2 et nous essayerons de le résoudre à

l’aide de cette instruction. La condition d’arrêt serait qu’un compteur (i), qui
nous servira pour compter le nombre d’entier à sommer, sera i > N.
Solution :
Algorithme : SommeRepeat ;
var i, S, N : entier ;
Début
ecrire(”Donnez la valeur de N”);
lire(N);
S ← 0;
i ← 1;
répéter
S←S+i;
i ← i+1;
jusqu’à (i > N);
ecrire(”S = ”,S);
Fin.
Algorithme 9 : La somme des N premiers entiers (Répéter).
4.2.3 L’instruction Tant que

Il s’agit dans cette situation d’itérer les instructions à l’intérieure de cette
boucle tant que la Condition est vraie :
tant que Condition faire

instructions;
..
.
fintq;
Problème 1. Dites pour chaque nombre saisi (N ∈ N), s’il est pair ou impair,
jusqu’à ce que N soit égale à -1 (l’utilisateur interrompt l’exécution en fournissant
la valeur -1).
Solution :
La différence entre ces deux algorithmes est que la boucle répéter exécute au
moins une fois les instructions à l’intérieur, qui n’est pas le cas de l’instruction
tant que (sur cet exemple, si N = -1 au début, l’algorithme se terminera).
Nous devons faire attention à nos algorithmes qui comprennent des instruc-
tions itératives car on risque d’avoir des boucles infinies (les conditions d’arrêts
ne seront jamais satisfaites) !
4.3. Les tableaux à une seule dimension 54
Algorithme : ParityWhile ;
var N : entier ;
Début
lire(N);
tant que N 6= -1 faire
si N mod 2 = 0 alors
ecrire(N, ” est pair”)
sinon
ecrire(N, ” est impair”)
finsi;
lire(N);
fintq;
Fin.
Algorithme 10 : Parité des nombres entiers.
1 2 3 4 5
12
Figure 4.1 – Tableau d’entiers contenant 5 valeurs.
4.3 Les tableaux à une seule dimension

Les structures itératives seront nécessaires pour ce type de variable (pour la
lecture des éléments d’un tableau par exemple). Ce tableau contiendra donc une
seule dimension (des lignes généralement) et un ensemble déterminé de valeur
d’un certain type (entier ici). La figure 4.1 nous montre une montre un tableau
de 5 valeurs entières avec la valeur 12 dans sa troisième case.
Pour mieux cerner la notion de tableaux en algorithmique, nous allons essayer
de résoudre le problème suivant :
Problème 2. Écrivez un algorithme qui calcule la moyenne des étudiants d’une
promotion donnée.
Solution : Supposant maintenant que nous voulons pas seulement calculer

la moyenne de la promotion, mais aussi sauvegarder la note de chaque étudiant
en mémoire ! Comme solution évidente, nous pouvons prévoir une variable pour
Algorithme : Moyenne ;
var i, nbrEtud, somme : entier ;
note, moy : réel ;
Début
ecrire(”Donnez le nombre d’étudiants”);
lire(nbrEtud);
somme ← 0;
pour i de 1 à nbrEtud,1 faire
ecrire(”Donnez la note de l’étudiant”,i);
lire(note);
somme ← somme + note;
finpour;
moy ← somme / nbrEtud;
ecrire(”La moyenne =”,moy);
Fin.
Algorithme 11 : La moyenne d’une promotion.
chaque étudiant. Cette solution bien qu’elle répond à notre question mais notre
algorithme ne deviendra plus lisible, du moment qu’avec un nombre d’étudiant
de 100, nous aurons 100 variables à déclarer ! Nous nous perdrons sûrement pour
retrouver nos notes. Les tableaux ont pour rôle principal de sauvegarder un en-
semble de valeurs en mémoire sous un même nom qui sera l’identificateur de notre
tableau.
4.3.1 Syntaxe de déclaration d’un tableau

Nous préciserons ici qu’un tableau représente un type à lui seul. Ce type diffère
des autres vus précédemment puisqu’il s’agit d’un ensemble complexe de donnée.
Ainsi, pour pouvoir manipuler des tableaux nous allons faire appel à un type
particulier de déclaration. Nous allons entre autre définir un nouveau type qu’on
baptisera Tableau qui va nous servir pour déclarer une collection de donnée de
même type. Cette déclaration est donnée comme suit :
Type NotreTableau : tableau de N entier ;
On définit un nouveau type (NotreTableau) qui est un tableau de N valeurs

entières. La valeur de N doit être connu préalablement (une constante) et le type

entier peut être remplacé par n’importe quel autre type de donnée.
La déclaration d’un tableau en algorithme consiste en la donnée de son iden-
tificateur, sa taille et le type des valeurs qu’il va contenir. Nous allons supposer
que la taille d’un tableau est préalablement connu.
Problème 1. Reprenons le problème 2 traité, nous allons essayer maintenant
de sauvegarder les notes de chaque étudiant (au nombre de 100) dans une même
variable (Notes).
Solution : Nous remarquons sur cet exemple que l’accès (en lecture et en
Algorithme : NotesEtudiants ;
Type NotreTableau : tableau de 100 réel ;
var i : entier ;
Notes : NotreTableau;
Début
pour i de 1 à 100,1 faire
ecrire(”Donnez la note de l’étudiant ”,i);
lire(Notes[i]);
finpour;
Fin.
Algorithme 12 : Un tableau avec les notes d’une promotion.
écriture) à la note d’un étudiant i se fait à l’aide de l’instruction Notes[i] de façon

générale.
4.3.2 Opérations sur les tableaux

Après avoir déclarer un tableau, toutes les opérations qu’on peut faire sur un
type donné, peuvent être faite sur ce tableau. En d’autre termes sur les valeurs
de ce tableau. Supposant qu’on veut ajouter un point pour l’étudiant 26, cela se
fait de la manière suivante :
Notes[26] ← Notes[26] + 1;
Cette dernière opération reste valable pour n’importe quelle autre opération
sur les réels. Notes[26] accède à la valeur de la note de l’étudiant numéro 26 dans
la liste, à laquelle elle ajoute 1, le résultat est de nouveau affecté à la même note.
4.4. Les tableaux à deux dimensions 57
(1,1) (1,2) (1,3)
13
(2,1) (2,2) (2,3)
(3,1) (3,2) (3,3)
Figure 4.2 – Matrice d’entiers de 3×3 valeurs
4.4 Les tableaux à deux dimensions

On appelle parfois un tableau à deux dimensions une matrice. La figure 4.2
nous montre un exemple d’une matrice carrée de 3×3 valeurs entières.
4.4.1 Syntaxe de déclaration d’une matrice

Nous supposons ici qu’on dispose d’un type tableau de N valeurs d’un certain
type donnée. Dans cette partie nous allons considérer notre structure NotreTableau
qui représentera un tableau de 3 valeurs entières. La déclaration qui suit nous
donne notre nouveau type Matrice :
Type NotreTableau : tableau de 3 entier ;

Type Matrice : tableau de 3 NotreTableau ;
Alors ici, la Matrice est un tableau qui contient un autre tableau de 3 entiers.
De ce fait, l’accès (en lecture et en écriture) des éléments de cette matrice se fait
de la manière suivante :
Supposons qu’on veut accéder à l’élément situé à la deuxième ligne et à la
deuxième colonne d’une matrice M (nous nous référons toujours à la matrice de
la figure 4.2). Il suffit d’écrire M[2][2].
4.4.2 Opération sur les matrices

Puisque accéder aux éléments de la matrice s’effectue en invoquant l’indice de
la ligne et celui de la colonne, nous pouvons facilement faire des opérations sur
les éléments de cette matrice de la manière suivant, à titre d’exemple :
4.5. Structures itératives imbriquées 58
M[2][2] ← 12 ;
M[1][1] ← M[2][2] - 3 ;
A ← M[1][1]-M[2][2] ; // A aura la valeur -3 ;
M[1][3] ← M[2][2] mod M[1][1] ;
M [0][0] ← M [0][0] + 100 ;
4.5 Structures itératives imbriquées

Comme on a vu pour les structures alternatives la notion d’imbrication, on
peut retrouver cette même notion dans les instructions pour, répéter et tant
que. Ce type d’instruction se manifeste beaucoup pour des notions de matrices
(des tableaux de tableaux). Contrairement aux tableaux qui ont une seule dimen-
sion (un nombre de ligne), ces matrices en ont deux (lignes et colonnes). Nous
aurons donc besoins de deux boucles imbriquées pour accéder aux éléments de
cette structure.
Pour afficher l’ensemble des valeurs de la matrice vu précédemment (cf. fi-
gure 4.2), il faut la parcourir (accéder à l’ensemble des indices donnée ici par les
petits nombres entre parenthèses) Il nous faut pour ce faire, parcourir l’ensemble
des lignes de 1 à 3 et l’ensemble des colonnes de 1 à 3, on utilise donc l’instruction
suivante :

pour j de 1 à 3,1 faire
lire(M[i][j]) ; // M est notre matrice
finpour;
finpour;
Nous invitons nos lecteurs à essayer de résoudre le problème ?? corrigé pour

mieux comprendre la manipulation des matrices.
Problème 1. Écrivez un algorithme qui prend en entrée une matrice carrée
d’ordre 3 M et qui retourne cette matrice élevée à la puissance 2.
Solution :
4.6. Conclusion 59
Algorithme : Matrice ;
Type NotreTableau : tableau de 3 réel ;
Type Matrice : tableau de 3 NotreTableau ;
var M : Matrice;
i,j : entier ;
x : réel ;
Début
pour j de 1 à 3,1 faire
lire(x);
M[i][j] ← x*x ;
finpour;
finpour;
Fin.
Algorithme 13 : Le carré d’une matrice quelconque d’ordre 3.
4.6 Conclusion
Nous avons étudier dans ce chapitres l’ensemble des structures itératives qui
servent à répéter un ensemble d’instructions sous certaines conditions. Deux nou-
veaux types de données ont émergé : Les tableaux. Manipuler des données de ce
type nécessite l’utilisation des structures itératives (imbriquées parfois).
Le rôle principal de ces types de données est de sauvegarder en mémoire un
ensemble de variables (dont on connait le nombre) de même type. Toutes les
opérations connus sur un type (primitif) de données seront ensuite valables sur
les tableaux d’une et de deux dimensions. Il suffit de respecter les opérations
d’accès aux éléments de ces structures.
Annexe A
Exercices divers
A.1 Codage de l’information

Exercice 1. Décoder les nombres ci-dessous :
(1110001)2 = · · · (11111011000)2 = · · · (11111111)2 = · · ·
(341)16 = · · · (11111111)2 = · · · (11010)16 = · · ·
Exercice 2. Codage :
1. Coder en binaire les nombres ci-dessous :
(57)10 = · · · (168)10 = · · · (255)10 = · · ·
2. Coder en hexadécimal les nombres ci-dessous :

(2016)10 = · · · (255)10 = · · · (400)10 = · · ·
Exercice 3. Transcodage :
1. Transcoder les nombres ci-dessous en base 2 :
(A8)16 = · · · (C5)16 = · · · (4FF0)16 = · · · (806)16 = · · ·
2. Transcoder les nombres ci-dessous en base 16 :

(11100111)2 = · · · (1100110011)2 = · · ·
(1000011111000)2 = · · · (1010101010)2 = · · ·
Exercice 4. Nombre signés :

1. Coder les valeurs suivantes en complément à 2 : 0, 10, −10 and −127.
2. Coder −15 en complément à 2 sur 1 octet.
3. Décoder cette valeur binaire 10100010 représentée en complément à 2.
Exercice 5. Prouvez l’égalité suivante :
(b)10 = (10)b , ∀b ∈ N, b > 1.
A.2. Identificateurs, expression, Si et Déroulement 61
A.2 Identificateurs, expression, Si et Déroulement

Exercice 6. A partir des identificateurs suivants, dites quels sont ceux qui sont
correctes ? Corrigez les identificateurs invalides ensuite :
A Azerty A-zer-ty Exo-1 Exo_2 Var
F% AB Un_id MAX(A,B) français lire
A_ 5ème_B6 Nom.2 EX97 1 A_1 Ex17
Exercice 7. Évaluez les différentes expressions suivantes :

1. 3^2+4
2. 3^(2+4)
3. 17 mod 10 div 3
4. 12*3+5
5. 5.*4.*9.^2
6. E Ou F Et G avec E=Vrai, F=Faux et G=Vrai.
7. 7+9/3-10*2
Correction 1. Les évaluations :

1. 13
2. 729
3. 1
4. 31
5. 1620
6. Vrai
7. -10
Exercice 8. Écrivez un algorithme qui calcule la division de deux nombres réels

x et y.
Correction 2. Voici l’algorithme 14 qui réalise l’opération de division :

A.3. Structures itératives 62
Algorithme : Division ;
var x, y, D : réel ;
Début
ecrire("Donnez la valeur de x");
lire(x);
ecrire("Donnez la valeur de y");
lire(y);
D ← x/y;
ecrire("D = ",D);
Fin.
Algorithme 14 : Division de deux nombres réels (y 6= 0).
Exercice 9. Soit l’algorithme suivant, donnez les valeurs des variables A, B et

C après l’exécution de chaque instruction de cet algorithme !
Algorithme : PGCD ;
var A, B, C : entier ;
Début
A ← 2;
A ← A+2;
B ← A*2+A;
C ← 4;
C ← B-C;
C ← A-C ;
A ← (B-A)*C ;
A ← B+C*A;
B ← (A+C)/B;
Fin.
Algorithme 15 : Déroulement d’un algorithme.
Exercice 10. Utilisez la fonction mod pour vérifier la parité d’un nombre entier
positif m ∈ N.
A.3 Structures itératives

Exercice 11. Écrivez un algorithme qui calcule et affiche la somme suivante :
S = N + (N − 1) + · · · + 2 + 1
Exercice 12. Écrivez un algorithme qui calcule et affiche le miroir de la conver-

sion binaire d’un nombre décimal. Par exemple si on prend N = 13 :
(13)10 = (1101)2 , ^2 = (1011)2 .

(1101)
Ainsi notre algorithme nous fournira pour N = 13, la sortie (1011)2
Exercice 13. Écrivez l’algorithme qui détermine pour toute pair de nombres
entiers (a, b), saisies au clavier, le plus grand diviseur commun, PGCD(a,b).
Correction 3. Voici l’algorithme d’Euclide :

Algorithme : PGCD ;
var A, B, r : entier ;
Début
lire(A,B);
tant que (B != 0) faire
r ← A mod B ;
A←B;
B←r;
fintq;
ecrire(”PGCD = ”,A);
Fin.
Exercice 14. Écrivez un algorithme qui calcule une approximation de e donnée

par la formule suivante :
1 1 1 1
e=1+ + + + ··· +
2 6 24 N (N − 1) · · · 1
Indications 1. n
X 1
e=
i=0
i!
π
Exercice 15. Écrivez un algorithme qui calcule une approximation de donnée
2

π 22 44 20 20
' ···
2 13 35 19 21
Indications 2. Il suffit de voir que :

N
π Y 2k 2k
'
2 k=1 2k − 1 2k + 1
π
Exercice 16. Écrivez un algorithme qui calcule une approximation de donnée
4
π 1 1 1
' 1 − + − + ···
4 3 5 7
Indications 3. On peut écrire :
n
π X (−1)i
'
4 i=0
2i + 1
Exercice 17. Écrivez un algorithme qui calcule une approximation de cos(x)

pour chaque x ∈ R donné, à l’aide de la formule suivante :
x2 x4 x2n
cos(x) ' 1 − + + · · · + (−1)n
2! 4! (2n)!
Indications 4. On peut écrire :

n
X x2i
cos(x) ' (−1)i
i=0
(2i)!

Cours TD

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours TD

Transféré par

Droits d'auteur :

Formats disponibles

i

Table des matières iii

Table des figures vi

Liste des tableaux vii

1 Bureautique & Technologie Web 1

2.2.5 Conversion entre les différentes bases . . . . . . . . . . . . 22

3 Notions d’algorithme et de programme 26

4 Les variables indicées 48

4.2.3 L’instruction Tant que . . . . . . . . . . . . . . . . . . . . 53

1.1 Battons de John Napier 1617. . . . . . . . . . . . . . . . . . . . . 3

3.1 Différentes variables . . . . . . . . . . . . . . . . . . . . . . . . . . 29

4.1 Tableau d’entiers contenant 5 valeurs. . . . . . . . . . . . . . . . . 54

2.1 Table de codage entre les bases 2, 10 et 16. . . . . . . . . . . . . 24

3.1 Table ASCII pour quelques caractères. . . . . . . . . . . . . . . . 32

1 Schéma type d’un algorithme. . . . . . . . . . . . . . . . . . . . . . 28

7 Un exemple simple d’instruction pour. . . . . . . . . . . . . . . . . 50

14 Division de deux nombres réels (y 6= 0). . . . . . . . . . . . . . . . 62

La révolution informatique fait gagner un temps fou aux hommes,

1.1.1 Différents types d’information

— Sons, vidéos, images.

1.2 Historique de l’informatique

1.2.1 Outils primitifs

1.2.2 Historiques des machines

Figure 1.1 – Battons de John Napier 1617.

Figure 1.2 – Battons de John Napier 1617.

Figure 1.3 – Premier ordinateur ENIAC en 1946.

Première génération (1936-1956)

Deuxième génération (1955-1963) Cette génération sera marqué par l’in-

Figure 1.4 – Architecture à mémoire partagée de Von Neuman en 1948.

Figure 1.5 – Circuit intégré.

tain, chercheurs des Laboratoires Bell.

Troisième génération (1963-1971)

Figure 1.6 – Mini-ordinateur PDP8 de 1965.

Figure 1.7 – Microprocesseur Intel C4004 de 1971.

Ordinateur personnel L’invention des PC ("Personnel Computers") remonte

Figure 1.8 – Premeir odinateur personnel d’IBM.

1.3 Matériel informatique

1.3.1.1 Organisation de la RAM

1.3.1.2 Opérations sur la RAM

Figure 1.10 – Mémoire morte ROM.

Figure 1.11 – Mémoire vive RAM.

1.4 Logiciel informatique

1.5 Les réseaux informatiques

1.5.1 Les différents type de réseaux

1.5.1.1 Le réseau local LAN (Local Area Network)

1.5.1.2 Le réseau MAN (Metropolitan Area Network)

1.5.1.3 Le réseau WAN (Wide Area Network)

1.5.2 Caractéristique d’un réseau local

Les éléments d’interconnexion : Plusieurs types de matériels existent afin

1.6 Topologie et fonctionnement d’un réseau

1.6.1 Topologie en bus

1.6.2 Topologie en étoile

du matériel. On peut facilement déplacer un appareil sur le réseau. La panne

1.6.3 Topologie en anneaux

1.6.4 Topologie maillé

peut avoir plusieurs topologies. Ces topologies dépendent de l’objectif de l’utili-

2.2 Différents systèmes de numérations

2.2.2 La numération décimale

en une somme de facteurs de 10n . Exemples :

(2508)10 = (8 × 100 + 0 × 101 + 5 × 102 + 2 × 103 )10

2.2.3 La numération binaire

2.2.4 La numération hexadécimale

(2F10D)16 = (13 × 160 + 0 × 161 + 1 × 162 + 15 × 163 + 2 × 164 )