Book Algo

UNIVERSITE CADI AYYAD
ÉCOLE SUPÉRIEURE DE
TECHNOLOGIE-ESSAOUIRA
Introduction à l’algorithmique et la
programmation
DUT : Informatique & Sciences des données
FAHD KARAMI
fa.karami@uca.ma
ANNÉE : 2013-2019
2
Contents
Table des matières i
1 Système informatique v
1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . v
1.2 Composants de l’ ordinateur . . . . . . . . . . . . . . . . . . . . . . . v
1.2.1 Les composants matériels . . . . . . . . . . . . . . . . . . . . vi
1.2.2 Les composants logicielle . . . . . . . . . . . . . . . . . . . . vii
1.3 Langage machine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . vii
1.4 Rappel sur la numération . . . . . . . . . . . . . . . . . . . . . . . . viii
1.4.1 Conversion de base . . . . . . . . . . . . . . . . . . . . . . . . viii
1.4.2 Codage des caractères . . . . . . . . . . . . . . . . . . . . . . ix
2 Algorithme et Langage de programmation xi

2.1 Notion d’Algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . xi
2.2 Structure d’un algorithme . . . . . . . . . . . . . . . . . . . . . . . . xii
2.3 Les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xii
2.3.1 Identificateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . xiii
2.3.2 Type des variables . . . . . . . . . . . . . . . . . . . . . . . . xiv
2.4 Affectation des variables . . . . . . . . . . . . . . . . . . . . . . . . . xvii
2.4.1 Constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xviii
2.4.2 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xix
3 Les entrées & Sortie: xxi
i
ii CONTENTS
3.0.1 Instruction de lecture . . . . . . . . . . . . . . . . . . . . . . xxi

3.0.2 Instruction d’écriture . . . . . . . . . . . . . . . . . . . . . . xxii
3.1 Exemples d’application . . . . . . . . . . . . . . . . . . . . . . . . . . xxii
4 Les structures de contrôle xxv

4.1 Les instructions conditionnelles . . . . . . . . . . . . . . . . . . . . . xxv
4.1.1 Les conditions composées . . . . . . . . . . . . . . . . . . . . . xxxi
4.2 Les structures de répétition . . . . . . . . . . . . . . . . . . . . . . . xxxiii
4.2.1 La boucle TantQue . . . . . . . . . . . . . . . . . . . . . . . . xxxiii
4.2.2 La boucle Faire ... TantQue . . . . . . . . . . . . . . . . . . . xxxvi
4.2.3 La boucle définie: Pour . . . . . . . . . . . . . . . . . . . . . . xxxvii
4.2.4 Boucle imbriquée . . . . . . . . . . . . . . . . . . . . . . . . . xxxix
4.2.5 Lien entre la boucle Pour et TantQue . . . . . . . . . . . . . xxxix
4.3 Choix de type de boucle . . . . . . . . . . . . . . . . . . . . . . . . . xlii
4.3.1 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xlii
5 Les Fonctions et procédures xlv

5.1 Sous algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xlv
5.1.1 Les fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . xlvii
5.1.2 Procédure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . l
5.1.3 Les paramètres d’un sous algorithme . . . . . . . . . . . . . . lii
5.1.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . liv
6 Les Tableaux lvii

6.0.1 Tableaux à une dimension . . . . . . . . . . . . . . . . . . . . lvii
6.0.2 Tableaux à deux dimension . . . . . . . . . . . . . . . . . . . lix
6.0.3 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . lxii
Préface
Ce document est une initiation à l’algorithmique et la programmation, il est destiné

aux étudiants de DUT, DEUG, DEUST ayant un parcours mathématique et/ou
Informatique. Ce cours propose les bases pour débuter la programmation. Il est
redigé dans le but de remplir les objectifs suivants:
• Fournir des notions de base pour décrire les algorithmes
• Présenter les concepts permettant de structurer et de réutiliser les algorithmes:

les fonctions et les procédures
• Explorer les structures de données linéaires: tableaux et listes.
iii
iv CONTENTS
Chapter 1
Système informatique
1.1 Introduction
Le terme Informatique désigne la science du traitement automatique de l’information
et qui est considérée comme le support des connaissances humaines et des communi-
cations dans différents domaines. En anglais (US) on utilise Computing Science
tant dis que Informatics en anglais grande Bretagne.
Définition 1.1.1 (Système informatique) Un système informatique est un en-

semble des moyens informatiques et de télécommunications ayant pour finalité d’élaborer,
traiter, stocker, présenter ou détruire des données.
En d’autres termes, nous définisons un système informatique comme un ensemble

constitué de composants matériels et logiciels. Les composants d’un ordinateur ou
PC (Personal Computer), désigne le matériel se situant à l’intérieur de l’ordinateur,
contrairement aux périphériques externes qui sont reliés par des moyens de com-
munication. Nous décriverons, ces composants internes qui nous permettrons de
se familiariser avec le matériel informatique de votre machine : le processeur, la
mémoire (RAM), le disque dur, la carte mère, carte graphique,....
1.2 Composants de l’ ordinateur

Dans cette partie, nous découvrirons les principales unités fonctionnelles d’un ordi-
nateur, ce dernier désigne une machine effectuant des opérations logiques et arithmétiques
consécutifs.
v
vi CHAPTER 1. SYSTÈME INFORMATIQUE
1.2.1 Les composants matériels

Un système à base de microprocesseur est composé des trois éléments :
• La mémoire centrale permet de stocker les données.
• Unité de centrale permet lde réaliser des traitements.
• Les périphériques: écran, clavier, souris, ...
Ces composants sont interconnectés via trois bus : le bus de données, le bus d’adresses
et le bus de contrôles etde commandes. Où un bus représente plusieurs pistes
électroniques qui sont reliées au microprocesseur. Ils assurent la communication
interne et externe du microprocesseur.
Figure 1.1: Cette figure représente une architecture du système
Le bus coordonne les échanges d’informations et permet l’échange des données.

Il introduit des délais d’attente lorsque des informations sont envoyées àux un
périphériques.
Définition 1.2.1 (Mémoire centrale) La mémoire centrale est un organe dont

la seule fonctionnalité consiste à pouvoir stocker de l’information et la préserver
intacte pour pouvoir la restituer à la demande.
1.3. LANGAGE MACHINE vii
La mémoire vive appelé RAM est une memoire temporaire, après chaque opération,
les données ne sont pas conservées et sont définitivement perdues à l’extinction de
l’ordinateur.
Généralement, un composant électronique n’est capable que de mémoriser des ten-
sions: BIT (Binary DigiT) et qui représente l’unité de stockage élémentaire. Les
informations sont codées en binaires. En fonction de type d’ordinateur, un mot
mémoire est composé de 2 (16 bits) ou 4(32 bits) octets.
Définition 1.2.2 (Le processeur) Le processeur est considéré comme le cerveau

de l’ordinateur. Il réalise les traitements et les calculs nécessaires au fonctionnement
de l’ordinateur.
De manière générale la fréquence du processeur, i.e. la vitesse à laquelle tourne

détermine la rapidité de votre ordinateur. Cette fréquence s’exprime en Giga Hertz
(GHz). Actuellement, les ordinateurs sont devenus multicoeurs i.e. ils possèdent
plusieurs processeurs permettant d’ effectuer rapidement les calculs ou les tâches
demandées.
1.2.2 Les composants logicielle

Les composants de l’ordinateur comme l’unité centrale et les autres périphériques
associés, ne sont pas suffisant pour faire fonctionner la machine, d’ou un système
d’exploitation (Ex : windows, unix, mac os, linux, ...) est nécessaire. En effet, un
système d’exploitation est un logiciel qui pilote les dispositifs matériels et recoit des
instructions de l’utilisateur ou d’autres applications. Dans un ordinateur, le système
d’exploitation gère la mémoire ainsi que les processeurs. Il fait également fonction-
ner les autres périphériques comme le clavier, lécran, la souris, etc. Le système
d’exploitation comporte aussi l’interface avec l’utilisateur permettant d’ afficher les
fenêtres et exposer leurs contenu.
Les autres programmes ou logiciels d’application s’exécutent généralement en s’appuyant
sur le système d’exploitation. Ces programmes peuvent être très divers : logiciels
de bureautique, logiciels de calcul, systèmes d’ informations, environnements de
développement ...
1.3 Langage machine

Le codage est une opération permettant la construction d’ une bijection entre une
information et une suite de valeurs composée de 0 et de 1 . Toute information doit
viii CHAPTER 1. SYSTÈME INFORMATIQUE
être codée en binaire pour être exploitable par un ordinateur. C’est le cas pour
les nombres et les caractères, les sons, les images ... .Toutes communications à
l’intérieur de l’ordinateur sont faites avec des signaux électriques
• 0 éteint i.e. absence de signal électrique
• 1 allumé i.e. présence de signal électrique
1.4 Rappel sur la numération

Les Système à base quelconque se basent sur le fait que tout nombre décimal N se
décompose d’une manière unique dans la base B comme suit:
N = an ×B n +an−1 ×B n−1 +...+a1 ×B 1 +a0 ×B 0 +a−1 ×B −1 +a−2 ×B −2 +...+a−m ×B −m
où 0 ≤ ai < B pour tout −m ≤ i ≤ n et on écrit

N = an an−1 ..a1 a0 a−1 a−2 a−m
B
Exemples:
Lorsque B = 10 c’est la base décimal et on convient que (...)10 = ...
467, 92 = 4 × 102 + 6 × 101 + 7 × 100 + 9 × 10−1 + 2 × 10−2
10
1010, 101 = 1×23 +0×22 +1×21 +0×20 +1×2−1 +0×2−2 +1×2−3 = 10, 625
2 10
Remark 1.4.1 Un même nombre peut être représenté dans plusieurs bases
• 123 en base 10 (décimal)
• 1111011 en base 2 (binaire)
• 173 en base 8 (octale)
• 7B en base 16 (hexadécimale)
1.4.1 Conversion de base

