Algorithmique

Table des matières

1. Introduction...................................................................................................................................... 2
1.1. Qualités d’un algorithme ......................................................................................................................2
2. Exemples et Définitions ..................................................................................................................... 3
2.1. Exemple 1 : Mode d’emploi d’un télécopieur ......................................................................................3
2.2. Exemple 2 : Trouver son chemin ..........................................................................................................3
2.3. Algorigramme, logigramme ou organigramme ....................................................................................3
2.4. Pseudo-code ou LDA (Langage de Description des Algorithmes).........................................................3
2.5. Programmation .....................................................................................................................................3
2.6. Programme ...........................................................................................................................................3
2.7. Langage de programmation .................................................................................................................4
3. La chaîne de développement d’un programme .................................................................................. 4
3.1. Les niveaux de langage de programmation ..........................................................................................5
3.1.1. Langage algorithmique .........................................................................................................................5
3.1.2. Langage de haut niveau ........................................................................................................................5
3.1.3. Langage assembleur (bas niveau) .........................................................................................................5
3.1.4. Langage machine ..................................................................................................................................5
4. Les principaux symboles d’un algorigramme ...................................................................................... 6
5. Le pseudo-code ................................................................................................................................. 7
5.1. Exemple d’algorigramme et de pseudo-code équivalent :...................................................................7
5.2. L’indentation.........................................................................................................................................8
6. Les opérateurs utilisés ....................................................................................................................... 8
6.1. Opérateurs arithmétiques ....................................................................................................................8
6.2. Opérateurs logiques .............................................................................................................................9
6.3. Opérateurs de comparaison .................................................................................................................9
7. Structure d’un algorithme ............................................................................................................... 10
7.1. L’entête ...............................................................................................................................................10
7.2. La partie déclarative ...........................................................................................................................11
7.3. La partie exécutive..............................................................................................................................11
8. Les structures algorithmiques de base ............................................................................................. 12
9. Les sous-algorithmes ....................................................................................................................... 15

 Cours algorithmique v1.docx Page 1 / 18 Décembre 2020 v1

 1. INTRODUCTION
Alors qu’ils n’existaient pas il y a 50 ans, les ordinateurs ont aujourd’hui envahi notre environnement. Bien que très
puissant par la quantité d’informations qu’il peut engranger et le grand nombre d’opérations qu’il peut exécuter par
seconde, un ordinateur n'est qu'une machine capable d'exécuter automatiquement une série d'opérations simples
qu'on lui a demandé de faire.
Pour résoudre un problème à l'aide d'un ordinateur, il faut :
1. analyser ce problème: définir avec précision les résultats à obtenir, les informations dont on dispose, ...
2. déterminer les méthodes de résolution: il s'agit de déterminer la suite des opérations à effectuer pour
obtenir à partir des données la solution au problème posé. Cette suite d'opérations constitue un
algorithme. Parmi tous les algorithmes fournissant la solution, il faudra choisir le plus efficace.
3. formuler l'algorithme définitif: cette étape doit faciliter la résolution sur ordinateur par l'expression de
l'algorithme dans un formalisme adéquat (langage de description d'algorithme: LDA, organigramme, arbre
programmatique, ...).
4. traduire l'algorithme dans un langage de programmation adapté.
L’Encyclopédia Universalis donne la définition suivante de l’Algorithme :
« Un algorithme est une suite de règles à appliquer dans un ordre déterminé à un nombre fini de données pour
arriver, en un nombre fini d’étapes, à un certain résultat, et cela indépendamment des données. »
Le mot algorithme provient du nom d’un mathématicien persan : Al-Khwarizmi (vers 780 – vers 850). Pour aider
ses contemporains, ce sage a écrit un livre regroupant des méthodes claires, à suivre pas à pas, pour résoudre
des problèmes mathématiques.
Les algorithmes sont fondamentaux au sens où ils sont indépendants à la fois de l’ordinateur qui les exécutent et
des langages dans lequel ils sont traduits.

1.1.QUALITES D’UN ALGORITHME

