Chapitre5 2019

École
Na)onale Polytechnique
1ère année Classes Préparatoires
Année 2019/2020

Ma)ère
Informa)que 1
Chapitre V
Algorithmique
Préparé et présenté par Dr. Meziane Tani I.

Plan
•  Introduc)on à l’algorithmique
•  Structure d’un Algorithme
•  No)on de variable et de constante
•  Séquence d’instruc)ons
–  Lecture/Écriture
–  Affecta)on
–  Structures alterna)ves
–  Structure itéra)ves
•  Les types complexes

–  Tableaux
–  Enregistrements
Dr. Meziane-Tani I. 2
Introduc)on
Ordinateur
Matériel Logiciel
-  Composants matériels
-  Codage de l’informa)on -  Algorithmique
-  Algèbre de Boole et circuits électroniques -  Programma)on
-  Machine de Von Neumann Dr. Meziane-Tani I. 3
Introduc)on
•  Logiciel = Programmes + Données
•  Un programme : une suite d’instruc)ons exécutées dans un ordre donné par le

processeur afin de produire un résultat.
•  Un programme : le traitement automa)que (par une machine) d’une tâche

laborieuse si elle est exécutée par l’être humain. Exemples : - un traitement répé))f,
un gros calcul, un traitement long,…
•  Un programme est écrit dans un langage de programma)on « compris » par

l’ordinateur.
•  Le seul langage que comprend l’ordinateur est le binaire.
•  Cependant celui-ci n’est pas très maniable par l’être humain qui doit écrire les codes
(le programmeur) => appari)on des langages évolués : Pascal, C, Fortran, C++, Java,
etc.
•  Les programmes écrits dans des langages évolués sont traduits (par l’ordinateur lui
même) vers le langage binaire afin d’être exécutés par le processeur : la compilaBon.
Introduc)on
Énoncé du problème
Spécifica-on
Cahier des charges
Analyse
PréparaBon
Algorithme du
programme
Traduc-on
Programme (Codes sources)
Compila-on
Programme exécutable Étapes de réalisa-on

d’un programme
Tests et modifica-ons
Algorithme
•  Extrait du nom du mathéma)cien perse Al Khawarizmi.
•  Algorithme : Ensemble de règles opératoires dont l'applica)on permet de

résoudre un problème énoncé au moyen d'un nombre fini d'opéraBons.
[Larousse]

•  L’Algorithmique fait référence à la science qui étudie les algorithmes.

•  L’algorithme est écrit dans un langage facilement compris par l’être
humain => Décrit les étapes de résolu)on d’un problème donné.
•  Exemples :
•  Mode d’emploi pour faire fonc)onner une machine à laver.
•  Receke de cuisine pour préparer un plat.
•  I)néraire rou)er pour aller d’une ville à une autre.
•  ...
Algorithme / Programme
Algorithme Programme écrit en langage « C »
#include <stdio.h>
Algorithme Puissance2
#include <stdlib.h>

Variables x, y : en-ers Traduc)on int x, y;

Début
int main()
Lire(x)
{
y ç x * x
scanf(“%d”, &x);
Ecrire(y)
y = x * x;
Fin
prin<(”y=%d\n”, y);
return 0;
}
=> L’algorithme est plus compréhensible par un être humain.

Algorithme
•  Le langage algorithmique doit s’approcher le plus possible du langage humain. Il
peut être écrit dans la langue de celui qui écrit l’algorithme : français, anglais,
arabe, etc.
•  Le langage algorithmique doit tout de même respecter une certaine syntaxe pour
faciliter la compréhension.
•  Un algorithme n’est pas un programme prêt à être exécuté par une machine.
•  Pour exécuter un algorithme sur une machine, il faut d’abord le traduire, dans un
langage de programma)on, en un programme exécutable par un ordinateur.
•  Un algorithme doit être écrit indépendamment du langage de programma)on

dans lequel il sera traduit.
•  Pour un même problème il peut exister plusieurs façon de formuler la solu)on,

donc : plusieurs algorithmes.
Principales qualités d’un algorithme
–  Clair => Compréhensible par d’autres personnes
–  Correct => implémente correctement les tâches pour

lesquelles il a été conçu.
–  Complet => prend en considéra)on tous les cas

possibles en donnant un résultat pour chaque cas.
–  Efficace => Exécute sa tâche efficacement, c’est-à-dire

avec un coût minimal. Le coût pour un ordinateur se
mesure en temps de calcul et d’espace mémoire
alloué pour le programme et ses données.
ReprésentaBon d’un algorithme
•  Deux façons de représenter un algorithme :
–  Représenta)on graphique => Organigramme
–  Représenta)on textuelle => Pseudo-code
Organigramme
•  Une représenta)on graphique Exemple d’organigramme pour
u)lisant des symboles : carrés, le calcul de la puissance 2
losanges, rectangles, etc.
Début
Début et Fin Test Lire(x)

Succession
des
Traitement Lecture/Écriture instruc)ons y=x*x
•  Un organigramme décrit une vue

d’ensemble de l’algorithme.
Écrire(y)
•  C e k e r e p r é s e n t a ) o n e s t
q u a s i m e n t a b a n d o n n é e
aujourd’hui. Fin
Pseudo-Code
•  Représenta)on textuelle respectant une certaine
s y n t a x e q u i r e s s e m b l e à u n l a n g a g e d e
programma)on, d’où le nom « pseudo-code ».

•  Plus pra)que pour écrire un algorithme.
•  C’est ceke représenta)on qui est la plus u)lisée

aujourd’hui.
•  A u j o u r d ’ h u i , L e m o t a l g o r i t h m e d é s i g n e
principalement le pseudo-code.
Composants de base d’un algorithme
•  Certaines convenBons doivent être respectées pour écrire un
algorithme, telles que :
–  Nom : un algorithme doit porter un nom qui généralement décrit la

fonc)on de l’algorithme ou bien le problème qu’il résout.
–  Début et Fin : Délimiter le commencement et la fin de l’algorithme par

les mots clés : Début et Fin.
–  Noms significaBfs : il faut donner des noms significa)fs aux variables

afin de rendre l’algorithme plus compréhensible par d’autres
personnes.
–  Commentaires : écrits dans la langue du programmeur, ils sont u)les

pour expliquer les étapes de l’algorithme.
Structure de base d’un algorithme
Algorithme Nom de l’algorithme

/* La par-e déclara-ons de l’algorithme */ Commentaire

Constantes // les constantes nécessitent d’avoir une valeur dès leur déclara)on
const1 ç 10 : en)er

Variables // les variables proprement dites
var2, var3 : réels

/* corps de l’algorithme */
Début

/* instruc)ons */

Fin
Les variables
NoBon de variable (1/2)
•  Dans un programme, une donnée peut être :
–  Une donnée de départ : une entrée
–  Un résultat intermédiaire obtenu par le programme en cours
d’exécu)on
–  Résultat défini)f du programme : une sor)e.
•  Pendant l’exécu)on d’un programme informa)que, chaque