Pour convertir un nombre N a une base B, nous développeons le nombre selon les
puissances de la base B. Pour ce faire nous utilisons la division euclidienne de N
par B i.e. N = B × q + r avec 0 ≤ r ≤ B.
1.4. RAPPEL SUR LA NUMÉRATION ix
De la base 10 à la base 2
L’opération consiste a diviser le nombre par 2 puis réitérer l’opération en remplacant

le nouveau numérateur par précédent quotient jusqu’à ce que ce dernier soit nul. La
suite inverse des restes représente le nombre binaire
n
X
nombre = chiffrei × 2i
i=0
Exemples:
• 9 en base 10 vaut 1001 en base 2 et on écrit 9 = (1001)2 parce que

9 = 1 × 23 + 0 × 22 + 0 × 21 + 1 × 20
• 123 en base 10 vaut 1111011 en base 2 et on écrit 123 = (1111011)2 parce que
123 = 1 × 26 + 1 × 25 + 1 × 24 + 1 × 23 + 0 × 22 + 1 × 21 + 1 × 20
De la base 2 à la base 10
L’opération consiste a additionner la multiplication du nombre représenté par

chaque chiffre avec la puissance de 2 correspondant au rang du chiffre.
Exemple: le nombre 1011001 en base binaire vaut 89 en base 10 parce que
1 × 26 + 0 × 25 + 1 × 24 + 1 × 23 + 0 × 22 + 0 × 21 + 1 × 20 = 64 + 16 + 8 + 1 = 89
1.4.2 Codage des caractères

Tous les caractères (les lettres majuscules et minuscules, les chiffres, les caractères
de ponctuation et les caractères spéciaux ...) sont représentés par des codes binaires.
Parmi les codes possibles, il y a le code ASCII (American Standard Code for Infor-
mation Interchange). Les tables ASCII, se trouve sur wikipedia.
Exemple:
x CHAPTER 1. SYSTÈME INFORMATIQUE
• la lettre A est codée 65 en décimal
• la lettre B est codée 66 en décimal
• et la lettre a est codée 91 en décimal.

Chapter 2
Algorithme et Langage de
programmation
2.1 Notion d’Algorithme

Le mot algorithme provient du nom d’un cèlèbre mathématicien arabe de la première
moitié du IXe siècle: Muhammad ibn Musa al Khwarizmi.
Définition 2.1.1 Un algorithme est suite finie d’opérations (instructions) con-

stituant un schéma de résolution d’un problème donné.
Pour fonctionner, un algorithme doit donc contenir des instructions compréhensibles

par celui qui devra l’exécuter. Enfin, les ordinateurs, ne sont capables de comprendre
que quatre catégories d’instructions. Ces quatre familles d’instructions sont:
• Affectation de variables
• Lecture & Écriture
• Instructions conditionnelles (les tests)
• Instructions de répétition ( les boucles)
Un algorithme est une combinaison de ces quatre instructions ou ordre. Il peut y en

avoir quelques unes, ou bien plusieurs dans certains programmes de taille importante.
xi
xii CHAPTER 2. ALGORITHME ET LANGAGE DE PROGRAMMATION
2.2 Structure d’un algorithme

Le développement d’un algorithme doit suivre impérativement plusieurs règles. Ainsi,
que la structure suivante :
Algorithme N om de algorithme
Début
Instruction1;
Instruction2;
...
InstructionN;
Fin
Chaque ligne contient une seule instruction et l’exécution de l’algorithme con-

siste a réaliser tous les instructions ligne après ligne dans l’ordre.
2.3 Les variables

Tout traitement de données nécessite deux concepts majeurs: besoin permanence de
stocker provisoirement des valeurs et une unité de raisonnement (ou bien de traite-
ment). Les variables présentent le concept algorithmique qui satisfait ce besoin.
Une variable est donc un emplacement dans la mémoire de l’ordinateur qui est ca-
pable de porter des valeurs spécifiques (informations), cet emplacement est ciblé par
une étiquette (nom de variable) permettant au programmeur d’accéder au contenu
de la variable.
Définition 2.3.1 Une variable désigne un emplacement mémoire afin de stocker

une valeur. Elle est définie par
• Un nom unique appelé identifiant
• Un type caractérisant l’ensemble des valeurs qu’ elle peut prendre
• Une valeur (contenu de l’espace mémoire) attribuée et peut être modifiée .
Les variables utilisées au cours de l’algorithme sont déclarées après le nom de

l’algorithme et il faut mentionné l’ identifiant et le type de la variable. La
syntaxe d’un algorithme déclarant une variable devient
2.3. LES VARIABLES xiii
Figure 2.1: Cette figure représente la structure de RAM. Les casiers contenant des
chiffres représentent les variables. Les mots ”nombreA”, ”nombreB” and ”nombreC”
représentent les noms des variables
Variables var1, var2 ..., varN : TypeVariable;
Début
Instruction1;
Instruction2;
...
InstructionN;
Fin
2.3.1 Identificateurs
Le choix des noms de variables est soumis à quelques règles qui varient selon le
langage, mais en général
• Le nom de la variable doit commencer par une lettre alphabétique (en minus-
cule pour certaine langage)
• Doit être constitué uniquement de lettres, de chiffres et du soulignement
xiv CHAPTER 2. ALGORITHME ET LANGAGE DE PROGRAMMATION
• Le nom de la variable ne doit pas comporter des caractères de ponctuation et

des espaces
• La longueur du nom doit être inférieure à la taille maximale spécifiée par le

langage utilisé.
• Le nom de la variable doit être différent des mots réservés du langage (par
exemple en langage C: int, float, else, switch, case, default, for, main,
return,...)
Exemples:
• L’identificateur A1 est valide par contre 1A est invalide.
• Identificateurs valides: info2019, dut 2019
• Identificateurs invalides: info 2019, dut-2019, licence;2019
Pour des raisons de lisibilité du code, il faut choisir des noms significatifs qui
décrivent les données manipulées
Exemple: totalVentes2006, prix TTC, prix HT
Remark 2.3.2 En pseudo-code algorithmique, nous allons respecter les règles citées,
même si on est libre dans la syntaxe
2.3.2 Type des variables

Le type d’une variable détermine l’ensemble des valeurs qu’elle peut prendre. Une
valeur peut être interpréter comme une suite des chiffres binaire. Puis, en choisissant
un type et en utilisant un table de codage (ASCII par exemple), On associe à cette
chaine une valeur compréhensible par l’humain. D’où, la spécification de type d’un
variable est obligatoire lors de déclaration.
Type numérique
Les variables de type numériques sont les variables de type entier ou réel. Lorsqu
on réserve un octet pour coder un nombre nous pourrions coder 28 = 256 valeurs
différentes. i.e. les nombres entiers de 1 à 256, ou bien de 0 à 255, ou bien de −127 à
+128.... Lorsqu’on réserve deux octets, nous pourrions coder jusqu’au 65536 valeurs.
2.3. LES VARIABLES xv
en résumé le type de codage (autrement dit, le type de variable) choisi pour un nom-
bre va spécifier les valeurs maximales et minimales des nombres pouvant être stockés
dans la variable; la précision de ces nombres (dans le cas de nombres décimaux).
Les langages de programmation, offrent un ensemble de types numériques, dont le
détail est peuvent de varier d’un langage à l’ autre, mais généralement nous retrou-
veons les types suivants:
Type numérique valeurs
Byte (1octet) 0 à 255
Entier Simple (2 octet) -32 768 à 32 767
Entier Long (4 octet ou 8 octet) -2 147 483 648 à 2 147 483 647
Réel simple (4 octet) 1, 40 × 10−45 à 3, 40 × 1038 valeurs positives
Réel double (8 octet) 4, 94 × 10−324 à 1, 79 × 10308 valeurs positives
Remark 2.3.3 La question que nous pouvons se poser est pourquoi ne pas déclarer
toutes les variables numériques en réel double pour s’assurer qu’ il n’y aura pas
de problème. Sauf, q’un bon algorithme ne se contente pas de répondre seulement
au besoin fonctionnel et pour un programmes de grande taille, l’abus de variables
surdimensionnées peut conduire a un ralentissements au niveau de l’exécution, voire
un plantage de l’ordinateur.
Les opérations uitisables sur les éléments de ces deux types sont tous les opérateurs
arithmétiques classiques : l’addition (+), la soustraction (-), le produit (?) et la
division (/). On pourra utiliser, sur les éléments de type entier ou réel, les opérateurs
de comparaison classique:
> < != = ≤ ≥.
De plus, il y a d’autre opérateurs spécifiques aux entier : la division entière (Div ou
bien /) et le modulo (Mod ou %). Par exemple
9 / 4 égale à 2 et 9 % 4 égale à 1.
Pour les opérateurs arithmétiques donnés, l’ordre de priorité est le suivant (du plus
prioritaire au moins prioritaire) : (? ⇒ / ⇒ % ⇒ + ⇒ −) par exemple
2+3?7 vaut 23.
xvi CHAPTER 2. ALGORITHME ET LANGAGE DE PROGRAMMATION
En cas de besoin (ou de doute), on utilise les parenthèses pour indiquer les opérations
à effectuer en prioriténpar exemple: (2 + 3) ? 7 vaut 35.
Les types alphanumérique
Les variables peuvent contenir d’autres informations que les nombres, par exemple
lorsqu’ on souhaite stocker un nom, nous pourrions utilisér le type alphanumérique.
En effet, ils’agit d’un domaine constitué des caractères alphabétiques, numériques et
de ponctuation. A ce sujet, nous devrions pas confondre entre la valeur entière 3 et le
caractère ’3’ noté entre simple quotes. Il est a noté qu à chaque caractère est associé
une valeur numérique entière. Comme nous l’avons dèja signalé précédemment la
lettre ’A’ correspond à la valeur 65 en code ASCII .
Nous signalons que, la précédence des caractères dans l’alphabet d’une machine
est dépendante du code de caractères utilisé. Pour le code ASCII, nous pouvons
constater l’ordre suivant:
0, 1, 3, .., 9..A, B, ..., Z, a, b, ..z
Les symboles spéciaux (’ ,+ ,- ,/ , ,] , ...) et les lettres accentuées (é ,è ,à ,û , ...) se
trouvent répartis autour des trois grands groupes de caractères (chiffres, majuscules,
minuscules). Leur précédence ne correspond à aucune règle d’ordre spécifique.
Exemple : ’0’ est inférieur à ’Z’ et noter ’0’ < ’Z’.
Type logique booléen :
Le domaine des booléens est l’ensemble formé par les deux valeurs: Vrai et Faux.
Les opérations possibles sur les booléens sont les opérations logiques: disjonction
(OU), conjonction (ET) et la négation (NON).
La table de vérité donne la réponse Vrai et Faux des opérations logiques
Opération ET Faux Vrai Opération OU Faux Vrai
Faux Faux Faux Faux Faux Vrai