Pour obtenir un bon programme il faut partir d’un bon algorithme qui doit posséder entre autres, les qualités
suivantes :
• Être clair, facile à comprendre par tous ceux qui le lisent.
• Être le plus général possible pour répondre au plus grand nombre de cas possibles.
• Être d’une utilisation aisée même par ceux qui ne l’ont pas écrit (Messages pour l’introduction des
données…)
• Être conçu de manière à limiter le nombre d’opérations à effectuer et la place occupée en mémoire.
Une des meilleures façons de rendre un algorithme clair et compréhensible est d’utiliser un langage de description
structuré n’utilisant qu’un petit nombre de structures indépendantes du langage de programmation utilisé.
 Cours algorithmique v1.docx Page 2 / 18 Décembre 2020 v1
 2. EXEMPLES ET DEFINITIONS
2.1.EXEMPLE 1 : MODE D’EMPLOI D’UN TELECOPIEUR
Extrait du mode d’emploi d’un télécopieur concernant l’envoi d’un document.

1. Insérez le document dans le chargeur automatique.

2. Composez le numéro de fax du destinataire à l’aide du pavé numérique.

3. Enfoncez la touche envoi pour lancer l’émission.

Ce mode d’emploi précise comment envoyer un fax. Il est composé d’une suite ordonnée d’instructions
(insérez…, composez…, enfoncez…) qui manipulent des données (document, chargeur automatique, numéro de fax,
pavé numérique, touche envoi) pour réaliser la tâche désirée (envoi d’un document).

Chacun a déjà été confronté à de tels documents pour faire fonctionner un appareil plus ou moins réticent et
donc, consciemment ou non, a déjà exécuté un algorithme.

2.2.EXEMPLE 2 : TROUVER SON CHEMIN

Extrait d’un dialogue entre un touriste égaré et un autochtone.

– Pourriez-vous m’indiquer le chemin de la gare, s’il vous plait ?

– Oui bien sûr : vous allez tout droit jusqu’au prochain carrefour, vous prenez à gauche au carrefour et ensuite
la troisième à droite, et vous verrez la gare juste en face de vous.

– Merci.

Dans ce dialogue, la réponse de l’autochtone est la description d’une suite ordonnée d’instructions (allez tout
droit, prenez à gauche, prenez la troisième à droite) qui manipulent des données (carrefour, rues) pour réaliser la
tâche désirée (aller à la gare). Ici encore, chacun a déjà été confronté à ce genre de situation et donc, consciemment
ou non, a déjà construit un algorithme dans sa tête (définir la suite d’instructions pour réaliser une tâche). Mais
quand on définit un algorithme, celui-ci ne doit contenir que des instructions compréhensibles par celui qui devra
l’exécuter (des humains dans les 2 exemples précédents).

2.3.ALGORIGRAMME, LOGIGRAMME OU ORGANIGRAMME

Un algorigramme est une représentation graphique normalisée (décrite dans la suite du cours) d’un algorithme.

2.4.PSEUDO-CODE OU LDA (LANGAGE DE DESCRIPTION DES ALGORITHMES)

Le pseudo-code est une écriture conventionnelle permettant de représenter un algorithme (décrite dans la
suite du cours) sous forme « textuelle ».

2.5.PROGRAMMATION
La programmation d’un processeur consiste à lui « expliquer » en détail ce qu’il doit faire, en sachant qu’il ne
« comprend » pas le langage humain, mais qu’il peut seulement effectuer un traitement automatique sur des
séquences de 0 et de 1.

2.6.PROGRAMME
Un programme n’est rien d’autre qu’une suite d’instructions, encodées en respectant de manière très stricte
un ensemble de conventions fixées à l’avance par un langage informatique. La machine décode alors ces
instructions en associant à chaque « mot » du langage informatique une action précise.

 Cours algorithmique v1.docx Page 3 / 18 Décembre 2020 v1

 2.7.LANGAGE DE PROGRAMMATION
Un langage de programmation est un langage informatique, permettant à un humain d’écrire un code source
qui sera analysé par un ordinateur.

La traduction de l’algorithme dans un langage de programmation particulier dépend du langage choisi et sa

mise en œuvre dépend également de la plateforme d’exécution (type d’ordinateur, de microcontrôleur…).

Quelques exemples de langages de programmation : C, Java, C++, C#, PHP, Visual Basic, Python, JavaScript,
MATLAB, Flowcode, LabVIEW, Arduino, Pascal… il y en existe des centaines !!!