donnée doit être sauvegardée temporairement en mémoire
centrale. L’emplacement où sera stockée ceke donnée peut
changer de valeur pendant l’exécu)on du programme
=> l’emplacement mémoire contenant une donnée : variable.
NoBon de variable (2/2)
•  Les données manipulées par un programme
peuvent être :
–  des nombres (en)ers ou réels),
–  des données logiques (vrai ou faux),
–  des caractères,
–  du texte (suite de caractères),
–  etc.
=> Il faut réserver de l’espace mémoire (nombre de

bits) nécessaire au stockage de la variable :
déclaraBon de variable.
DéclaraBon de variable
•  Avant d’u)liser une variable, il faut d’abord la déclarer
dans la par)e déclara)on de l’algorithme.
•  Déclarer une variable consiste à donner :
–  Nom de la variable : appelé aussi « iden)ficateur ».
–  Type de la variable : désigne la plage de valeurs que peut

avoir la variable (en)er, réel, booléen, etc).
–  Une valeur : n’est pas obligatoire et peut se faire à

l’intérieur du corps de l’algorithme.
IdenBficateur de variables
•  L’iden)ficateur est le nom qu’on donne à une variable.
•  Conven)ons :
1.  l’iden)ficateur commence par une majuscule. Exemples : Nom, Prenom,
Age, …
2.  Les symboles acceptées sont : Chiffres, lekres minuscules, majuscules, )ret-
bas “_”. Exemples : Informa)que1, Informa)que_1 : corrects
3.  Ne commence pas par un chiffre. Exemple : 1Informa)que : incorrect.
4.  Éviter les caractère de ponctua)on et les espaces. Exemples : Informa)que

1, Informa)que-1, Informa)que&1 : Incorrects
5.  Doit être différent des mots réservés. Exemples : En)er, Début, Variable, ...
6.  De longueur raisonnable.
7.  Doit être significa)f et décrit la données manipulée.
Types de variables
•  Le type d’une variable détermine l’ensemble de
valeurs que peut prendre ceke variable ainsi que les
opéra)ons correspondantes.
•  Spécifier le type d’une variable au moment de sa

déclara)on est nécessaire afin de réserver de l’espace
mémoire pour son stockage.
•  Exemples :
–  En)er court : réserver 2 octets.
–  Caractère : réserver un octet.
Types prédéfinies
Type Valeur Exemples

En)er Les en)ers et les en)ers 17, -50, …
rela)fs
Réel Les réels 13.5, 0.5e3, …
Booléen VRAI ou FAUX
Caractère Les lekres, les chiffres et les ‘a’, ‘B’, ‘3’, ‘%’
symboles sont mis entre
apostrophes
Chaîne de caractères Les chaînes de caractères sont ‘’ Bonjour ’’, ‘’Ceci est une
mises entre guillemets chaîne’’
DéclaraBon de variables
•  Toute variable u)lisée dans un algorithme doit être déclarée avant
son u)lisa)on.
•  La déclara)on des variables n’est pas représentée sur

l’organigramme.
•  En pseudo-code : Variables liste d’iden-ficateurs : Type
•  Exemples :

Variables i, j, k : en@er
x, y : réel
OK : booléen
Chaine1, Chaine2 : Chaîne de caractères
Les constantes
NoBon de constante
•  Une constante est une variable dont la valeur ne change pas au cours de
l’exécu)on du programme, elle peut être :
–  un nombre
–  un caractère
–  une chaine de caractères.
•  Une constante doit toujours recevoir une valeur dès sa déclara)on.
•  En pseudo-code : Constante iden-ficateur ç valeur : type
•  Par conven)on, les noms de constantes sont écrits en majuscules
•  Exemple :
–  Pour calculer la surface des cercles, la valeur de pi est une constante mais le
rayon est une variable.
Constante PI ç 3.14 : réel
Variable Rayon : réel

La séquence d’instrucBons
Séquence d’instrucBons
•  Une instruc)on, appelée aussi « ac-on primi-ve » est une
opéra)on de base du processeur, d’un langage de
programma)on ou bien du langage algorithmique.
•  Les instruc)ons d’un algorithme sont habituellement

exécutées une à la suite de l’autre, de haut en bas et de
gauche à droite : elles forment une séquence d’instruc)ons.
•  L’ordre d’exécu)on des instruc)ons est important. Changer

l’ordre peut cause un dysfonc)onnement de l’algorithme.
Lire(A) Lire(A)
•  Exemple : A ç A + 1; est différent de : Ecrire(A)
Ecrire(A) A = A + 1;
Séquence d’instrucBons
•  En algorithmique, une instruc)on peut être :
–  Une instruc)on d’entrée ou de sor)e
–  Une affecta)on

–  Une structure alterna)ve
–  Une structure itéra)ve
Les entrées et sorBes
Les instrucBons d’entrées/sorBes
•  Les instruc)ons d’entrées et de sor)es
permekent à l’humain de communiquer avec
l’ordinateur.
•  Il existe deux types d’instruc)ons d’entrées/

sor)es :
–  La lecture
–  L’écriture
Lecture
•  La lecture est une instruc)on d’entrée qui permet d’introduire des
données numériques ou textuelles au moyen d’un clavier.
•  En pseudo-code : Lire(x)
•  L’ordinateur enregistre la valeur entrée au clavier à l’emplacement

mémoire réservé à la variable « x ».
•  Il faut toujours déclarer une variable avant de lire sa valeur.
•  A l’exécu)on : En exécutant un programme, celui-ci s’arrête

lorsqu’il rencontre une instruc)on de lecture jusqu’à l’introduc)on
de la valeur suivi de l’appui sur la touche « Entrée ».
Écriture
•  L’écriture est une instruc)on de sor)e qui permet d’afficher des résultats ou
bien des messages à l’écran.
Ecrire(liste d’expressions)
•  En pseudo-code : ou
Ecrire(expression 1, expression 2, expression 3, …)
•  L’ordinateur affiche à l’écran la liste des expressions qui peuvent être :

–  Des Variables : affiche les valeurs des variables.
–  Des valeurs numériques : affiche des nombres
–  Des chaînes de caractères: messages affichés à l’u)lisateur pour communiquer
avec lui.

Exemples :
–  Écrire(a) // Affiche la valeur de la variable a
–  Écrire(‘’La valeur de a est : ‘’, a) // affiche un message suivi de la valeur de a
–  Écrire(‘’La valeur de b est : ‘’, 2) // affiche un message suivi du nombre 2
–  Écrire(‘’La valeur de b est : ‘’, a+2) // affiche un message suivi du résultat de a+2
–  Écrire(‘’Veuillez introduire la valeur de x ’’) // affiche un message
Exemple
Algorithme AfficherNomComplet A l’exécu)on, ce qui est affiché à l’écran :

variables Nom, Prenom : chaîne de caractères

entrez le nom
Début Benarbi
entrez le prénom
Ecrire("entrez le nom") Mohamed
Lire(Nom) Votre nom complet est : Benarbi
Ecrire("entrez le prénom") Mohamed
Lire(Prenom)
Ecrire("Votre nom complet est : ", Nom, ‘’ ‘’,Prenom)

Fin Remarque : Benarbi et Mohamed sont
des valeurs introduites au clavier.
L’affectaBon
AffectaBon
•  Soit « v » une variable et « E » une expression.
•  Une affecta)on est une instruc)on dans laquelle le

résultat de l’expression E est affecté à la variable v.
•  Important : Le résultat de l’expression E doit être du

même type que la variable v.
•  La syntaxe de l’affecta)on est la suivante :