Vrai Faux Vrai Vrai Vrai Vrai
Exemple:
2.4. AFFECTATION DES VARIABLES xvii
Algorithme M on Seconde algorithme
Variables i, j, k: Entiers;
x,y: Réels;
oK: Boolean;
car1, car2: Caractères;
ch1, ch2: Chaı̂ne de caractères;
Début
Bloc d’instructions;
Fin
2.4 Affectation des variables

L’affectation est une opération permettant de modifier la valeur d’une variable. La
syntaxe de l’affectation est la suivante :
nomV ariable ← valeur;
où < nomV ariable > est le nom de la variable dont on souhaite modifer la
valeur, < valeur > est la valeur que l’on veut placer dans la variable. Cette valeur
doit être de même type que la variable. Par exemple, l’opération
nomV ariable ← 25;
permet de placer la valeur 25 dans la variable nomVariable. Si nomVariable contenait

préalablement une valeur, elle sera écrasée et remplacée par la nouvelle. Il est
également possible d’affecter a une variable le résultat d’une opération arithmétique.
nomV ariable ← 25 + (7 ? 2);
Nous pourrions affecter à une variable la valeur d’une autre variable.i.e.
nomV ariable1 ← 25;

nomV ariable2 ← nomV ariable1 + 5;
La deuxième instruction lit la valeur de nomVariable1, lui additionne 5, et recopie le

résultat dans nomVariable2. cette affectation ne modifie que ce qui est à gauche de la
xviii CHAPTER 2. ALGORITHME ET LANGAGE DE PROGRAMMATION
flèche. L’affectation n’est pas commutative : nomV ariable2 ← nomV ariable1; est
différente de nomV ariable1 ← nomV ariable2; ce qui est différente d’une équation
mathématique : nomV ariable ← nomV ariable + 1; a un sens en langages de
programmation, par contre nomV ariable + 1 ← 2; n’est pas possible en langages de
programmation et n’est pas équivalente à nomV ariable ← 1;
Exemple: Quelles sont les valeurs des variables aprés l’exécution de l’agorithme
suivante ?
Algorithme M on P remier algorithme
Variables varA, varB, varC, varD : Entiers;
Début
varA ← 1;
varB ← 2;
varC ← 3;
varD ← varA;
varA ← varC + 1;
varB ← varD + varC;
varC ← varD + 1;
Fin
Réponse: les valeurs des variables aprés l’exécution de l’agorithme seront:

Instruction varA varB varC varD
Début
varA ← 1; 1
varB ← 2; 1 2
varC ← 3; 1 2 3
varD ← varA; 1 2 3 1
varA ← varC + 1; 4 2 3 1
varB ← varD + varC; 4 4 3 1
varC ← varD + 1; 4 4 2 1
2.4.1 Constantes
Une constante est un emplacement mémoire dont la valeur reste figée durant le
déroulement d’un algorithme, le type d’une constante découle de sa valeur.
Constantes N omConstante ← V aleur;

2.4. AFFECTATION DES VARIABLES xix
Voilà un exemple d’application
Constantes P i ← 3.141559;
2.4.2 Exercices
Exercice 2.4.1 Donnez les valeurs des variables varA, varB et varC apràs exécution
des instructions suivantes ?
Algorithme Exo0 algorithme
Variables varA, varB, varC : Entiers;
Début
varA ← 3;
varB ← 7;
varA ← varB;
varB ← varA + 5;
varC ← varA + varB;
varC ← varB − varA;
Fin
Exercice 2.4.2 Donnez les valeurs des variables varA et varB apràs exécution des
instructions suivantes ?
Algorithme Exo0 algorithme
Variables varA, varB :Réels ;
Début
varA ← 1;
varB ← 2;
varA ← varB;
varB ← varA;
Fin
Les deux dernières instructions permettent-elles d’échanger les valeurs de varA et

varB ? Sinon écrire un algorithme permettant d’échanger les valeurs de deux vari-
ables varA et varB.
xx CHAPTER 2. ALGORITHME ET LANGAGE DE PROGRAMMATION
Chapter 3
Les entrées & Sortie:
Les instructions de lecture et d’écriture permettent à la machine de communiquer

avec l’utilisateur. La plupart des algorithmes, ont besoin de communiquer avec
l’utilisateur, soit pour envoyer des messages, des données à l’utilisateur ou bien
pour stocker valeurs fournis par l’utilisateur.
3.0.1 Instruction de lecture
La lecture permet d’éntrer des donnés à partir du clavier
Algorithme Lecture var
Variables var : Entier;
Début
Lire(var);
Fin
Cette instruction permet d’affecter une valeur saisi au clavier à la variable nommée
var.
Remark 3.0.1 Le programme s’arrête lorsqu’ il rencontre une instruction Lire et

ne se poursuit qu’après la frappe d’une valeur au clavier et de la touche Entrée.
xxi
xxii CHAPTER 3. LES ENTRÉES & SORTIE:
3.0.2 Instruction d’écriture
L’instruction d’écriture en algorithmique est décrite comme suit :
Algorithme Ecriture var
Variables varE : Réel;
Début
varE ← 5;
Ecrire(varE);
Ecrire(”Bonjour tous les informaticiens de l’ESTE”);
Fin
La Première instruction Ecrire permet l’écriture (ou l’affichage) de la valeur de la

variable varE à l’écran. La deuxième instruction représente l’ordre de l’affichage de
la chaine des caractères ”Bonjour tous les informaticiens de l’ESTE”.
Dans le cas ou, nous combinons des messages textes avec des variables dans les
instructions d’écriture, nous les séparerons par des virgules. Nous rappelons, que
tous ce qui est delimité par des guillemets ”...” est considéré comme chaine des
caractères constante et sera affiché tel quel, alors tout ce qui n’est pas delimité par
des guillemets est vu comme variable qui doit etre declaré auparavant. Avant de
lire une variable, il est fortement conseillé d’écrire des messages à l’écran, afin de
prévenir l’utilisateur de ce qu’il doit frapper.
3.1 Exemples d’application
• Ecrire un algorithme qui demande un nombre réel à l’utilisateur, puis qui

calcule etaffiche le double de ce nombre?
Algorithme Calcul double
Variables val, res : réels;

Début
Ecrire(”Entrez la valeur: ”);
Lire(val);
res ← 2 ? val;
Ecrire(”Le double de”, val,”est:”, res);
Fin
3.1. EXEMPLES D’APPLICATION xxiii
• Ecrire un algorithme qui demande le nom et le prénom à l’utilisateur, puis

affiche ensuite le nom complet?
Algorithme Affichage Nom complet
Variables nom, prenom, nomc omplet : chaine de caractères;

Début
Ecrire(”Entrez votre Nom: ”);
Lire(nom);
Ecrire(”Entrez votre Prenom: ”);
Lire(prenom);
nom complet ← nom & prenom;
Ecrire(”Votre nom complet est ”, nom complet );
Fin
• Ecrire un programme qui lit le prix HT d’un article, le nombre d’articles et le

taux de TVA, et qui fournit le prix total TTC correspondant. Faire en sorte
que des libelles apparaissent clairement?
Algorithme P rix T T C
Variables prix HT, T V A, prix T T C : réels;

N : entier;
Début
Ecrire(”Entrez le prix d’un article:”);
Lire(prix HT );
Ecrire(”Entrez le nombre d’articles:”);
Lire(N);
Ecrire(”Entrez le taux de TVA:”);
Lire(TVA);
prix T T C ← N ∗ prix HT ∗ (1 + T V A/100);
Ecrire(”Le prix à payer est:”, prix T T C, ”MAD”);
Fin
xxiv CHAPTER 3. LES ENTRÉES & SORTIE:
Chapter 4
Les structures de contrôle
4.1 Les instructions conditionnelles

Un algorithme est composé d’une suite d’instructions permettant la résolution d’ un
problème donné. Les algorithmes ou (pseudo codes) traités jusqu ’a present sont sous
forme de suite linéaire d’instructions. Par contre, dans la pratique les algorithmes
qui peuvent se décrire uniquement par un enchaı̂nement séquentiel d’opérations
élémentaire sont très rares et par suite la nécessité d’un concept de rupture. Dans
certain cas nous distinguons le cas sur laquelle on execute plusieurs instructions
selon une conditionne donnée. On distingue trois catégories de structures:
• Structures linéaire d’opérations: c’est un enchaı̂nement séquentiel d’opérations

élémentaires
• Structures conditionnelles ou alternatives (Test): c’est un bloc d’instructions

dont l’exécution est soumise à la vérification d’un test.
• Structures itératives ou répétitives (Boucle): consiste à exécuté un bloc d’instructions

un certain nombre de fois.
Définition 4.1.1 Une instruction conditionnelle indique si un bloc d’instructions

sera exécuté ou pas. La condition est une expression booléenne.
La syntaxe de cette instruction peut s’écrit sous par deux formes possibles:
xxv
xxvi CHAPTER 4. LES STRUCTURES DE CONTRÔLE
Si (Condition) Alors
Instruction11;
Instruction12;
...
Instruction1N;
FinSi
Le traitement est ou n’est pas effectué suivant le résultat de la condition. Une Forme
plus complexe s’écrit:
Si (Condition) Alors
Instruction11;
Instruction12;
...
Instruction1N;
Sinon
Instruction21;
Instruction22;
...
Instruction2N;
FinSi
La syntaxe ci-dessous, permet de définir une structure conditionnelle permettant aux