3. LA CHAINE DE DEVELOPPEMENT D’UN PROGRAMME

Cette chaîne désigne l’ensemble des étapes nécessaires à la construction d’un fichier exécutable (binaire).

 Cours algorithmique v1.docx Page 4 / 18 Décembre 2020 v1

 3.1.LES NIVEAUX DE LANGAGE DE PROGRAMMATION
3.1.1. Langage algorithmique
Le programme en langage algorithmique est indépendant de la machine physique et du langage utilisé pour
écrire le fichier source. Il peut être réaliser à l’aide d’un algorigramme ou un pseudo-code (décrit par la suite)

3.1.2. Langage de haut niveau

Le programme en langage de haut niveau est indépendant de la structure interne de la machine physique. Il
peut être réalisé à l’aide d’un éditeur de texte ou d’un logiciel spécialisé.

Pour pouvoir être exécuté, un programme en langage de haut niveau doit être traduit vers son équivalent
machine, c’est le rôle du compilateur.

While (x > 0)
do
y := y + 1;
x := x - 1;
done;

3.1.3. Langage assembleur (bas niveau)

Le programme en langage assembleur est l’équivalent du langage machine. Chaque champ binaire de
l’instruction machine est remplacé par un mnémonique alphanumérique.

loop : add R1, 1

sub R2, 1
jmpP loop

3.1.4. Langage machine

Le programme en langage machine est écrit en binaire. Chaque processeur possède son propre jeu
d’instructions machine (chaîne binaire). Seul ces instructions sont exécutables par le processeur.

1000 : 000001100001000000000001
000011100010000000000001
011000000000000000001000

 Cours algorithmique v1.docx Page 5 / 18 Décembre 2020 v1

 4. LES PRINCIPAUX SYMBOLES D’UN ALGORIGRAMME
Les principaux symboles normalisés pour la représentation graphique d’un algorithme sont les suivants :

Symbole Désignation Symbole Désignation

Symboles de traitement Symboles auxiliaires

Symbole général Renvoi

Opération ou groupe Symbole utilisé deux fois
d’opérations sur des pour assurer la continuité
données, instructions pour lorsqu’une partie de ligne de
laquelle il n’existe aucune liaison n’est pas
symbole normalisé représentée.

Sous-programme Début, fin,

Portion de programme interruption
considérée comme une Début, fin ou interruption
simple opération d’un algorigramme

Entrée-Sortie Commentaire
Mise à disposition d’une
Symbole utilisé pour donner
information à traiter ou
des indications sur les
enregistrement d’une
opérations effectuées
information à traitée

Symbole de test

Branchement Les différents symboles sont

Exploitation de conditions reliés entre eux par des
variables impliquant un lignes de liaisons
choix parmi plusieurs

Sens conventionnel des liaisons

Le sens général des lignes de liaison doit être :
➢ De haut en bas

➢ De gauche à droite
Lorsque le sens général ne peut pas être respecté, des pointes de flèches à cheval sur la ligne indiquent le sens
utilisé.
Règles de construction
➢ Centrer l’algorigramme sur une feuille
➢ Respecter le sens conventionnel des liaisons
➢ Les lignes de liaison entre symboles ne doivent pas en principe se couper (utiliser un symbole de
renvoi)
➢ Une ligne de liaison doit toujours arriver sur le haut et au centre d’un symbole.
➢ Les commentaires sont à placer de préférence à droite, et les renvois de branchement à
gauche.

 Cours algorithmique v1.docx Page 6 / 18 Décembre 2020 v1

 5. LE PSEUDO-CODE
Le pseudo-code est une écriture conventionnelle permettant de représenter un algorithme sous forme textuel.
Ce mode de représentation consiste à exprimer en langage naturel, mais selon une disposition particulière et des
mots choisis, les différentes opérations constituant l’algorithme, conformément au code donné dans le tableau qui
suit :

Mots et symboles du pseudo-code Opérations réalisées