v ç E
AffectaBon
•  L’expression E peut être :
–  Une constante du même type : v ç 12,5
–  Une variable du même type : v ç u
–  Un ensemble de valeurs ou de variables du même type reliées entre elles par

des opérateurs : v ç u+w
Remarque : Une affectaBon n’est pas une équaBon mathémaBque
•  Exemples :
–  A ç A+1 (incrémenta)on) et A ç A-1 (décrémenta)on) ont un sens en
programma)on contrairement aux équa)ons.
–  A+1 ç 3 n’est pas une affecta)on possible et ne vaut pas Aç 2.
Opérateurs
•  En algorithmique, un opérateur est un symbole
qui représente une opéra)on qui, selon le type
des opérandes (variables), peut être :
–  ArithméBque : retourne un résultat numérique
–  Logique : retourne un résultat logique (vrai ou faux)
–  De comparaison : retourne un résultat logique (vrai

ou faux)
Type Opérateur Symbole
Opérateurs

addi)on +
soustrac)on -
Opérateurs
ArithméBques mul)plica)on *
division /
modulo %
puissance ^
Est égal =
Est différent ≠

Opérateurs de Est inférieur <
comparaison Est supérieur >
Est inférieur ou égal ≤
Est supérieur ou égal ≥
Inverse NON
Opérateurs Et ET
logiques
Autre Concaténa)on de chaînes &
de caractères
Quelques exemples
•  OpéraBon ArithméBque :
–  v ç 15 + 5 => v vaut 20
•  OpéraBon de comparaison :
–  v ç 6 > 8 => v (une variable booléenne) vaut faux car 6 n’est pas
supérieur à 8.
•  OpéraBon logique :
–  v ç (8 % 5 = 3) OU (5 > 10) => v vaut vrai

car : 8%5 vaut 3
(8%5 = 3) vaut vrai
(5 > 10) vaut faux
(vrai OU faux) vaut vrai.
Règles d’uBlisaBon des opérateurs
•  L’évalua)on d’une expression se fait en tenant
compte des priorités des opérateurs.
–  Exemple : 2+5*4 vaut 22
•  Pour forcer les priorités, des parenthèses sont

u)lisées.
–  Exemple : (2+5)*4 vaut 28
•  Si les opérateurs ont la même priorité,

l’expression est évaluée de gauche à droite.
–  Exemple : 2+5+7 se calcule (2+5)+7 et vaut 14.
Priorités des opérateurs
Ordre de priorité Opérateurs
1 ()
2 ^
3 * / %
4 + -
5 < ≤ > ≥
6 = ≠
7 NON
8 ET OU
9 ç
Exemple d’exécuBon d’un algorithme
Algorithme Affecta-ons
Déroulement de l’algorithme :
Variables A, B, C: En@er
InstrucBon A B C
Début A←7 7 ? ?
A←7 B ← 17 7 17 ?
B ← 17 A←B 17 17 ?
B ← A+5 17 22 ?
A←B
C←A+B 17 22 39
B ← A+5
C←A+B A = 17
Résultats : B = 22
Fin C = 39
Les structures alternaBves
Structure alternaBve
•  Une structure alterna-ve, appelée aussi structure
condi-onnelle est une structure algorithmique dans
laquelle une suite d’instruc)ons n’est exécutée que si
une condi)on est vérifiée.
•  Une condi-on est une expression qui retourne une

valeur booléenne.
–  Exemple : (Delta > 0)
•  Remarque : Dans le jargon informa)que, les structures

condi)onnelles sont souvent appelées « Tests ».
CondiBon composée
•  Une condi)on peut être :
–  Simple : Généralement une opéra)on de comparaison

comportant un seul opérateur de comparaison (=, ≠, <, ≤ ,
> , ≥).
Exemple :
§  Age supérieur à 30 : Age > 30.
–  Composée : Une suite d’expressions de comparaison

reliées par des opérateurs logiques.
Exemples :
§  x compris entre 1 et 10 : (x ≥ 1) ET (x ≤ 10)
§  n divisible par 2 ou 5 : (n % 2 = 0) OU (n % 5 = 0)

Types de structures alternaBves
1.  Alterna)ve simple
–  Si … alors ... Finsi
2.  Alterna)ve complète

–  Si … alors ... Sinon ... Finsi
3.  Alterna)ve imbriquée

–  Plusieurs « Si » imbriqués
–  L’instruc)on « Selon »
1. AlternaBve simple
Si … alors ... Finsi
AlternaBve simple
La structure algorithmique pour effectuer un test simple est la suivante :
Début
Si Condi-on alors
/* Séquence d’instruc-ons */
Finsi
Condi)on
?
-  Condi-on est une expression booléenne qui doit
retourner un résultat VRAI ou FAUX. VRAI
-  La séquence d’instruc)ons n’est exécutée que si la Instruc)ons

Condi-on retourne un résultat VRAI.
-  Si Condi-on retourne un résultat FAUX, aucune Fin

instruc)on à l’intérieur du test n’est exécutée et on
reprend l’exécu)on de l’algorithme après le Finsi. Organigramme
Exemple
Exemple : Écrire un algorithme qui permet de lire un en)er x puis de vérifier
si sa valeur est posi)ve ou nulle. Dans ce cas afficher un message.
Algorithme En-erPosi-f

Variables x: En@er

Début

Lire(x)
Si x ≥ 0 alors
Écrire(‘’La valeur de x est posi-ve ou nulle’’)
Finsi

Fin
2. AlternaBve complète
Si … alors ... Sinon ... Fin si
AlternaBve complète
Pseudo-code :
Si Condi-on alors Début
/* Séquence d’instruc-ons 1 */
Sinon
/* Séquence d’instruc-ons 2 */ FAUX
Condi)on
Finsi ?
-  Condi-on est une expression booléenne qui doit VRAI

retourner un résultat VRAI ou FAUX.
Instruc)ons 1 Instruc)ons 2
-  La « séquence d’instruc)ons 1 » est exécutée si la
Condi-on retourne un résultat VRAI.
-  Si Condi-on retourne un résultat FAUX, la « séquence Fin

d’instruc)ons 2 » sera exécutée. Organigramme
Exemple
Exemple : Écrire un algorithme qui permet de lire un en)er x puis d’afficher
sa valeur absolue.
Algorithme ValeurAbsolue

Variables x: En@er

Début

Lire(x)
Si x ≥ 0 alors
Écrire(‘’La valeur absolue de x est :’’, x)
Sinon /* x < 0 mais pas besoin de revérifier la condi-on */
Écrire(‘’La valeur absolue de x est :’’, -x)
Finsi

Fin
3. AlternaBve imbriquée
AlternaBve imbriquée
•  Il est possible d’effectuer un test à l’intérieur d’un autre test : imbricaBon.
•  Le degré d’imbrica)on n’est pas limité mais doit tout de même être raisonnable.
Pseudo-code :
Début
Si Condi-on 1 alors
Si Condi-on 2 alors
/* Séquence d’instruc-ons 1 */ VRAI Condi)o FAUX
Sinon n 1 ?
/* Séquence d’instruc-ons 2 */ FAUX
Condi)o Condi)o
Finsi n 2 ? n 3 ?
VRAI
Sinon FAUX
Si Condi-on 3 alors VRAI Instruc)ons 2 Instruc)ons 4
/* Séquence d’instruc-ons 3 */
Sinon
/* Séquence d’instruc-ons 4 */ Instruc)ons 1 Instruc)ons 3
Finsi
Finsi
Dr. Meziane-Tani I. Fin 53