”Instruction11, ...,Instruction1N” de s’exécuter si la condition (Condition) est vrai
(ou bien vérifiée). Sinon, la suite des instructions ”Instruction21, ..., Instruction2N”
aura place.
Exemple: L’algorithme suivant permets d’afficher la valeur absolue d’un réel donné.
4.1. LES INSTRUCTIONS CONDITIONNELLES xxvii
Algorithme Prog ValAbsolue
Variables x: réel;
Début
Ecrire(”Entrer un réel :”);
Lire(x);
Si (x<0) Alors
Ecrire(”la valeur absolue de ”, x ,” est ”,-x);
Sinon
Ecrire(”la valeur absolue de ”, x ,” est ”,x);
FinSi
Fin
Nous réecrirons l’ algorithme qui consiste a afficher la valeur absolue d?un

nombre réel, cette fois nous n’ utiliserons pas l?instruction(Sinon).
Algorithme Prog ValAbsolue2
Variables x, y: réels;
Début
Ecrire(”Entrer un réel :”);
Lire(x);
y ← x;
Si (x<0) Alors
y ← −x;
FinSi
Ecrire(”la valeur absolue de ”, x ,” est ”,y);

Fin
Ecrire un algorithme qui demande un nombre entier à l’utilisateur, puis qui

teste etaffiche s’il est divisible par 3?
xxviii CHAPTER 4. LES STRUCTURES DE CONTRÔLE
Algorithme Divisible Par3
Variable n: entier;
Début
Ecrire(”Entrer un entier:”);
Lire(n);
Si (n%3 =0) Alors

Ecrire(n,”est divisible par 3”);
Sinon
Ecrire(n,”n’est pas divisible par 3”);
FinSi
Fin
Les tests imbriqués

Une instruction imbriquée est une instruction qui contient d’autres instructions de
test. Les tests peuvent avoir un degré quelconque d’imbrications:
Si (Condition 1) Alors
InstructionsA;
Sinon
InstructionsB;
FinSi
Sinon
InstructionsC;
FinSi
FinSi
Considérons la première version de l’algorithme qui vous informe de signe d’un

nombre entré au clavier:
4.1. LES INSTRUCTIONS CONDITIONNELLES xxix
Algorithme Signe nombre
Variable n: entier;
Début
Lire(n);
Si (n<0) Alors
Ecrire(n,” est négatif strictement”);
FinSi
Si (n>0) Alors
Ecrire(n,” est positif strictement”);
FinSi
Si (n=0) Alors
Ecrire(n,” est nulll”);
FinSi
Fin
La version imbriquée s’éscrit sous la forme suivante:
Algorithme Signe nombre imbrique
Variable n: entier;
Début
Lire(n);
Si (n<0) Alors
Ecrire(n,” est négatif strictement”);
Sinon
Si (n>0) Alors
Ecrire(n,” est positif strictement”);
Sinon
Ecrire(n,” est null”);
FinSi
FinSi
Fin
xxx CHAPTER 4. LES STRUCTURES DE CONTRÔLE
Remark 4.1.2 Dans cet d’algorithme, nous avons trois cas possibles a traitée.Conrenant
la première version, nous avons réaliser trois tests systématique, alors que dans la
deuxième version avec les tests imbriquées, si le nombre est négatif on ne fait qu’
un seul test, ce qui permet d’optimiser notre algorithme.
Il est fortement recommandé d’utiliser les tests imbriqués pour limiter le nombre de
tests et placer d’abord les conditions les plus probables (minimiser la complexité).
Les structures de choix permettent a l’algorithme de réaliser un choix parmi plusieurs.

Ceci est utilisé quand les valeurs d’une variable sont constantes et limitées.
Selon (Variable ou Expression) Faire

Cas < valeur1 >: Action 1 ;
Cas < valeur2 >: Action 2 ;
...
Cas < valeurN >: Action N ;
Sinon: Action par défaut ;
FinSelon
Dans ce cas l’algorithme compare la valeur de la variable ou l’expression au différentes

valeurs de constantes (valeur1 ... valeurN).
Exemple: L’algorithme suivant permet d’afficher le jour de la semaine
Algorithme Prog Jour Semaine
Variables jour: chaine de caractère;

Début
Ecrire(”Entrer le jour de la semaine:”);
Lire(jour);
Selon (jour) Faire

Cas ”Lundi”: Ecrire(” Algorithmique”);
Cas ”M ardi”: Ecrire(” Mathématique”);
Cas ”M ercredi”: Ecrire(” Langues ”);
Cas ”Jeudi”: Ecrire(” Programmation”);
Cas ”V endredi”: Ecrire(” gestion de projet”);
Cas ”Samedi”: Ecrire(” Repos et révision”);
Cas ”Dimanche”: Ecrire(” Fin de la semaine”);
Sinon: Ecrire(” jour Inconnu”);
FinSelon
Fin
4.1. LES INSTRUCTIONS CONDITIONNELLES xxxi
4.1.1 Les conditions composées

Une condition composée est une condition formée de plusieurs conditions simples
reliées par des opérateurs logiques: disjonction (OU), disjonction esxclusif (XOR),
conjonction (ET) et la négation (NON).
Exemples:
• x compris entre 2 et 6 (2 ≤ x ≤ 6): (x >= 2) ET (x <= 6)

• n divisible par 4 ou par 5: (n%4 = 0) OU (n%5 = 0)
• deux valeurs et deux seulement sont identiques parmi a, b et c :
(a = b) XOR (a = c) XOR (b = c).
Exercice 4.1.3 Ecrire un algorithme qui demande deux nombres à l’utilisateur et

l’informe ensuite si leur produit est négatif ou positif. Attention toutefois : on ne
doit pas calculer le produit des deux nombres.
Algorithme Produit pos neg
Variables X, Y : réels;
Début
Ecrire(”Entrez un nombre”);
Lire(X);
Ecrire(”Entrez un deuxième nombre”);

Lire(Y);

Si (X>0 ET Y>0) OU (X<0 ET Y<0) Alors
Ecrire(”Le produit de”, X, ”et”, Y, ”est positif”);
Sinon
Ecrire(”Le produit de”, X, ”et”, Y, ” est négatif”);
FinSi
Fin
Exercice 4.1.4 Ecrire un algorithme du traitement qui calcule le discriminant DELTA

d’un trinome du second degré AX 2 + BX + C = 0 et qui, en fonction de son signe,
xxxii CHAPTER 4. LES STRUCTURES DE CONTRÔLE
calcule la ou les racines réelles du trinome ou affiche, si besoin est qu’il n’y a pas de
racine réelle. Les trois coefficients A, B et C seront saisis au clavier avant traite-
ment.
Algorithme Equation deux deg
Variables a, b, c, delta, sol1, sol2 : réels;

Début
Ecrire(”Résolution de AX 2 + BX + C = 0 ”);
Ecrire(”A:”);
Lire(a);
Ecrire(”B:”);
Lire(b);
Ecrire(”C:”);
Lire(c);
delta ← b ? b − 4 ? a ? c;
Si( delta < 0) Alors

Ecrire(”L’ équation n ’ a pas de racine”);
Sinon
Si( delta > 0) Alors
sol1 ← (−b + racine(delta))/(2 ? a);

sol2 ← (−b − racine(delta))/(2 ? a);
Ecrire(” X1=”, sol1, ”et X2= ”, sol2);
Sinon
sol1 ← b/(2 ? a);

Ecrire(” X=”, sol1);
FinSi
FinSi
Fin
4.2. LES STRUCTURES DE RÉPÉTITION xxxiii
4.2 Les structures de répétition

Les structures de répétition (les boucles) sont invoquées quant il s’agit de répéter un
traitement plusieurs fois dans des conditions quasiment similaires. On admet que
le traitement diffère par les valeurs des variables qui sont présentes lors de chaque
exécution, mais l’algorithme qui est répété inclue le code programme valable pour
tous les cas de figure. C’est la seul instruction permettant de revenir en arrière
dans l’algorithme pour exécuter les mêmes instructions. De manière générale les
structures de boucle diffèrent par les nombres d’itérations. On distingue 2 catégories
• Les boucles à événement ou indéfinie
– On ne sait pas à l’avance le nombre de fois que la boucle sera exécuté.

– Peut dépendre du nombre de données à traiter.
– Peut dépendre du nombre d’essais que l’usager a effectués. Exemple: la
boucle TantQue et la boucle jusqu?à (Faire ... TantQue )
• Les boucles à compteur ou définie c’est lorsqu’ on connait à l’avance le nombre

de fois que boucle devra tourner et une variable (le compteur) compte les
répétitions.
Exemple: Pour choisir 10 nombres au hasard, nous ferons dix fois l’opération
choisir un nombre au hasard. Pour cel nous utilisons la boucle Pour
4.2.1 La boucle TantQue
La boucle TantQue est considérée comme l’instruction la plus classique permettant

de répéter un bloc d’instructions. Le syntaxe s’écrit sous la forme
TantQue (Condition) Faire

Instruction1;
Instruction2;
...
InstructionN;
FinTantQue
Remark 4.2.1 Il faut noté que la l’exécution des instructions pour la première fois
nécessite la vérification de la condition.
xxxiv CHAPTER 4. LES STRUCTURES DE CONTRÔLE
L’Algorithme d’Euclide
Il s’agit de trouver le plus grand diviseur commun (pgcd) de deux entiers.
Définition 4.2.2 q est un diviseur commun de m et n si q divise à la fois m et n

(c-a-d le reste de la division entière est 0)
Définition 4.2.3 Le pgdc de m et n est le plus grand entier q divisant à la fois m

et n.
Exemple: pgcd(4, 6) = 2; pgcd(3,8) = 1; pgcd(9, 12) = 3;

Le calcul du pgcd est très utile pour la simplification de fractions:
9/12 = 3 ? 3/4 ? 3 = 3/4.
Méthodes classique de calcul de pgcd:
• Trouver tous les diviseurs de chaque nombre, ensuite trouver le diviseur com-
mun le plus grand par exemple
• D(30) = {1, 2, 3, 5, 6, 10, 15, 30} et D(105) = {1, 3, 5, 7, 15, 21, 35, 105}
• D(30) ∩ D(105) = {1, 3, 5, 15} et par conséquent pgcd (30, 105) = 15.
Méthodes d’Euclide de calcul de pgcd:
• Soient a et b deux entiers strictement positifs, tels que a = b ? q0 + r0 avec