ALGORITHME Nomme l’algorithme
DEBUT Début de l’algorithme
FIN Fin de l’algorithme
FAIRE Exécution d’une opération
LIRE Acquisition ou chargement d’une donnée
ECRIRE Edition ou sauvegarde d’un résultat
AFFICHER Affiche sur l’écran
ALLER A Branchement inconditionnel
SI…ALORS…SINON…FIN SI Branchement conditionnel
SELON CAS…FAIRE …AUTREMENT…FIN SELON Branchement conditionnel généralisé
TANT QUE…FAIRE…FIN TANT QUE
Répétition conditionnelle
RÉPÉTER…JUSQU’À…
POUR…DE…À…FAIRE…FIN POUR Répétition contrôlée
// Commentaire

5.1.EXEMPLE D’ALGORIGRAMME ET DE PSEUDO-CODE EQUIVALENT :

Algorigramme Pseudo-code

 Cours algorithmique v1.docx Page 7 / 18 Décembre 2020 v1

 5.2.L’INDENTATION
Le pseudo-code de l’exemple précédent montre que les lignes de code ne sont pas alignées, cela s’appelle
l’indentation1.
L’écriture sera indentée afin de faire apparaître l’algorithme comme un réseau principal comportant une borne
d’entrée et une borne de sortie et chacune des structures qui le constitue comme un sous-réseau présentant aussi
une entrée et une sortie.
Règles :
• Le dernier sous réseau ouvert doit être le premier fermé
• Le nombre de fermetures doit être égal au nombre d’ouvertures
Le rang de la dernière paire de mots délimiteurs représente le degré de complexité de l’algorithme.

6. LES OPERATEURS UTILISES

Dans un algorigramme ou un pseudo-code différents opérateurs peuvent être utilisés.

Les opérateurs permettent d’élaborer une expression en vue d’effectuer un calcul ou une comparaison. L’usage
des parenthèses est vivement conseillé dans le cas d’expressions complexes.

6.1.OPERATEURS ARITHMETIQUES

Notation Signification
← Affectation
+ Addition
- Soustraction
* Multiplication
/ Division
DIV Division entière
MOD Modulo (reste de la division entière)
↑ Puissance

1
indentation : Tabulation du texte en insérant des espaces au début de chaque nouvelle structure afin de la mettre en
évidence.
 Cours algorithmique v1.docx Page 8 / 18 Décembre 2020 v1
 6.2.OPERATEURS LOGIQUES

Notation Signification

ET Fonction ET
OU Fonction OU
OUX Fonction OU exclusif
NON Fonction NON

NON ET Fonction NON ET

NON OU Fonction NON OU

6.3.OPERATEURS DE COMPARAISON

Notation Signification
= Égal à
≠ Différent de
< Inférieur à
> Supérieur à
≤ Inférieur ou égal à
≥ Supérieur ou égal à

 Cours algorithmique v1.docx Page 9 / 18 Décembre 2020 v1

 7. STRUCTURE D’UN ALGORITHME
Un algorithme est organisé de la manière suivante :

Algorigramme Pseudo-code

Nom de l’algorithme ALGORITHME nom de l’algorithme ;

Description de l’algorithme
L’entête // description de l’algorithme
DEBUT
CONST
liste des constantes ;
VAR
CONST liste des variables ;
liste des constantes
VAR La partie déclarative DEBUT
liste des variables
Action 1 ;
Action 2 ;

Action 1
Action n ;
FIN
La partie exécutive

Action 2 (Corps de l’algorithme)

Action n

FIN

On peut distinguer 3 parties bien distinctes :

• L’entête
• La partie déclarative
• La partie exécutive (le corps)

7.1.L’ENTETE
Dans cette partie le concepteur donne un nom à l’algorithme, définit le traitement effectué et les données
auxquelles il se rapporte.

 Cours algorithmique v1.docx Page 10 / 18 Décembre 2020 v1

 7.2.LA PARTIE DECLARATIVE
Dans cette partie, le concepteur décrit les différents « objets » que l’algorithme utilise. On y retrouve les
constantes et les variables.

Les constantes Les variables

Ce sont des « objets » constant dans tout Ce sont des « objets » dont la valeur peut changer
l’algorithme. au cours de l’exécution de l’algorithme.

Déclaration : Déclaration :

Nom_constante = valeur ; Nom_variable : type ;

Exemple : Exemple :

CONST Pi = 3,1416; VAR x, y : nombres réels ;

Les constantes et les variables sont définies dans la partie déclarative par deux caractéristiques essentielles, à
savoir :