Exemple
•  Écrire un algorithme permekant de vérifier si un en)er « x » saisi
au clavier est posi)f, nul ou bien néga)f. Afficher un message pour
chaque cas.
Algorithme Signe

Variables x: En@er

Début

Lire(x)
Si x > 0 alors
Écrire(‘’Le nombre est posi-f’’)
Sinon
Si x = 0 alors
Écrire(‘’Le nombre est nul’’)
sinon
Écrire(‘’Le nombre est néga-f’’)
Finsi
Finsi

Fin
L’instrucBon « Selon … FinSelon »
•  Les tests imbriqués peuvent parfois être

remplacés par l’instruc)on ‘’Selon …FinSelon’’.
•  Ceci est possible lorsque les tests imbriqués

effectuent la comparaison de la même
variable avec plusieurs valeurs.
Selon … FinSelon
En Pseud-code :
SELON 1.  La condiBon 1 est évaluée :

Condi)on 1 : Ac)on 1 •  Si la condi)on 1 est vraie, alors on exécute
l'ac)on correspondante et on quike la structure
Condi)on 2 : Ac)on 2 selon.
•  Si la condi)on 1 est fausse, on évalue la
... condi)on 2...et ainsi de suite.

Condi)on n : Ac)on n 2.  Si aucune n'est vraie on effectue l'acBon sinon

SINON : ac)on_sinon Remarque : l'ac)on sinon n’est pas obligatoire. Si
elle n'existe pas alors aucune ac)on n'est exécutée
FINSELON dans le cas où aucune condi)on n’et vérifiée.

Exemple
•  Résoudre l’exemple précédent (le signe d’un nombre
introduit au clavier) en u)lisant l’instruc)on Selon.
Algorithme Signe

Variables x: En@er

Début
Lire(x)

Selon
x > 0 : Écrire(‘’Le nombre est posi-f’’)
x < 0 : Écrire(‘’Le nombre est néga-f’’)
Sinon : Écrire(‘’Le nombre est nul’’)
FinSelon

Fin
Les structures répéBBve
Structure répéBBve
•  Une structure répéBBve ou structure itéraBve est une
structure algorithmique qui consiste à répéter un ensemble
d’instruc)ons un certain nombre de fois.

•  Aken)on : le nombre de répé))ons ne peut être infini ! Il
faut toujours s’assurer que la structure répé))ve s’arrête
après un nombre fini de répé))ons.
•  Remarques :
- En jargon informa)que, une structure répé))ve est
généralement appelée « boucle ».
- Une répé))on est appelée : itéraBon.
Structure répéBBve
•  Le nombre d’itéra)ons peut être donné de deux différentes
manières :
–  Un compteur
–  Une condi)on d’arrêt des répé))ons
•  Il existe 3 types de structures répé))ves (boucles) :

1.  La boucle : « TantQue … Faire ... FinTantQue » => Condi)on
2.  La boucle : « Répéter ... Jusqu’à » => Condi)on
3.  La boucle : « Pour … de ... à ... Pas ... FinPour » => Compteur
•  Le choix d’un type de boucle dépend des données dont ont

dispose (compteur ou condi)on d’arrêt).
1. TantQue … Faire ... FinTantQue
La boucle « TantQue »
•  Une séquence d’instruc)ons est répétée tant
qu’une condi)on est vérifiée.
Pseudo-code :
Début
TantQue Condi-on Faire
FinTantQue VRAI
Condi)on
Instruc)ons
?
Remarques :
-  La Condi-on est évaluée avant chaque FAUX Organigramme
itéra)on.
-  Il est possible que la séquence
d’instruc)ons ne soit jamais exécutée. Fin
Exemple
•  Écrire un algorithme qui demande à l’u)lisateur d’introduire
une note jusqu’à ce que celle-ci soit valide (0 ≤ note ≤ 20).
Algorithme SaisiNote

Variables Note: En@er

Début
Ecrire(“Introduire une note :”)
Lire(Note)

TantQue (Note < 0) OU (Note > 20) faire
Ecrire(“La note n’est pas valide. Veuillez recommencer”)
Lire(Note)
FinTantQue

Ecrire(“Note Correcte.”)

Fin Dr. Meziane-Tani I. 63
2. Répéter… Jusqu’à ...
La boucle « Répéter »
•  Répéter une séquence d’instruc)ons jusqu’à
ce qu’une condi)on soit vérifiée. Dans ce cas,
on sort de la boucle. Début
Pseudo-code :
Répéter
Instruc)ons
Jusqu’à Condi-on
FAUX
Condi)on
Remarques : ?
-  La Condi-on est évaluée après chaque
itéra)on. VRAI
-  La séquence d’instruc)ons est exécutée
au moins une fois. Fin
Dr. Meziane-Tani I. Organigramme 65

Exemple
•  Écrire un algorithme qui calcule le nombre, N, des premiers
nombres posi)fs tels que leur somme est supérieure ou égale
à 100. N =? ∑
(1+ 2 + 3+ 4 +... + N ) ≥ 100
Algorithme Somme100
Variables N, Somme, i: En@er

Début

Somme ← 0
i ← 0
Répéter
i ← i + 1
Somme ← Somme + i
Jusqu’à Somme ≥ 100
Ecrire(“La valeur de N est : “, i)

Boucles TantQue/Répéter
- Risque de boucle infini -
•  Dans une boucle TantQue ou dans une boucle Répéter,
il faut bien choisir la condi)on de sorte que la boucle
fini toujours par s’arrêter et ce afin d’éviter la boucle
infini => Problème de satura)on du processeur !
Algorithme BoucleInfini
•  Exemple : Variables i: En@er

Début
i ←1
TantQue i > 0 faire
i ← i+1
FinTantQue
Fin
3. Pour … de ... à ... Pas ... Faire ...
FinPour
La boucle « Pour »
•  Une séquence d’instruc)ons est exécutée un certain nombre
de fois connu à l’avance.
Pseudo-code :
Pour Compteur de Ini-ale à Finale Pas Valeur_Pas Faire
FinPour
-  Compteur : une variable qui sert à compter le nombre

d’itéra)ons
-  Ini@ale : la valeur ini)ale du compteur. Doit être donnée.
-  Finale : la valeur finale du compteur. Doit être donnée. Finale
n’est pas toujours supérieure à Ini-ale.
-  Valeur_Pas : la valeur du pas d’incrémenta)on du compteur.
Ceke valeur est op)onnelle. Si elle n’est pas donnée, elle sera
par défaut égale à « 1 ».
- Organigramme -
Début
cpt ← ini)ale
cpt ← cpt + Valeur_Pas
VRAI
cpt ≤ Finale* Instruc)ons
FAUX
* : la condi)on devient cpt ≥ Finale
Fin si Finale < Ini)ale.
Exemple 1
•  Écrire un algorithme qui demande à l’u)lisateur un
nombre en)er de départ et qui ensuite affiche les 10
en)ers suivants.
Algorithme NombresSuivants

Variables Depart, i: En@er

Début
Ecrire(“Introduire un nombre de départ :”)
Lire(Depart)