0 ≤ r0 < b
• Si r0 = 0 alors pgcd (a, b) = b.
• Sinon, rediviser b par r0 tels que b = r0 ? q1 + r1 avec 0 ≤ r1 < r0
• Si r1 = 0 alors pgcd (a, b) = pgcd (b, r0 ) = r0 . ...
• Si rk est le premier reste null alors
pgcd (a, b) = pgcd (b, r0 ) = pgcd (r0 , r1 ) = ... = pgcd (rk−1 , rk ) = pgcd (rk−1 , 0) = rk−1
4.2. LES STRUCTURES DE RÉPÉTITION xxxv
Algorithme Euclide
Variables a, b, res: entiers;
Début
Lire(a);
Lire(b);
res ← b;
TantQue (res! = 0) Faire

r ← a%b;
a ← b;
b ← res;
FinTantQue
Ecrire(” le pgcd est:”, a);

Fin
Exercice 4.2.4 Ecrire un algorithme qui détermine le premier nombre entier N tel
que la somme de 1 à N dépasse strictement 100?
Algorithme Nombre Somme100
Variables som i : enties;

Début
i ← 0;
som ← 0;
TantQue (som < 100) Faire

som ← som + i;
i ← i + 1;
FinTantQue
Ecrire(” la valeur cherchée est:”, i-1);

Fin
xxxvi CHAPTER 4. LES STRUCTURES DE CONTRÔLE
4.2.2 La boucle Faire ... TantQue
La boucle Faire ... TantQue est similaire à la boucle TantQue, sauf que la
dernière ne permet pas une première exécution des instructions à l’intérieur du bloc
sans vérifier la condition. Contrairement à la boucle Répéter ... Jusqu’à qui
permet une première execution sans condition.
Faire
Instruction1;
Instruction2;
...
InstructionN;
TantQue (Condition);
Exemple: Nous reprenons l’exemple précédent i.e. l’ algorithme qui détermine

le premier nombre entier N tel que la somme de 1 à N dépasse strictement 100 en
utilisant la boucle Faire ... TantQue.
Algorithme Nombre Somme100 FaireTq
Variables som i : enties;

Début
i ← 0;
som ← 0;
Faire
som ← som + i;
i ← i + 1;
TantQue (som < 100) ;
Ecrire(” la valeur cherchée est:”, i-1);

Fin
Le fonctionnement de cette boucle est analogue à celui de la boucle TantQue à

quelques détails près:
• La condition est évaluée après chaque passage dans la boucle
• On éxécute le corps de la boucle tant que la condition est vraie et jusqu’ a ce

que la condition soit fausse.
4.2. LES STRUCTURES DE RÉPÉTITION xxxvii
4.2.3 La boucle définie: Pour

La boucle Pour est utilisable pour un nombre déterminé d’ itérations. La définition
d’une boucle Pour nécessite la donnée de trois entités :
1. compteur est une variable de type entier (ou caractère) qui doit être déclarée.
2. pas est un entier qui peut être positif ou négatif. Pas peut ne pas être men-
tionné, car par défaut sa valeur est égal à 1. Dans ce cas, le nombre d’itérations
est égal à finale - initiale +1
3. intiale et finale peuvent être des valeurs, des variables définies avant le début
de la boucle ou des expressions de même type que compteur.
Le syntaxe de la boucle Pour s’exprime comme suit :
Pour compteur Allant de initiale à f inale Pas pas

Instruction1;
Instruction2;
...
InstructionN;
FinPour
Déroulement des boucles Pour
1. La valeur initiale est affectée à la variable compteur.
2. On compare la valeur du compteur et la valeur de finale :
• Si la valeur du compteur est > à la valeur finale dans le cas d’un pas
positif (ou si compteur est < à finale pour un pas négatif), on sort de la
boucle et on continue avec l’instruction qui suit FinPour.
• Si compteur est <= à finale dans le cas d’un pas positif (ou si compteur
est >= à finale pour un pas négatif), instructions seront exécutées
(a) Ensuite, la valeur de compteur est incrémentée de la valeur du pas si
pas est positif (ou décrémenté si pas est négatif)
(b) On recommence l’étape 2 : La comparaison entre compteur et finale
est de nouveau effectuée, et ainsi de suite ...
xxxviii CHAPTER 4. LES STRUCTURES DE CONTRÔLE
Exemple: Cet algorithme permet déterminer le plus grand nombre d’une suite de
n nombres réels saisit au clavier.
Algorithme Plus grand element
Variables i, n : enties;
nbr, grand : réels;
Début
Ecrire(” Entrez n:”);
Lire(n);
Ecrire(” Entrez le nombre 0:”);

Lire(nbr);
grand ← nbr;
Pour i Allant de 1 à n
Ecrire(” Entrez le nombre”, i,”:”);
Lire(nbr);
Si nbr > grand Alors
grand← nbr;
FinSi
FinPour
Ecrire(” le plus grand element est:”, grand);

Fin
Remark 4.2.5 Il faut éviter de modifier la valeur du compteur (et de finale) à

l’intérieur de la boucle. En effet, une telle action peut provoquer un des problèmes
suivant :
• Perturbation de nombre d’itérations prévu par la boucle.
• Difficulté de lecture de l’algorithme.
• Risque d’aboutir à une boucle infinie.
Exemple: modification de la valeur du compteur à l’intérieur provoquant une

boucle infinie
4.2. LES STRUCTURES DE RÉPÉTITION xxxix
Pour i Allant de 1 à f inale Pas pas

i←i-1;
Ecrire(” Entrez le nombre”, i,”:”);
FinPour
4.2.4 Boucle imbriquée
Les instructions d’une boucle peuvent être également des instructions itératives.
Dans ce cas, nous obtenons une boucle imbriquée. Donner la sortie de cet algorithme
Algorithme boucle imbrique
Variables i, j : enties;
Début
i ← 0;
Ecrire(” Debut”);
TantQue (i <= 5) Faire
Pour j Allant de i à 10
Ecrire(” les trois valeurs:”, i , j , i ? j);
FinPour
i ← i + 1;
FinTantQue
Ecrire(” Fin”);
Fin
4.2.5 Lien entre la boucle Pour et TantQue
La boucle Pour peut etre vue comme un cas particulier de la boucle TantQue.
En effet, tout ce qu’on peut écrire avec Pour peut être remplacé avec la boucle
TantQue et la réciproque n’est pas toujours vrai.
De manière générale soit la boucle Pour suivante :
xl CHAPTER 4. LES STRUCTURES DE CONTRÔLE
Pour compteur Allant de initiale à f inale Pas pas

Instruction1;
Instruction2;
...
InstructionN;
FinPour
Ell peut être remplacée, dans le cas d’un pas positif par:
compteur ← initiale;
TantQue (compteur <= f inale) Faire

Instruction1;
Instruction2;
...
InstructionN;
compteur ← compteur + pas;
FinTantQue
Exemple: En utilisant la boucle Pour et TantQue, nous allons écrire l’algorithme

qui calcul xn où les données x un réel et n un entier positif non null
4.2. LES STRUCTURES DE RÉPÉTITION xli
Algorithme Puissance Pour

Variables x,puis: réels
n, i: entiers
Début
Ecrire(”Entrer un entier x :”);

Lire(x);
Ecrire(”Entrer un entier n :”);
Lire(n);
puis ← 1;
Pour i Allant de 0 à n
puis← puis ? x;
FinPour
Ecrire(x,”à la pissance”,n,”égale à :” puis);

Fin
Nous proposons maintenant la solution avec la boucle TantQue
Algorithme Puissance TantQ

Variables x,puis: réels
n, i: entiers
Début
Ecrire(”Entrer un entier x :”);

Lire(x);
Ecrire(”Entrer un entier n :”);
Lire(n);
puis ← 1;
i← 0;
TantQue (i<=n) Faire
puis← puis ? x;
i← i+1;
FinTantQue
Ecrire(x,”à la pissance”,n,”égale à :” puis);

Fin
xlii CHAPTER 4. LES STRUCTURES DE CONTRÔLE
4.3 Choix de type de boucle

Le choix d’une boucle dépend de la nature du problème à traité, ce choix peut
simplifier et rendre l’algorithme plus lisible. Nous distingueons plusieurs situations
ainsi que les boucle convenant.
• Si on peut déterminer le nombre d’itérations avant l’exécution de la boucle, il

est plus naturel d’utiliser la boucle Pour.
• S’il n’est pas possible de connaı̂tre le nombre d’itérations avant l’exécution de

la boucle, on fera appel à l’une des boucles TantQue ou répéter jusqu’à
– Si on doit tester la condition de contrôle avant de commencer les instruc-

tions de la boucle, on utilisera TantQue.
– Si la valeur de la condition de contrôle dépend d’une première exécution
des instructions de la boucle, on utilisera répéter jusqu’à.
4.3.1 Exercices
Exercice 4.3.1 Ecrire un programme qui lit le prix HT d’un article, le nombre
d’articles et le taux de TVA, et qui fournit le prix total TTC correspondant. Faire
en sorte que des libelles apparaissent clairement.
Exercice 4.3.2 Ecrire un algorithme qui demande deux nombres à l’utilisateur et

l’informe ensuite si leur produit est négatif ou positif. Attention toutefois : on ne
doit pas calculer le produit des deux nombres.
Exercice 4.3.3 Ecrire un algorithme qui demande l’ge d’un enfant à l’utilisateur.
Ensuite, il l’informe de sa catégorie.
”Poussin” de 6 à 7 ans
”Pupille” de 8 à 9 ans
”Minime” de 10 à 11 ans
”Cadet” apr ès 12 ans.
Exercice 4.3.4 Ecrire un algorithme qui demande un nombre compris entre 10 et

20, jusqu’ à ce que la réponse convienne. En cas de réponse supérieure à 20, on fera
apparaitre un message : Plus petit ! , et inversement, Plus grand ! si le nombre est
inférieur à 10.
4.3. CHOIX DE TYPE DE BOUCLE xliii
Exercice 4.3.5 Ecrire un algorithme qui demande un nombre de départ, et qui