➢ L’identificateur : c’est le nom de la variable ou de la constante. Il est composé de lettres et de chiffres.

➢ Le type : Il détermine la nature de la variable ou de la constante (entier, réel, booléen, chaîne de

caractères).

Les principaux types de variables sont les suivants :

Type Désignation Exemple

ENTIER Nombre entier 42
REEL Nombre flottant (à virgule) 0.154
BOOLEEN Énumération définissant les données vrai et faux vrai
CARACTERE Caractère ASCII sur un octet ‘a’
CHAINE Chaîne de caractère ‘lapin’
Une fois la variable crée, il est possible d’affecter une valeur ou le résultat d’un calcul à cette variable à l’aide du
symbole « ← »

L’affectation se fait en deux temps :

1) Évaluation de l’expression située à droite du symbole

2) Affectation du résultat à l’identificateur de variable

Exemple :

y←2*x+3

7.3.LA PARTIE EXECUTIVE

Dans cette partie, le concepteur écrit les actions décrivant l’algorithme. Elle est délimitée par les mots « DEBUT »
et « FIN ».

Ne surtout pas oublier de commenter son programme afin dans faciliter la relecture

 Cours algorithmique v1.docx Page 11 / 18 Décembre 2020 v1

 8. LES STRUCTURES ALGORITHMIQUES DE BASE

STRUCTURE LINEAIRE
Algorigramme Pseudo-code Arduino
FAIRE
Opération 1 ;
Opération 2 ;
La structure linéaire se
caractérise par une suite Opération 3 ; digitalWrite(13, HIGH) ;// ON
delay(1000); // wait for 1s
d’actions à exécuter | digitalWrite(13, LOW) ; // OFF
successivement dans delay(1000); // wait for 1s
l’ordre énoncé. |
Opération n ;
FIN FAIRE

STRUCTURE ALTERNATIVE « SI…ALORS…SINON »

Algorigramme Pseudo-code Arduino
STRUC

SI Condition ALORS if (pinFiveInput < 500)

La structure alternative {
n’offre que deux issues FAIRE Opération 1 ; // action A
}
possibles à la poursuite SINON else
de l’algorithme en {
s’excluant mutuellement. FAIRE Opération 2 ; // action B
FIN SI }

TURE LINEAIRE

 Cours algorithmique v1.docx Page 12 / 18 Octobre 2016 v0

 STRUCTURE DE CHOIX « SELON »
Algorigramme Pseudo-code Arduino
Algorigra

SELON cas
switch (var) {
Cas 1 : FAIRE Opération 1 ; case 1:
La Structure de choix //do something 1
permet, en fonction de Cas 2 : FAIRE Opération 2 ; break;
plusieurs conditions de | case 2:
//do something 2
type booléen, d’effectuer
| break;
des actions différentes default:
suivant les valeurs que Cas n : FAIRE Opération n ; // if nothing else matches, do
peut prendre une même the default
AUTREMENT // default is optional
variable.
FAIRE Opération n+1 ; break;
}
FIN SELON ;

mme
STRUCTURE ITERATIVE « TANT QUE…FAIRE »
Algorigramme Pseudo-code Arduino
Les structures
itératives répètent
l’exécution d’une
opération ou d’un
traitement. var = 0;
TANT QUE condition
while(var < 200){
Dans cette structure,
FAIRE Opération ; // do something repetitive 200 times
on commence par tester var++;
la condition ; si elle est FIN TANT QUE }
vraie, le traitement est
exécuté.

L’ACTION PEUT NE
JAMAIS ETRE EXECUTEE.

 Cours algorithmique v1.docx Page 13 / 18 Octobre 2016 v0

 STRUCTURE ITERATIVE « RÉPÉTER…JUSQU’À »
Algorigramme Pseudo-code Arduino

Dans cette structure,

le traitement est exécuté do
une première fois puis sa RÉPÉTER {
delay(50); // wait for
répétition se poursuit Opération ; sensors to stabilize
jusqu’à ce que la x = readSensors(); // check the
JUSQU’À Condition ;
condition soit vérifiée. sensors
FIN RÉPÉTER
L’ACTION EST EXECUTEE } while (x < 100);
AU MOINS UNE FOIS