Pour i de 1 à 10 Pas 1 faire /* i est un compteur qui compte les nombres */
Ecrire(Depart+i) /* afficher les en-ers qui suivent la valeur Depart */
FinPour

Fin
Exemple 2
•  Écrire un algorithme qui demande à l’u)lisateur un
nombre en)er final et qui ensuite affiche les 10
en)ers précédents dans un ordre croissant.
Algorithme NombresPrecedents

Variables Final, i: En@er

Début
Ecrire(“Introduire un nombre final”)
Lire(Final)

Pour i de 10 à 1 Pas -1 faire /* le compteur est décrémenté par pas de -1 */
Ecrire(Final-i) /* afficher les en-ers qui précèdent Final */
FinPour

Fin
- Quelques remarques -
•  Avec la boucle « Pour », il n’y a pas de risque de boucle
infinie car les valeurs « Ini)ale » et « Finale » sont
obligatoirement définies avec des valeurs numériques.
•  Pour qu’il n’y ait pas de dysfonc)onnement de la

boucle « pour », il faut éviter de modifier la valeur du
compteur à l’intérieur de la boucle.
–  Exemple :
En ajoutant l’incrémenta)on du i
Pour i de 0 à 10 Pas 1 Faire à l’intérieur de la boucle, ceke
Ecrire(i) variable sera incrémentée de 2
pas à chaque itéra)on.
i ← i + 1
Les valeurs de « i » sont donc : 0,
FinPour 2, 4, 6, 8, 10.
Remarque Pour/TantQue
•  La boucle Pour peut être remplacée par une boucle TantQue.
Pour Compteur de Ini-ale à Finale Pas Valeur_Pas Faire
FinPour
Compteur ← Ini-al
TantQue Compteur ≤ Finale* Faire
Compteur ← Compteur + Valeur_Pas
FinTantQue
* : la condi)on devient compteur ≥ Finale si Finale < Ini)ale.

•  Il n’est pas toujours possible de remplacer la boucle TantQue
par la boucle Pour sauf si le nombre d’itéra)ons est connu.
Choix du type de boucle
•  Si le nombre d’itéra)ons est connu à l’avance :
=> Choisir la boucle Pour
•  Sinon :
–  Si la condi)on de la boucle ne peut être vérifié
qu’après une première itéra)on OU Si au moins
une itéra)on est obligatoire :
=> Choisir la boucle Répéter
–  Sinon :
=> Choisir la boucle TantQue
Quelques exemples…
•  Exemple 1 : Écrire un algorithme qui
demande successivement 20 nombres à
l’u)lisateur, et qui lui dise ensuite quel était le
plus grand parmi ces 20 nombres.
•  Exemple 2 : Écrire un autre algorithme qui

demande successivement plusieurs nombres à
l’u)lisateur et affiche leur maximum, mais ceke
fois-ci la saisie des nombres s’arrête lorsque
l’u)lisateur entre un zéro.
SoluBon Exemple 1
Algorithme PlusGrandNombre
Variables N, i, Max : En@er

Debut
Max ← 0

Pour i de 1 à 20 Pas 1
Ecrire("Entrez un nombre : ”)
Lire(N)

Si (i = 1) OU (N > Max ) Alors
Max ← N
FinSi

FinPour

Ecrire("Le nombre le plus grand était : ", Max )
Fin.
SoluBon Exemple 2
TantQue
Algorithme PlusGrandNombre2
Variables N, i, Max: En@er

Debut
N ← 1
i ← 0
Max← 0

TantQue N <> 0
Lire(N)
i ← i + 1

Si (i = 1) OU (N > Max) Alors
Max← N
FinSi

FinTantQue

Ecrire("Le nombre le plus grand était : ", Max)
Fin
SoluBon Exemple 2
Répéter
Algorithme PlusGrandNombre3
Variables N, i, Max: En@er

Debut
i ← 0
Max← 0

Répéter
Lire(N)
i ← i + 1

Si (i = 1) OU (N > Max) Alors
Max← N
FinSi
Jusqu’à N=0

Ecrire("Le nombre le plus grand était : ", Max)
Fin
Boucles imbriquées
•  En fonc)on du problème abordé, il est possible que les
instruc)ons d’une boucle soient à leur tour une
boucle : du même type ou d’un autre type.
•  Exemple : Afficher le triangle ci-dessous en u)lisant

une boucle « Pour ».
*
**
***
****
*****
******
*******
Boucles imbriqués
- Exemple -
Algorithme Pyramide

Variables i, j: En@er

Début

Pour i de 1 à 7 faire /* i compte les lignes */
Pour j de 1 à i faire /* j compte le nombre d’étoiles de chaque ligne */
Ecrire(“*”)
FinPour
FinPour

Fin
Les types complexes
Types complexes
•  Les types complexes ne désignent pas les nombres complexes !
•  Types complexes : désignent des types de données dont la

structure est plus complexe que les types prédéfinies (En)er, Réel,
Caractère, etc.).
•  En algorithmique :
–  Les tableaux
–  Les enregistrements
–  Les listes
–  Les Piles et les Files
–  Les arbres
–  Etc.
1 – Les tableaux
IntroducBon
•  Reprenons l’exemple des boucles où il était demandé d’introduire
20 nombres puis d’afficher le maximum de ces nombres comme
résultat.
•  Supposons qu’il fallait afficher les 20 nombres introduits après avoir

affiché le maximum. Quelle serait la solu)on ?
⇒  Il faudrait alors sauvegarder les 20 nombres !

•  Comment faire alors pour sauvegarder les 20 nombres ?
⇒  Déclarer 20 variables ?

•  Et s’il était demandé d’introduire 100 nombres ? 200 nombres ? …
⇒  Il faut stocker tous les nombres dans une seule structure de
données (variable) de type “Tableau”.
Tableau
•  Un tableau est une structure de données qui
permet de manipuler un ensemble de données
de même type.
•  Un tableau est une variable qui sert à stocker en

mémoire plusieurs valeurs.
•  Les données sont stockées de façon « con)güe »,

c’est à dire la première données suivi de la
deuxième, suivi de la troisième … Et ainsi de
suite.
ReprésentaBon d’un tableau
ReprésentaBon graphique :
Élément 1 Élément 2 Élément 3 …......... Élément n-1 Élément n
RAM
ReprésentaBon en mémoire :
Élément 1
Élément 2
Élément 3
Tableau de n
: éléments
:
Élément n
Taille du tableau = n x Taille d’un élément [Bits]

DéclaraBon d’un tableau (1/2)
•  Un tableau est déclaré comme une variable.
•  Déclarer un tableau consiste à donner :
–  Le nom du tableau : il fait référence à l’adresse du premier

élément du tableau.
–  Le type de données : tous les éléments du tableaux doivent être

de même type. Généralement le type fait référence à un type
prédéfini (En)er, Réel, etc.)
–  La taille du tableau : le nombre maximal de données qui

peuvent être stockées dans le tableau : nécessaire pour la
réserva)on d’espace mémoire.
DéclaraBon d’un tableau (2/2)
•  En pseudo-code :
Variable nom_tableau[nombre_elements]: type_elements
•  Exemple : Déclarer un tableau de 20 en)ers.
Variable T[20]: En@er
Accéder aux éléments du tableau
•  Pour accéder à un élément du tableau, il faut donner le nom du tableau et
le numéro d’ordre (entre crochets []) de l’élément dans le tableau.
•  Exemples :
–  T[3] ← 4.
–  N = T[1]+T[2]
•  Le numéro d’ordre est appelé : « Indice ».
•  Important : Par conven)on, le premier élément du tableau possède