calcule sa factorielle en utilisant les trois types de boucles
NB : la factorielle de 8, notée 8!, vaut 1 × 2 × 3 × 4 × 5 × 6 × 7 × 8
Exercice 4.3.6 Ecrire un algorithme qui demandeun nombre de dṕart, et qui en-
suite écrit la table de multiplication de ce nombre, présentée comme suit(cas où
l’utilisateur entre le nombre 7) :
Table de 7 :
7x1=7
7 x 2 = 14
...
7 x 10 = 70
Exercice 4.3.7 Ecrire un algorithme qui demandesuccessivement 10 nombres à

l’utilisateur, et qui lui dise ensuite quel était le plus grand parmi ces 10 nombres:
Entrez le nombre numéro 0: 12
etc.
Le plus grand de ces nombres est : 500
Modifiez ensuite l’algorithme pour que le programme affiche de surcroı̂t en quelle
position avait été saisie ce nombre:
C’était le nombre numro 2
Exercice 4.3.8 Ecrire un algorithme qui demandeun nombre n à l’utilisateur et

calcul la somme suivante :
S = 12 + 22 + 32 + ... + N 2 .
Exercice 4.3.9 un nombre parfait est un entier positif égal à la somme de ses
diviseurs (le nombre lui-même n’est pas compté diviseur). Ecrire un algorithme
qui, étant donné un entier plus grand que 1, indique si cet entier est parfait ou
pas. Cette méthode doit retourner un résultat de type booléen. Exemple: 28 est un
nombre parfait car, à par lui, ses diviseurs sont 1, 2, 4, 7 et que:
1 + 2 + 4 + 7 + 14 = 28.
Exercice 4.3.10 Ecrire un algorithme qui permet de saisir une série de nombres
entiers positifs et qui après saisie, affiche les valeurs du plus petit et du plus grand
nombre saisi ainsi que la somme et la moyenne des nombres.
xliv CHAPTER 4. LES STRUCTURES DE CONTRÔLE
Exercice 4.3.11 Ecrire l’algorithme estPremier, qui a partir d’un entier stricte-
ment positif donné, retourne le résultat booléen VRAI ou FAUX selon le nombre
est premier ou non.
Exercice 4.3.12 Ecrire l’algorithme qui calcul la racine carrée d’un nombre sans
avoir recours a la fonction mathématique racine carrée prédéfinie.
Procédure : si n est le nombre dont on souhaite extraire la racine carrée. On
construit une suite de nombres uk dont le premier vaut 1 et dont le terme générale
a pour expression :
1 n
uk = + uk−1 pour k ≥ 1.
2 uk−1
√
Cette suite converge systématiquement vers n. Tester cet algorithme avec des
valeurs: 1, 2, 3, 4, 9, 16.
Exercice 4.3.13 Ecrire un algorithme qui, étant donné un nombre entier naturel
p, affiche tous les couples d’entiers naturels (a, b) tels que a ? b = p.
Exercice 4.3.14 Ecrire un algorithme permettant de calculer le produit de 2 entiers

naturels x et y par la méthode de la multiplication égyptienne.Les seuls opérations
autorisées sont: multiplication par 2, division par 2, addition, soustraction, affecta-
tion, lecture et écriture
Exercice 4.3.15 Je souhaite louer un appartement. Les charges s’élèvent à 300

DH par mois. Le loyer initial est de 1000 DH (charges comprises). On me propose
deux formules de location. Dans la première formule, le loyer augmente tous les
mois de 20Dans la seconde formule, le loyer augmente seulement de 10
1. Ecrire un programme permettant de calculer le montant des 2 loyers au mois

N
2. Ecrire un programme permettant de calculer la somme totale d’argent dépensée
en loyer au mois N.
3. Ecrire un programme permettant de déterminer au bout de combien de mois
le loyer de la seconde formule est strictement plus important que le loyer de la
première
4. Ecrire un programme permettant de déterminer au bout de combien de mois la
somme totale dépensée en loyers avec la formule 2 sera strictement supérieure
à la somme totale dépensée avec la formule 1
Chapter 5
Les Fonctions et procédures
Lorsqu’ on commence à écrire des programmes sophistiqués et de taille importante,

il devient très difficile d’avoir une vision globale sur sa gestion et son fonction-
nement. Ce qui provoque, une grande difficulté au niveau de la comprehension de
l’algorithme et la gestion des erreurs . Pour ce rem:’edier a ce type de problème nous
décomposeons le problème en sous problèmes. Par conséquent, nous d’écriverons les
algorithmes en utilisant des sous-algorithme. La forme générale de notre algorithme
devient
Algorithme A
Sous-algorithme SA1;
Sous-algorithme SA2;
...
Sous-algorithme SAN;
FinA
5.1 Sous algorithme

Un sous-algorithme est un élément d’algorithme nommé et éventuellement paramétré
que l’on définit afin de pouvoir ensuite l’appeler par son nom en affectant, s’il y a
lieu, des valeurs aux paramètres. Le découpage d’une tâche en sous-tâche permet
d’effectuer une seule description d’une tâche commune et de concevoir une applica-
tion de manière descendante en entrant de plus en plus dans les détails.
xlv
xlvi CHAPTER 5. LES FONCTIONS ET PROCÉDURES
La structure générale d’un sous-algorithme est composé de
1. Un nom unique de sous-algorithme
2. Des paramètres applés aussi arguments avec leurs types
3. D’un corps des déclarations d’objets locaux aux sous-algorithme, instructions

à exécuter
Sous Algorithme nom (liste des paramètres): type de retour
Déclaration des variables locales
Début
Corps du sous-algorithme
Fin
5.1. SOUS ALGORITHME xlvii
Déclaration des variables
Début
Instructions;
Appel du sous-algorithme
Instructions;
Fin
En algorithmique, on distingue deux types de sous-programmes les fonctions et les

procédures
5.1.1 Les fonctions

Définition 5.1.1 Une fonction est un sous algorithme indépendant, dans le sens
mathématique du terme, il sert à calculer une valeur (i.e. image). elle est car-
actérisée par des paramètres et un type de retour.
Une fonction s’écrit en dehors du programme principal sous la forme
Fonction identificateur (paramètres: leurs types) : type fonction

Début
Instructions constituant le corps de la fonction
retourne(resultat);
FinFonction
où
• Type de fonction : le type du résultat renvoyé par la fonction
• Identificateur : le nom que l’on a donné à la fonction
• Liste de paramètres : la liste des paramètres formels donnés en entrée avec

leurs types
• corps de la fonction : un bloc d’nstructions, pouvant comprendre la déclaration

des variables locales de la fonction
xlviii CHAPTER 5. LES FONCTIONS ET PROCÉDURES
La figure suivante illustre la configuration globale d’une fonction
Remark 5.1.2 le corps de la fonction doit comporter une instruction de la forme :

Retourne(expression); où expression est du même type que le résultat de retrour de
la fonction.
Exemple :
Fonction carre(n : entier): entier

Variables res: entier
Début
res ← n * n;
retourne(res);
FinFonction
La fonction carre prend en argument un entier et renvoie le carré de ce nombre

comme résultat. Nous utiliserons cette fonction dans un algorithme suivant
Algorithme Test fonction

Variables a, b: entier
Debut
Ecrire(” Donner la valeur ”);
Lire (a);
b ← carre(a);
Ecrire(” le carrée de ”, a, ”est ”,b);
Fin
5.1. SOUS ALGORITHME xlix
Maintenant nous considérons deux fonctions. La fonction SommeCarre qui calcule la

somme des carrées de deux réels entrées comme paramètres et qui renvoie la somme
des carrées comme résultat. La fonction Pair qui prend en argument un entier et
qui renvoie un résultat booléen indiquant si le nombre est pair ou impaire :
Fonction SommeCarre (x : réel, y: réel ): réel

Variable z : réel
Debut
z ← x*x+y*y;
retourne (z);
FinFonction
La fonction Pair suivante :
Fonction Pair (n : entier): booléen

Variable bol : booléen
Debut
bol ←n%2=0;
retourne (bol);
FinFonction
Maintenant , nous allons utiliser les deux fonctions SommeCarre et Pair, nous ferons
l’appel des ces fonctions par simple écriture de nom dans le programme principale.
Algorithme Exemple Appel Fonction

Variables z : réel
b : booléen
Début
b ← Pair (3);
z ← 5? SommeCarre(7,2)+1;
Ecrire(”3 est pair? ”,b);
Ecrire(”SommeCarre(3,5)= ”,SommeCarre(3,5));
Fin
Remark 5.1.3 Lors de l’appel Pair(3) le paramètre formel n de la fonction est

remplacé par le paramètre effectif 3.
Le résultat étant une valeur, nous pourrions soit l’ affecté ou bien utilisé dans une
expression, une écriture etc.
l CHAPTER 5. LES FONCTIONS ET PROCÉDURES
Exercice 5.1.4 Trouver le plus petit nombre premier strictement supérieur à un

entier positif donné n.
NB. Utiliser l’algorithme qu’on aà déjà fait estPremier (le plus petit nombre pre-
mier p supérieur à un entier n) en tant que fonction. Fait appel a cette fonction a
l’intérieur de l’algorithme premier-plus-petit
5.1.2 Procédure
Une procédure est un sous-programme qui ne retourne pas de valeure. C’est donc
un type particulier de fonction. En général, une procédure modifié la valeur de
ses paramètres , mais ce n’est pas toujours le cas. Tout comme les fonctions, une
procédure est un sous-programme composé d’instructions :
• Comportant un nom unique
• Peut contenir des paramètres en entrées
• Qui ne retourne pas de valeur.
Dans certains cas, nous pourrions avoir besoin de répéter une tache dans plusieurs
endroits du programme, mais que dans cette tache on ne calcule pas de résultats
ou qu’on calcule plusieurs résultats à la fois. Dans ces cas nous ne pourrions pas
utiliser de fonction, nous utilisons une procédure. En effet, une procédure est un
sous-programme semblable à une fonction mais qui ne retourne pas de résultat.
Une procédure s’écrit en dehors du programme principal sous la forme :
Procédure identificateur (paramètres: leurs types)