STRUCTURE ITERATIVE « POUR…DE…À… »

Algorigramme Pseudo-code Arduino

Dans cette structure, le POUR i DE i1 À i2 for (int i=0; i <= 255; i++){
traitement est exécuté analogWrite(PWMpin, i);
FAIRE Opération ; delay(10);
un nombre limité de fois,
défini au préalable. FIN POUR }

 Cours algorithmique v1.docx Page 14 / 18 Octobre 2016 v0

 9. LES OPERATEURS UTILISES EN LANGUAGE ARDUINO
En langage Arduino (langage C/C++), les opérateurs présentent des différences. Elles sont résumées dans les
tableaux ci-dessous.

9.1.OPERATEURS ARITHMETIQUES
Notation Signification
= Affectation
+ Addition
- Soustraction
* Multiplication
/ Division
% Modulo (reste de la division entière)

9.2.OPERATEURS LOGIQUES
Notation Signification
&& Fonction ET
|| Fonction OU
! Fonction NON

9.3.OPERATEURS DE COMPARAISON
Notation Signification
== Égal à  Ne pas confondre avec l’affectation
!= Différent de
< Inférieur à
> Supérieur à
<= Inférieur ou égal à
>= Supérieur ou égal à

 Cours algorithmique v1.docx Page 15 / 18 Octobre 2016 v0

 10. LES SOUS-ALGORITHMES
Un algorithme, surtout s’il est long, a toutes les chances de devoir procéder aux mêmes traitements, ou à des
traitements similaires, à plusieurs endroits de son déroulement. Par exemple, la saisie d’une réponse par oui ou par
non (et le contrôle qu’elle implique), peuvent être répétés dix fois à des moments différents de la même application,
pour dix questions différentes.

La manière la plus évidente, mais aussi la moins habile, de programmer ce genre de choses, c'est bien entendu
de répéter le code correspondant autant de fois que nécessaire. Mais si par la suite, il y a une modification à
apporter au traitement, il faut l’effectuer partout où le traitement est.

Il faut donc opter pour une autre stratégie, qui consiste à utiliser un sous-algorithme (que l’on appelle aussi,
sous-programme, fonction, procédure ou routine).

C’est un sous-ensemble de l’algorithme principal. En fait, c'est un algorithme que nous représentons à part, un
bloc d'instructions que nous pouvons appeler quand nous le souhaitons, plusieurs fois même.

Imaginons l’exemple suivant :

ALGORITHME ALGORITHME
DEBUT DEBUT
MANGER Sous algorithme Manger
Mettre_la_table INFORMATIQUE
Manger Programmer
Débarrasser_la_table Lire_un_super_tuto
INFORMATIQUE Sous algorithme Manger
Regardez les textes surlignés,
Programmer BRICOLAGE
ce sont les mêmes. Le but d'un
Lire_un_super_tuto Faire_un_tire_bottes
sous algorithme serait d'écrire
MANGER Couper_un_arbre_mort
ceci :
Mettre_la_table Sous algorithme Manger
Manger FIN
Débarrasser_la_table
BRICOLAGE SOUS ALGORITHME Manger
Faire_un_tire_bottes DEBUT
Couper_un_arbre_mort MANGER
MANGER Mettre_la_table
Mettre_la_table Manger
Manger Débarrasser_la_table
Débarrasser_la_table FIN
FIN

Les lignes « Sous algorithme Manger » sont les appels, on appelle le sous-algorithme « Manger »

 Cours algorithmique v1.docx Page 16 / 18 Octobre 2016 v0

 Dans un algorigramme c’est la même chose, un sous algorithme a presque la même
structure que l’algorithme principal. La seule différence réside dans les blocs de début et de
fin du programme.

Quand dans l’algorithme principal on veut utiliser un sous algorithme on l’appelle à

l’aide de du bloc « Sous-programme » :

Il est possible d’avoir des sous algorithmes à l’intérieur de sous-algorithme.

Par exemple le sous algorithme « Manger » peut faire appel au sous algorithme « Mettre_La_Table »

 Cours algorithmique v1.docx Page 17 / 18 Novembre 2020 v0

 Arduino Programming Cheat Sheet

 Cours algorithmique v1.docx Page 18 / 18 Novembre 2020 v0