l’indice « 0 » => T[0].
•  Exemple :
–  Les éléments du tableau précédent sont : T[0], T[1], T[2], … T[19]
Indices
0 1 2 n-2 n-1
T[0] T[1] T[2] …......... T[n-2] T[n-1]
Valeur d’un élément

Lecture d’un tableau (1/2)
•  Lire un tableau consiste à lire les éléments du
tableau.
•  Pour lire les éléments d’un tableau, il faut u)liser

une boucle qui « répète » le même traitement
qui est « lecture d’un élément » du tableau.
•  La taille d’un tableau étant connue dès sa

déclara)on => Une boucle « Pour » peut être
u)lisée.
Lecture d’un tableau (2/2)
•  Écrire un algorithme qui demande à l’u)lisateur
d’introduire les 20 éléments d’un tableau d’en)ers T.
Algorithme LectureTableau
Constante N←20 : En@er /* La taille du tableau est déclarée comme une constante
*/
Variables i: En@er
T[N] : En@er

Début

Pour i de 0 à N-1 faire /* i : indice qui compte les éléments du tableau */
Ecrire(“T[“, i, “] = ”) /* affiche le nom de la case */
Lire(T[i])
FinPour

Fin
Écriture (Affichage) d’un tableau
•  Écrire un algorithme qui affiche les 20 éléments d’un
tableau d’en)ers T.
Algorithme EcritureTableau
Constante N←20 : En@er /* La taille du tableau est déclarée comme une
constante */
Variables i: En@er
T[N] : En@er

Début

Pour i de 0 à N-1 faire /* i : indice qui compte les éléments du tableau */
Ecrire(“T[“, i, “] = ”, T[i]) /* affiche le nom de la case */
FinPour

Fin
Mise à jour d’un tableau
•  Les opéra)ons de mise à jour sont les opéra)ons qui
permekent de modifier les éléments d’un tableau.
•  il existe 3 types de mises à jour :
–  ModificaBon d’un élément du tableau
–  InserBon d’un élément à un tableau

–  Suppression d’un élément du tableau
ModificaBon
La modifica)on d’un élément du tableau consiste à
remplacer la valeur d’un élément par une autre valeur.

La taille du tableau ne change pas après modifica)on.
Avant modificaBon :
0 1 p-1 p p+1 n-1
T[0] T[1] … ... T[p] ... …. T[n-1]
Après modificaBon :
0 1 p-1 p p+1 n-1
T[0] T[1] … ... x ... ... T[n-1]
Algorithme de modificaBon
Écrire un algorithme qui permet de modifier l’élément qui se trouve à
l’emplacement « p » d’un tableau d’en)ers T par la valeur de « x ».
Algorithme Modifica-on
Constante N←20 : En@er
Variables p, x: En@er
T[N] : En@er
Début

Lire(x,p)
T[p] ← x /* remplacer la valeur de T[p] par x */

InserBon
L’inser)on d’un élément « x » à l’emplacement « p » d’un
tableau consiste à :
–  Décaler vers la droite tous les éléments à par)r de l’indice
p.
–  Insérer cet élément dans la case T[p]
=> la taille du tableau après inser)on : n+1.
Avant inserBon :
0 1 p-1 p p+1 n-1
T[0] T[1] … T[p-1] T[p] T[p+1] …. T[n-1]
Après inserBon :
0 1 p-1 p p+1 p+2 n
T[0] T[1] … T[p-1] x T[p] T[p+1] …. T[n-1]
Algorithme d’inserBon
Écrire un algorithme qui permet d’insérer un élément « x » à l’emplacement
« p » d’un tableau, T, d’en-ers. T est supposé donné.
Algorithme Inser-on
Variables i, p, x: En@er
T[N], T_nouveau[N+1] : En@er /*T_Nouveau : Nouveau tableau après inser-on de x. */

Début
Lire(x,p)
Pour i de 0 à p-1 faire /* Les éléments de 0 à p-1 sont conservés dans le tableau T_nouveau */
T_nouveau[i] ← T[i]
FinPour

Pour i de p+1 à N faire /* Ceƒe boucle décale les éléments de p+1 à N-1. */
T_nouveau[i] ← T[i-1]
FinPour

T_nouveau[p] ← x /* Insérer l’élément x à l’emplacement p */
Fin
Suppression
La suppression d’un élément qui se trouve à
l’emplacement « p » d’un tableau consiste à :
–  Décaler vers la gauche tous les éléments à par)r de
l’indice p+1.
=> la taille du tableau après inser)on : n-1.
Avant suppression :
0 1 p-1 p p+1 n-1
T[0] T[1] … T[p-1] T[p] T[p+1] …. T[n-1]
Après suppression :
0 1 p-1 p n-2
T[0] T[1] … T[p-1] T[p+1] …. T[n-1]
Algorithme de suppression
Écrire un algorithme qui permet de supprimer l’élément qui se trouve à
l’emplacement « p » d’un tableau, T, d’en-ers. T est supposé donné.
Algorithme Suppression
Variables i, p, x: En@er
T[N], T_nouveau[N-1] : En@er /*T_Nouveau : Nouveau tableau après suppression de x. */

Début
Lire(p)
Pour i de 0 à p-1 faire /* Les éléments de 0 à p-1 sont conservés dans le tableau T_nouveau */
T_nouveau[i] ← T[i]
FinPour

Pour i de p à N-2 faire /* Ceƒe boucle décale les éléments de p+1 à N-1. */
T_nouveau[i] ← T[i+1] /* la suppression est effectuée en affectant à T[p] ← T[p+1] */
FinPour

Algorithme de Recherche
Principe
•  Étant donnés un tableau T et une valeur x(l’élément que
l’on cherche), plusieurs types de problèmes peuvent être
posés :
–  l’élément est-il ou non dans la collec)on ? autrement dit x∈T ?
–  si l’élément est dans la collec)on, où peut-on le trouver ?

autrement dit, pour quel indice i a-t-on T[i]=x?
•  Ceke dernière ques)on pouvant être déclinée de plusieurs

façons :
–  quel est le plus pe)t indice I tel que T[i]=x ?
–  quel est le plus grand ?
–  quels sont tous les indices ?
Algorithmes de recherche
•  Dans un ensemble de données non triées :
–  Recherche séquen)elle
•  Dans un ensemble de données triées :

–  Recherche séquen)elle
–  Recherche dichotomique