Début
Instructions constituant le corps de la procédure
FinProcédure
Remark 5.1.5 Comme pour une fonction, une procédure peut ne pas avoir de
paramètres mais qui il ne retourne pas de résultat.
L’appel d’une procédure, se fait dans le programme principale ou dans une autre
procédure par une instruction indiquant le nom de la procédure :
5.1. SOUS ALGORITHME li
Début
Instructions;
Appel de la procédure
Instructions;
Fin
Remark 5.1.6 Contrairement à l’appel d’une fonction, on ne peut pas affecter la

procédure appelée ou l’utiliser dans une expression. L’appel d’une procédure est
une instruction autonome.
Exemple :
Procédure AfficherB (n : entier)

Variables i: entier
Début
Pour i Allant de 0 à n − 1
Ecrire(” Bonjour”);
FinPour
FinProcédure
La procédure AfficherB prend en argument un entier et afficher un nombre de fois

”bonjour” en fonction de cet argument. Nous utiliserons cette procédure dans l’
algorithme suivant
Algorithme Test procedure

Variables m: entier
Debut
Ecrire(” Donner combien de bonjour”);
Lire (m);
AfficherB (m);
Ecrire(”Après Appel” );
Fin
lii CHAPTER 5. LES FONCTIONS ET PROCÉDURES
5.1.3 Les paramètres d’un sous algorithme
Un sous-algorithme (fonction ou procédure) peut avoir des paramètres qui sont très
utile, car il permettent de répéter une suite d’instructions complexes pour des valeurs
qu’ on ne connaı̂t pas à l’avance. Les paramètres servent à échanger des données
entre l’algorithme principale (ou l’algorithme appelante) et le sous algorithme ap-
pelée. Les paramètres placés dans la déclaration d’un sous algorithme (fonction ou
procédure) sont appelés paramètres formels. Ces paramètres peuvent prendre toutes
les valeurs possibles mais ils sont abstraits (n’existent pas réellement). Par contre,
les paramètres placés dans la déclaration placés dans l’algorithme principale sont ap-
pelés paramètres effectifs car ils contiennent les valeurs pour effectuer le traitement.
Remark 5.1.7 Le nombre de paramètres effectifs doit être égal au nombre de paramètres
formels. L’ordre et le type des paramètres doivent aussi correspondre.
Il existe deux types de passage de paramètres : par valeur et par variable (dite aussi
par référence ou encore par adresse).
Passage par valeur
C’est la manière de transmission par défaut, le système cré une copie de la valeur,
des paramètres effectifs dans les variables locales provenant des paramètres formels
du sous algorithme appelée. Dans ce cas, le contenu des paramètres effectifs ne peut
pas être modifié par les instructions du sous algorithme. En effet a l’intérieur de ce
dernier, nous ne travaillons pas directement avec la variable, mais sur une copie. A
la fin de l’exécution du sous-algorithme la variable de l’algorithme principale con-
servera sa valeur initiale. Les paramàtres dans ce cas sont utilisés comme données.
Exemple :
Procédure Aug2 (m : entier)

Début
m ← m+2;
FinProcédure
En utilisant cette procédure, nous souhaitons écrire un algorithme principale qui lit
un entier positif n puis affiche tous les nombres impaires inférieurs à m
5.1. SOUS ALGORITHME liii
Algorithme Nombre pair

Variables i, n: entiers
Debut
Ecrire(” Donner le nombre”);
Lire (n);
i ← 0;
Ecrire(”les nombres paires inférieure à”,n,”sont:”);
TantQue (i<=n) Faire

Ecrire(i);
Aug2 (i);
FinTantQue
Fin
Dans cet exemple, lors de l’appel de la procédure Aug2 la variable i est un paramètre
effectif et le système cré une copie de de la valeur de i dans la variable locale m
(paramètre formel) de la procédure Aug2. Par conséquent, la valeur de i reste
inchangée après appellation de la procédure Aug2 ce qui provoque une boucle infini.
La solution est d’utiliser un passage par adresse .
Passage par adresse variable
Dans ce type de passage, nous utilisons l’emplacement dans la mémoire (l’adresse )

de la variable i.e. . En fait, le paramètre formel se substitue au paramètre effectif
durant le temps d’ éxécution du sous-algorithme et à la sortie il lui transmet sa nou-
velle valeur. Un tel passage de paramètre se fait par l?utilisation du mot-clé Var
en langagec nous utiliserons le pointeur. Afin de résoudre le problème de l’exemple
précédent nous remplacons la procédure précédente par Exemple :
Procédure Aug2 ( Var m : entier)

Début
m ← m+2;
FinProcédure
liv CHAPTER 5. LES FONCTIONS ET PROCÉDURES
5.1.4 Exercices
Exercice 5.1.8 Ecrire un algorithme principale utilisant une fonction qui permet
de calculer et de retourner la plus grande valeur parmi trois réels.
Exercice 5.1.9 Ecrire l’algorithme et le sous algorithme permettant de :
1. Convertir un nombre entier N en un nombre représentant sa valeur en binaire

(base 2). Exemple: le nombre 204 est converti en 11001100
2. Convertir un nombre entier N représentant une valeur en binaire (on vérifiera
cette propriété) en un nombre en base 10.
Exemple: le nombre 11001100 est converti en 204
Le nombre 100301 n’est pas valide et doit être ressaisi
Exercice 5.1.10 Ecrire une fonction qui permet de déterminer le plus grand com-
mun diviseur (PGCD) de deux entiers positifs ( cette fonction prend comme paramètres
deux entiers positifs et elle renvoie un entier positif ). Ecrire l’algorithme principale
qui demande a l’utilisateur deux nombres appel la fonction précédente pour calculer
le PGCD, ensuite affiche le résultat à l’écran.
Exercice 5.1.11 1. Ecrire une fonction qui détermine si une entier N est parfait
ou non (cette fonction prend comme paramétre N et elle renvoie un résultt de
type booléen: VRAI ou FAUX).Ecrire l’algorithme principale qui demande a
l’utilisateur un nombre appel la fonction précédente pourconnaitre si le nombre
est parfait ou pas, ensuite affiche le résultat pour l’utilisateur à l’écran.
2. Ecrire une fonction qui affiche tous les nombre parfait inférieur à un nombre
entier N assez grand. Cette fonction fera appel à la fonction crée dans la
question précédente.
Exercice 5.1.12 Ecrire une fonction qui permet le produit de deux nombres. Ici on
impose d’utiliser la méthode de la multiplication égyptienne pour calculer le produit.
Exercice 5.1.13 En utilisant les fonctions, ćrire un algorithme permettant de saisir

les coordonnées de types réels d’un point A et de calculer sa norme
p
N orme(x, y) = x2 + y 2
Exercice 5.1.14 Etant donné un entier naturel n, la factorielle de n (noté n!)

est le produit de tous les entiers naturels non nuls inférieurs ou égaux à n. Par
convention, la factorielle de 0 vaut 1.
5.1. SOUS ALGORITHME lv
1. Ecrire la fonction factorielle qui, étant donnée un entier n, calculen!
2. Ecrire une fonction combinaison qui calcule le coefficient binominal de n et p

n!
Cnp = p!(n−p)! . On utilisera la fonction factorielle crée auparavant.
3. Ecrire un algorithme principlae permettant de tester les deux fonctions
Exercice 5.1.15 Ecrire l’algorithme et le sous algorithme permettant de calculer la

limite à près de la suite définie par la relation de récurrence:
U0 = 2
2
Un = Un−1 + , n ≥ 1.
Un−1
On arrête d’itérer quand l’intervalle entre 2 termes consécutifs devient strictement
inférieur à .
Exercice 5.1.16 Ecrire l’algorithme et le sous algorithme permettant de calculer la

n ème terme de la suite définie par:
F0 = 1, F1 = 2
Fk = 4Fk−1 + 3Fk−2 , k ≥ 2.
lvi CHAPTER 5. LES FONCTIONS ET PROCÉDURES
Chapter 6
Les Tableaux
Lorsque dans un algorithme, nous aurons besoin simultanément de plusieurs vari-

ables pour stocker des valeurs (par exemple, les notes des modules pour un etudiant).
La solution consiste à déclarer seize variables, appelées par exemple Module1, Mod-
ule2,..., Module16. Lorsque nous souhaitons conserver ces valeurs jusqu ’ a la fin
de l’algorithme ou bien réaliser des traitements comme calculer la note maximale,
trier les notes des problèmes majeurs apparaissent: le premier est celui de la lecture
et écriture de ces variables qui nécessitera une succession de 16 instructions Lire
distinctes, le deuxième est celui d’ecriture de ces 16 variable a chaque traitement.
6.0.1 Tableaux à une dimension
Définition 6.0.1 Un tableau est un ensemble de valeurs portantle même nom de

variable et repérées par un indice.
Tableau à une dimension 7 −1 50 100 0 19

Un tableau de taille n est une structure très simple constituée de n emplacements
consécutifs en mémoire. Il est donc possible d’accéder à un élément d’un tableau
quand on connait sa position (ou indice). Un tableau est donc une structure très
simple et très efficace.
Pour remédier au problème de l’exemple précédent, nous allons créer un tableau
appelé M odule[]. Et chaque note de module sera notée M odule[i] où i désigne
l’élément de la position i. Pour déclarer un tableau il faut préciser le nombre et
le type de valeurs qu’il contiendra. En pseudo code
lvii
lviii CHAPTER 6. LES TABLEAUX
Algorithme Decl tableau

Variables tableau identificateur[ dimension] : Type;
Début
Instructions;
Fin
Cette déclaration réserve des emplacements pour un certaine nombre des éléments
où le nombre est caractérisé par dimension et de type donné Type . Chaque élément
est repéré par son indice dans le tableau. Dans la plus part des langages de pro-
grammation comme langage C, la première position porte le numéro 0. Exemple
Variables tableau module[ 16] : Réels;
Dans cet exemple, nous avons crée un tableau appelé module contenant 16 emplace-
ments memoire pour stocker des nombres réels. Nous pourrions également créer des
tableaux contenant des variables de types numériques, caractàres, booléens, ... .
Remark 6.0.2 Dans un même tableau, nous ne pourrions pas faire un melange de
types différents de valeurs .
L’ avantage d’un tableau, c’est quı́l nous permet réaliser des traitement sur tous les
éléments en utilisant les boucles. Par exemple, pour effectuer la lecture des élement
du tableau précédent
Algorithme notes tableau

Variables tableau module[16] : Réel;
i: Entier;
Début
Pour i Allant de 0 à 15
Ecrire(” Donner l’élément ”,i);
Lire(module[i]);
FinPour
Fin
Dans cet exemple, nous avons déclaré un tableau nomé module de 16 valeurs réels
et nous avons demandé a l’utilisateur de saisir une suite de nombres, que nous avons
prévu de stocker successivement dans le tableau. Afin d’accéder (en lecture ou en
lix
écriture) à la i ème valeur du tableau nous utilisons la syntaxe module[i]). De

manière générale
• Accès en écriture :
module[7]) ← 15.5; affecte la valeur 15.5 dans la zone mémoire d’indice 7.
• Lire(module[7]); enregistre la valeur entré par l’utilisateur dans le tableau à

l’indice 7.
• Accès en lecture:
Ecrire(module[7]); affiche à l’écran le contenu du tableau à l’indice 7.
Nous reprendrons l’exemple précédent, et nous allons de plus calculer le nombre des
modules ayant une note supérieure à 10, nous pourrions écrire :
Algorithme lecture tableau

Variables tableau module[16] : Réel;
i, nbre: Entiers;
Début
nbre ← 0;
Ecrire(” Donner l’élément ”,i);
Lire(module[i]);
FinPour
Si (module[i] >10) Alors
nbre ←nbre+1;
FinSi
FinPour
Ecrire (”le nombre de notes supérieures à 10 est : ”, nbre);

Fin
6.0.2 Tableaux à deux dimension
Les langages de programmation permettent de déclarer des tableaux dans lesquels les
valeurs sont repérées par deux indices. Ceci est utile par exemple pour représenter
des matrices . En pseudo code, un tableau à deux dimensions se déclare ainsi
lx CHAPTER 6. LES TABLEAUX
Algorithme Decl tableau

Variables tableau identificateur[ dimension1 ][ dimension2 ] : Type;
Début
Instructions;
Fin
−1 10.5 17 0 50 17
Tableau à deux dimension 100 3.2 −6 3 44 19
1 1 1 0 0 0
Voici un exemple de la déclaration d’un tableau de 3 × 6 éléments de types réels
Variables tableau Mat[ 3][6] : Réel;
Cette déclaration permet de réserver un espace de mémoire pour 3 × 6 réels. Afin

d’accéder (en lecture ou en écriture) à l’élément de la i ème ligne et de la j ème
colonne du tableau nous utilisons la syntaxe M at[i][j]). De manière générale
• Accès en écriture :
M at[2][4]) ← 13.5; affecte la valeur 13.5 dans la zone mémoire de la matrice
qui se trouve à l’intersection de la ligne 2 et la colonne 4.
• Lire(M at[2][4]); enregistre la valeur entrée par l’utilisateur dans le tableau à

l’intersection de la ligne 2 et la colonne 4.
• Accès en lecture:
EcrireM at[2][4]); affiche à l’écran le contenu de l’élément du tableau de la
ligne 2 et colonne 4.
lxi
Algorithme lecture matrice

Variables tableau Mat[3][6] : Réel;
i,j: Entiers;
Début
Pour j Allant de 0 à 5
Ecrire(” Donner l’élément ”,i,j);
Lire(Mat[i][j]);
FinPour
FinPour
Fin
Dans cet exemple, nous avons déclaré une matrice nomé Mat de 2 lignes et 3 colonnes
pour stocker des valeurs réels et nous avons demandé a l’utilisateur de saisir une
suite de nombres, que nous avons prévu de stocker successivement dans la matrice.
Maintenant, nous reprendrons l’exemple précédent, et nous dclarerons deux matrices
et aprs saisit nous calculerons la somme de ces deux matrices de la manière suivante
L’algorithme, s’écrit de manière suivante: :

lxii CHAPTER 6. LES TABLEAUX
Algorithme somme matrice

Variables tableau A[3][3], B[3][3], R[3][3] : Réel;
i,j: Entiers;
Début
Lire(A[i][j]);
FinPour
FinPour
Lire(B[i][j]);
FinPour
FinPour
R[i][j] ← A[i][j]+B[i][j];
FinPour
FinPour
Ecrire(” R[”,i, ”][”,j,”]=”,R[i][j]);
FinPour
FinPour
Fin
6.0.3 Exercices
Exercice 6.0.3 1. Ecrivez un algorithme permettant la saisie d’un tableau d’entiers.

Le nombre des éléments du tableau doit être fixer par l’utilisateur.
lxiii
2. Ecrivez un algorithme SaisieTableauAvecDrapeau permettant la saisie d’un

tableau d’entiers positives . Cette fois le nombre n’est pas connu et la saisie
s’arréte lorsque l’utilisateur appui sur la touche −1.
Exercice 6.0.4 Erivez le corps de la fonction estTrier qui prend en argument un

tableau T et retourne vrai si et seulement si le tableau T est trié par ordre croissant.
Exercice 6.0.5 Ecrivez un algorithme calculant la somme des valeurs d’un tableau
Exercice 6.0.6 Ecrire un algorithme qui permet de saisir une série de nombres
entiers positifs et qui après saisie, affiche les valeurs du plus petit et du plus grand
nombre saisi ainsi que la somme et la moyenne des nombres.
Exercice 6.0.7 Ecrire un algorithme qui calcule le schtroumpf des deux tableaux.
Pour calculer le schtroumpf, il faut multiplier chaque élément du tableau 1 par chaque
élément du tableau 2, et additionner le tout.
Exercice 6.0.8 1. Ecrire une fonction qui prend un tableau de 5 entiers, puis
retourne la valeur Vraie ou Faux selon que le tableau est trié par ordre croissant
ou non.
2. Ecrire un algorithme qui lit un tableau de 5 entiers puis teste s’il est trié ou
pas
Exercice 6.0.9 1. Ecrivez un algorithme permettant la saisie d’un tableau à

deux dimension d’entiers. Le nombre des éléments du tableau doit être fixer
par l’utilisateur.
2. Ecrivez un algorithme permettant l’affichage des élément d’un tableau è deux

dimension.
Exercice 6.0.10 Ecrivez un algorithme calculant la trace d’une matrice .
Exercice 6.0.11 Ecrivez un algorithme calculant le produit d’une matrice et un

vecteur .

Book Algo

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

Book Algo

Transféré par

Droits d'auteur :

Formats disponibles

UNIVERSITE CADI AYYAD

DUT : Informatique & Sciences des données

Table des matières i

2 Algorithme et Langage de programmation xi

3 Les entrées & Sortie: xxi

3.0.1 Instruction de lecture . . . . . . . . . . . . . . . . . . . . . . xxi

4 Les structures de contrôle xxv

5 Les Fonctions et procédures xlv

6 Les Tableaux lvii

Ce document est une initiation à l’algorithmique et la programmation, il est destiné

• Fournir des notions de base pour décrire les algorithmes

• Présenter les concepts permettant de structurer et de réutiliser les algorithmes:

• Explorer les structures de données linéaires: tableaux et listes.

Définition 1.1.1 (Système informatique) Un système informatique est un en-

En d’autres termes, nous définisons un système informatique comme un ensemble

1.2 Composants de l’ ordinateur

1.2.1 Les composants matériels

• La mémoire centrale permet de stocker les données.

• Unité de centrale permet lde réaliser des traitements.

• Les périphériques: écran, clavier, souris, ...

Figure 1.1: Cette figure représente une architecture du système

Le bus coordonne les échanges d’informations et permet l’échange des données.

Définition 1.2.1 (Mémoire centrale) La mémoire centrale est un organe dont

Définition 1.2.2 (Le processeur) Le processeur est considéré comme le cerveau

De manière générale la fréquence du processeur, i.e. la vitesse à laquelle tourne

1.2.2 Les composants logicielle

1.3 Langage machine

• 0 éteint i.e. absence de signal électrique

• 1 allumé i.e. présence de signal électrique

1.4 Rappel sur la numération

N = an ×B n +an−1 ×B n−1 +...+a1 ×B 1 +a0 ×B 0 +a−1 ×B −1 +a−2 ×B −2 +...+a−m ×B −m

où 0 ≤ ai < B pour tout −m ≤ i ≤ n et on écrit

• 123 en base 10 (décimal)

• 1111011 en base 2 (binaire)

• 173 en base 8 (octale)

1.4.1 Conversion de base

L’opération consiste a diviser le nombre par 2 puis réitérer l’opération en remplacant

• 9 en base 10 vaut 1001 en base 2 et on écrit 9 = (1001)2 parce que

L’opération consiste a additionner la multiplication du nombre représenté par

1.4.2 Codage des caractères

• la lettre A est codée 65 en décimal

• la lettre B est codée 66 en décimal

• et la lettre a est codée 91 en décimal.

2.1 Notion d’Algorithme

Définition 2.1.1 Un algorithme est suite finie d’opérations (instructions) con-

Pour fonctionner, un algorithme doit donc contenir des instructions compréhensibles

• Lecture & Écriture

• Instructions conditionnelles (les tests)

• Instructions de répétition ( les boucles)

Un algorithme est une combinaison de ces quatre instructions ou ordre. Il peut y en

2.2 Structure d’un algorithme

Chaque ligne contient une seule instruction et l’exécution de l’algorithme con-

2.3 Les variables

Définition 2.3.1 Une variable désigne un emplacement mémoire afin de stocker

• Un nom unique appelé identifiant

• Un type caractérisant l’ensemble des valeurs qu’ elle peut prendre

• Une valeur (contenu de l’espace mémoire) attribuée et peut être modifiée .

Les variables utilisées au cours de l’algorithme sont déclarées après le nom de

Variables var1, var2 ..., varN : TypeVariable;

• Le nom de la variable ne doit pas comporter des caractères de ponctuation et

• La longueur du nom doit être inférieure à la taille maximale spécifiée par le

• L’identificateur A1 est valide par contre 1A est invalide.

• Identificateurs valides: info2019, dut 2019