Recherche séquenBelle
- Ensemble non trié -
•  Principe : Parcourir un ensemble de données à la recherche d’un
élément. Arrêter la recherche dès que l’élément est trouvé.
Algorithme RechercheSéquen)elle
Variables Trouve : Booléen
i,x : En@er
T[N] : En@er
Début
Lire(x)
Trouve ← Faux
i←0
TantQue (NON Trouve) ET (i<n) faire
Si T[i]=x alors
Trouve ← Vrai
FinSi
i←i+1
FinTantQue
Fin.
Recherche séquenBelle
- Ensemble trié -
•  Principe : En supposant que l’ensemble est trié par ordre croissant,
parcourir l’ensemble des éléments dont l’élément recherché est
inférieur. Arrêter la recherche dès que l’élément courant devient
supérieur ou égale ou qu’on a parcouru tout l’ensemble.
Algorithme RechercheSéquen)elle2
i,x : En@er
T[N] : En@er
Début
Lire(x)
i←0
TantQue (i < n) ET (x > T[i])
i←i+1
FinTantQue
Si (i < n) ET (x = T[i]) alors
Trouve ← Vrai
Sinon
Trouve ← Faux
FinSi Dr. Meziane-Tani I. 104
Fin.
Recherche dichotomique
- Ensemble trié -
•  Dichotomie vient de dic)onnaire : méthode inspirée de la
recherche d’un mot dans un dicBonnaire.
•  Principe :
–  Diviser le tableau en deux par)es et comparer la valeur
recherchée avec l'élément situé au milieu du tableau (l'élément
médian).
–  Si la valeur recherchée correspond à l'élément médian, alors

l'algorithme s'arrête et renvoie l'indice de cet élément.
–  Sinon l'algorithme va répéter la recherche uniquement dans la

par)e qui peut contenir la valeur recherchée.

0 1 Diviser le tableau
en deux par)es
0 1
Si x < milieu
0 1
Rediviser la par)e
gauche en deux par)es
0 1 Ainsi de suite…
Algorithme RechercheDichotomique
x, d, f, m : En@er // d : indice du premier élement
T[N] : En@er // f : indice du dernier élement
Début // m : indice du milieu
d ← 0
f ← n−1
TantQue d < f faire
m ← (d+f)/2 /* Milieu du tableau : Division en-ère */
Si T[m] < x alors
d ← m+1 /*rechercher dans la par-e gauche*/
Sinon
f ← m /*rechercher dans la par-e droite*/
FinSi
FinTantQue
Si x = T[d] alors
Trouve ← Vrai
Sinon
Trouve ← Faux
FinSi
Fin.
2 – Les enregistrements

Enregistrements
•  Un enregistrement est un type ou une structure de
données permekant de définir un ensemble fini de
données (ou variables) qui ne sont pas du même type
(contrairement aux tableaux où tous les éléments doivent
être de même type).
•  Exemple : Le nom, le prénom, l’âge et la moyenne d’un

élève sont des données de types différents mais qui restent
reliés par la no)on d’élève => Nous pouvons regrouper
alors ces 4 informa)ons dans un enregistrement.
•  Les éléments qui composent un enregistrement sont

appelés : « Champs ». Exemples : Nom, Prénom, …

DéclaraBon d’un type enregistrement
•  A v a n t d e d é c l a r e r u n e v a r i a b l e d e t y p e
enregistrement, il faut d’abord définir son type.
Nom_Enregistrement : Enregistrement
Nom_Champ_1 : Type_Champ_1
Nom_Champ_2 : Type_Champ_2
…
Nom_Champ_n : Type_Champ_n
FinEnregistrement
•  La défini)on d’un type se fait dans la par)e déclara)on

des variables juste avant la déclara)on des variables et
après la déclara)on des constantes.

Exemples
Personne: Enregistrement Date: Enregistrement
Nom : Chaîne de caractère Jour : En-er
Prénom : Chaîne de caractère Mois : En-er
Age : En-er Année : En-er
FinEnregistrement FinEnregistrement

Point: Enregistrement Complexe: Enregistrement

Num : En-er Re : Réel
Abscice : Réel Im: Réel
Ordonnée : Réel FinEnregistrement
FinEnregistrement

DéclaraBon de variables de type
Enregistrement
•  Une fois que le type Enregistrement défini, on
peut déclarer des variables de ce type de la
même manière que la déclara)on de variables
de types primi)fs est faite.
•  Pseudo-code : Nom_variable : Nom_Enregistrement
•  Exemple : P: Personne

ManipulaBon d’un enregistrement
•  La manipula)on d’un enregistrement est faite à travers les champs
qui le définissent.
•  Pour accéder au champ d’un enregistrement :

Nom_Variable.Nom_champs
•  Exemples :
–  Personne.Age
–  Complexe.Im
•  Les champs d’un enregistrement sont considérés comme des

variables qui peuvent être u)lisées dans tout type d’instruc)ons :
affecta)ons, lecture/écriture, ….

Exemple
•  Afficher les champs de l’enregistrement P de type
Personne. Nous supposons que les champs ont été lus
auparavant.
Algorithme EnregistrementPersonne

Personne: Enregistrement /*défini-on du type Personne*/
Nom : Chaîne de caractères
Prenom : Chaîne de caractères
Age : En-er
FinEnregistrement

Variables P : Personne /*déclara-on de la variable P de type Personne*/

Début
Ecrire (‘’Le nom de la personne est : ’’, P.Nom)
Ecrire (‘’Le prénom de la personne est : ’’, P.Prenom)
Ecrire (‘’L’âge de la personne est : ’’, P.Age)

Fin. Dr. Meziane-Tani I. 114
Remarque
•  Un enregistrement peut contenir un champ d’un autre type
enregistrement.
•  Exemple : Une personne possède une date de naissance.

Date: Enregistrement Le champs Date_Naiss est manipulé comme
Jour : En-er suit :
Mois : En-er
Année : En-er
FinEnregistrement P.Date_Naiss.Jour
P.Date_Naiss.Mois
Personne: Enregistrement P.Date_Naiss.Année
Nom : Chaîne de caractère
Prénom : Chaîne de caractère
Date_Naiss : Date
FinEnregistrement

Variables P: Personne
Références
•  Introduc)on à l’algorithmique, C. Darmangeat, Université
Paris 7, Cours.
•  Ini)a)on à l’algorithmique, 2007
•  Algorithmique, A. EL Harraj, 2015, Cours.
•  Les bases de l’informa)que et de la programma)on, R.M. Di

Scala, 2005.

Chapitre5 2019

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Chapitre5 2019

Hochgeladen von

Copyright:

Verfügbare Formate

École

Préparé et présenté par Dr. Meziane Tani I.

• Structure d’un Algorithme

• No)on de variable et de constante

• Les types complexes

• Un programme : une suite d’instruc)ons exécutées dans un ordre donné par le

• Un programme : le traitement automa)que (par une machine) d’une tâche

• Un programme est écrit dans un langage de programma)on « compris » par

• Le seul langage que comprend l’ordinateur est le binaire.

Cahier des charges

Programme (Codes sources)

Programme exécutable Étapes de réalisa-on

• Algorithme : Ensemble de règles opératoires dont l'applica)on permet de

=> L’algorithme est plus compréhensible par un être humain.

• Un algorithme doit être écrit indépendamment du langage de programma)on

• Pour un même problème il peut exister plusieurs façon de formuler la solu)on,

– Correct => implémente correctement les tâches pour

– Complet => prend en considéra)on tous les cas

– Eﬃcace => Exécute sa tâche eﬃcacement, c’est-à-dire

• Deux façons de représenter un algorithme :

– Représenta)on graphique => Organigramme

– Représenta)on textuelle => Pseudo-code

Début et Fin Test Lire(x)

• Un organigramme décrit une vue

• C’est ceke représenta)on qui est la plus u)lisée

– Nom : un algorithme doit porter un nom qui généralement décrit la

– Début et Fin : Délimiter le commencement et la ﬁn de l’algorithme par

– Noms signiﬁcaBfs : il faut donner des noms signiﬁca)fs aux variables

– Commentaires : écrits dans la langue du programmeur, ils sont u)les

• Pendant l’exécu)on d’un programme informa)que, chaque

=> Il faut réserver de l’espace mémoire (nombre de

• Déclarer une variable consiste à donner :

– Nom de la variable : appelé aussi « iden)ﬁcateur ».

– Type de la variable : désigne la plage de valeurs que peut

– Une valeur : n’est pas obligatoire et peut se faire à

3. Ne commence pas par un chiﬀre. Exemple : 1Informa)que : incorrect.

4. Éviter les caractère de ponctua)on et les espaces. Exemples : Informa)que

6. De longueur raisonnable.

7. Doit être signiﬁca)f et décrit la données manipulée.

• Spéciﬁer le type d’une variable au moment de sa

Type Valeur Exemples

• La déclara)on des variables n’est pas représentée sur

• En pseudo-code : Variables liste d’iden-ﬁcateurs : Type

• Une constante doit toujours recevoir une valeur dès sa déclara)on.

• En pseudo-code : Constante iden-ﬁcateur ç valeur : type

• Par conven)on, les noms de constantes sont écrits en majuscules

• Les instruc)ons d’un algorithme sont habituellement

• L’ordre d’exécu)on des instruc)ons est important. Changer

– Une instruc)on d’entrée ou de sor)e

– Une structure itéra)ve

• Il existe deux types d’instruc)ons d’entrées/

• L’ordinateur enregistre la valeur entrée au clavier à l’emplacement

• Il faut toujours déclarer une variable avant de lire sa valeur.

• A l’exécu)on : En exécutant un programme, celui-ci s’arrête

• L’ordinateur aﬃche à l’écran la liste des expressions qui peuvent être :

• Une aﬀecta)on est une instruc)on dans laquelle le

• Important : Le résultat de l’expression E doit être du

• La syntaxe de l’aﬀecta)on est la suivante :

– Une constante du même type : v ç 12,5

– Une variable du même type : v ç u

– Un ensemble de valeurs ou de variables du même type reliées entre elles par

Remarque : Une aﬀectaBon n’est pas une équaBon mathémaBque

– A+1 ç 3 n’est pas une aﬀecta)on possible et ne vaut pas Aç 2.

•  Structure d’un Algorithme

•  No)on de variable et de constante

•  Les types complexes

•  Un programme : une suite d’instruc)ons exécutées dans un ordre donné par le

•  Un programme : le traitement automa)que (par une machine) d’une tâche

•  Un programme est écrit dans un langage de programma)on « compris » par

•  Le seul langage que comprend l’ordinateur est le binaire.

•  Algorithme : Ensemble de règles opératoires dont l'applica)on permet de

•  Un algorithme doit être écrit indépendamment du langage de programma)on

•  Pour un même problème il peut exister plusieurs façon de formuler la solu)on,

–  Correct => implémente correctement les tâches pour

–  Complet => prend en considéra)on tous les cas

–  Eﬃcace => Exécute sa tâche eﬃcacement, c’est-à-dire

•  Deux façons de représenter un algorithme :

–  Représenta)on graphique => Organigramme

–  Représenta)on textuelle => Pseudo-code

•  Un organigramme décrit une vue

•  C’est ceke représenta)on qui est la plus u)lisée

–  Nom : un algorithme doit porter un nom qui généralement décrit la

–  Début et Fin : Délimiter le commencement et la ﬁn de l’algorithme par

–  Noms signiﬁcaBfs : il faut donner des noms signiﬁca)fs aux variables

–  Commentaires : écrits dans la langue du programmeur, ils sont u)les

•  Pendant l’exécu)on d’un programme informa)que, chaque

•  Déclarer une variable consiste à donner :

–  Nom de la variable : appelé aussi « iden)ﬁcateur ».

–  Type de la variable : désigne la plage de valeurs que peut

–  Une valeur : n’est pas obligatoire et peut se faire à

3.  Ne commence pas par un chiﬀre. Exemple : 1Informa)que : incorrect.

4.  Éviter les caractère de ponctua)on et les espaces. Exemples : Informa)que

6.  De longueur raisonnable.

7.  Doit être signiﬁca)f et décrit la données manipulée.

•  Spéciﬁer le type d’une variable au moment de sa

•  La déclara)on des variables n’est pas représentée sur

•  En pseudo-code : Variables liste d’iden-ﬁcateurs : Type

•  Une constante doit toujours recevoir une valeur dès sa déclara)on.

•  En pseudo-code : Constante iden-ﬁcateur ç valeur : type

•  Par conven)on, les noms de constantes sont écrits en majuscules

•  Les instruc)ons d’un algorithme sont habituellement

•  L’ordre d’exécu)on des instruc)ons est important. Changer

–  Une instruc)on d’entrée ou de sor)e

–  Une structure itéra)ve

•  Il existe deux types d’instruc)ons d’entrées/

•  L’ordinateur enregistre la valeur entrée au clavier à l’emplacement

•  Il faut toujours déclarer une variable avant de lire sa valeur.

•  A l’exécu)on : En exécutant un programme, celui-ci s’arrête

•  L’ordinateur aﬃche à l’écran la liste des expressions qui peuvent être :

•  Une aﬀecta)on est une instruc)on dans laquelle le

•  Important : Le résultat de l’expression E doit être du

•  La syntaxe de l’aﬀecta)on est la suivante :

–  Une constante du même type : v ç 12,5

–  Une variable du même type : v ç u

–  Un ensemble de valeurs ou de variables du même type reliées entre elles par

–  A+1 ç 3 n’est pas une aﬀecta)on possible et ne vaut pas Aç 2.

–  ArithméBque : retourne un résultat numérique

–  Logique : retourne un résultat logique (vrai ou faux)

–  De comparaison : retourne un résultat logique (vrai

•  Pour forcer les priorités, des parenthèses sont

•  Si les opérateurs ont la même priorité,

•  Une condi-on est une expression qui retourne une

•  Remarque : Dans le jargon informa)que, les structures

–  Simple : Généralement une opéra)on de comparaison

–  Composée : Une suite d’expressions de comparaison

2.  Alterna)ve complète

3.  Alterna)ve imbriquée

-  La séquence d’instruc)ons n’est exécutée que si la Instruc)ons

-  Si Condi-on retourne un résultat FAUX, aucune Fin

-  Condi-on est une expression booléenne qui doit VRAI

-  Si Condi-on retourne un résultat FAUX, la « séquence Fin

•  Les tests imbriqués peuvent parfois être

•  Ceci est possible lorsque les tests imbriqués

•  Il existe 3 types de structures répé))ves (boucles) :

•  Le choix d’un type de boucle dépend des données dont ont

-  Compteur : une variable qui sert à compter le nombre

•  Pour qu’il n’y ait pas de dysfonc)onnement de la

•  Exemple 2 : Écrire un autre algorithme qui

•  Exemple : Aﬃcher le triangle ci-dessous en u)lisant

•  Types complexes : désignent des types de données dont la

•  Supposons qu’il fallait aﬃcher les 20 nombres introduits après avoir

•  Un tableau est une variable qui sert à stocker en

•  Les données sont stockées de façon « con)güe »,