Séquence 5a

STRUCTURE ALGORITHMIQUE Niveau : Première

P a g e 1 | 18

✓ Analyser le traitement de l’information ✓ Traduire le comportement attendu ou observé

d’un objet

COURS

Table des matières

1. Introduction .......................................................................................................................................... 2

2. Définition .............................................................................................................................................. 2

3. La chaîne de développement d’un programme ....................................................................................... 4

4. Les principaux symboles d’un algorigramme .......................................................................................... 6

5. Le pseudo-code ..................................................................................................................................... 7

6. Les opérateurs utilisés ........................................................................................................................... 8

7. L’organisation d’un algorithme .............................................................................................................. 9

8. Les structures algorithmiques de base .................................................................................................. 11

9. Les sous-algorithmes ........................................................................................................................... 17

P a g e 2 | 18

1. Introduction

Avant toute programmation, il est recommandé d'avoir une visualisation du programme qu'on va faire. Pour cela,

il faut faire un algorigramme permettant de représenter graphiquement un algorithme.

Faire un algorigramme est important car la programmation est un processus itératif (on n’écrit pas un programme

d’un seul coup). Le programme est parfois modifié par d'autres développeurs que ceux qui l'ont conçu. Ce schéma

pourra expliquer la conception du programme aux nouveaux développeurs. Il pourra même éclairer le concepteur lui-

même sur des idées qu'il avait eues. La réalisation d'un algorigramme est tout aussi important que de mettre des

commentaires dans le programme.

Les modes de programmation visuelle, qui se développent de plus en plus ressemblent plus à des algorigrammes

qu'à un programme. Il est donc important de prendre connaissance dès que possible avec cette schématique.

2. Définition

2.1. Algorithmique ou Algorithmie

L’algorithmique est la science des algorithmes.

2.2. Algorithme

Un algorithme est une suite ordonnée d’instructions qui indique la démarche à suivre pour résoudre une série de

problèmes équivalents.

Un algorithme peut exprimer la structure logique d’un programme informatique et de ce fait est indépendant du

langage de programmation utilisé.

Exemple 1 : Mode d’emploi d’un télécopieur

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.

P a g e 3 | 18

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.

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 milliers !!!

P a g e 4 | 18

3. La chaîne de développement d’un programme

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

P a g e 5 | 18

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.

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.

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.

While (x > 0)

do

y := y + 1;

x := x - 1;

done;

loop : add R1, 1

sub R2, 1

jmpP loop

1000 : 000001100001000000000001

000011100010000000000001

011000000000000000001000

P a g e 6 | 18

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

Opération ou groupe d’opérations sur des données, instructions pour laquelle il n’existe aucune symbole normalisé

Renvoi

Symbole utilisé deux fois pour assurer la continuité lorsqu’une partie de ligne de liaison n’est pas représentée.

Sous-programme

Portion de programme considérée comme une simple opération

Début, fin, interruption

Début, fin ou interruption d’un algorigramme

Entrée-Sortie

Mise à disposition d’une information à traiter ou enregistrement d’une information à traitée

Commentaire

Symbole utilisé pour donner des indications sur les opérations effectuées

Symbole de test

Les différents symboles sont reliés entre eux par des lignes de liaisons

Branchement

Exploitation de conditions variables impliquant un 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.

P a g e 7 | 18

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 Branchement inconditionnel

SELON CAS…AUTREMENT Branchement conditionnel généralisé

TANT QUE…FAIRE… } Répétition conditionnelle

RÉPÉTER…JUSQU’À…

POUR…DE…À… Répétition contrôlée

// Commentaire

Exemple d’algorigramme et de pseudo-code équivalent :

Algorigramme Pseudo-code

P a g e 8 | 18

6. Les opérateurs utilisés

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. Opérateurs arithmétiques

Notation Signification

← Affectation

+ Addition

- Soustraction

* Multiplication

/ Division

DIV Division entière

MOD Modulo (reste de la division entière)

↑ Puissance

6.2. Opérateurs 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. Opérateurs de comparaison

Notation Signification

= Égal

≠ Différent

< Inférieur

> Supérieur

≤ Inférieur ou égal

≥ Supérieur ou égal

P a g e 9 | 18

7. L’organisation d’un algorithme

Un algorithme est organisé de la manière suivante :

Algorigramme Pseudo-code

DEBUT

Action 2

CONSTliste des constantes

VARliste des variables

Action 1

FIN

Action n

Nom de l’algorithmeDescription de l’algorithme

ALGORITHME nom de l’algorithme ; // description de l’algorithme CONST

liste des constantes ; VAR

liste des variables ;

DEBUT Action 1 ; Action 2 ; 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’entête Dans cette partie le concepteur donne un nom à l’algorithme, définit le traitement effectué et les données

auxquelles il se rapporte.

L’entête

La partie déclarative

La partie exécutive

(Corps de l’algorithme)

P a g e 10 | 18

7.2. La partie déclarative 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

Ce sont des « objets » constant dans tout

l’algorithme.

Déclaration :

Nom_constante = valeur ;

Exemple :

CONST Pi = 3,1416;

Les variables

Ce sont des « objets » dont la valeur peut changer

au cours de l’exécution de l’algorithme.

Déclaration :

Nom_variable : type ;

Exemple :

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 exécutive 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

P a g e 11 | 18

8. Les structures algorithmiques de base

8.1. La structure linéaire

La structure linéaire se caractérise par une suite d’actions à exécuter successivement dans l’ordre énoncé.

Algorigramme Pseudo-code

FAIRE

Opération 1 ;

Opération 2 ;

Opération 3 ;

|

|

Opération n ;

FIN FAIRE

Exemples de structure linéaire dans différents langages :

Flowcode LabVIEW

Arduino Python

a = 3

print(a)

a = a + 3

b = a - 2

print("a =", a, "et b =", b)

P a g e 12 | 18

8.2. La structure alternative « SI…ALORS…SINON »

La structure alternative n’offre que deux issues possibles à la poursuite de l’algorithme en s’excluant

mutuellement.

Algorigramme Pseudo-code

SI Condition ALORS

FAIRE Opération 1 ;

SINON

FAIRE Opération 2 ;

FIN SI

Exemples de structure « SI…ALORS…SINON » dans différents langages :

Flowcode LabVIEW

Arduino Python if (pinFiveInput < 500)

{

// action A

}

else

{

// action B

}

a = 5

if a > 0:

print("a est supérieur à 0.")

else:

print("a est inférieur ou égal à 0.")

P a g e 13 | 18

8.3. La structure de choix « SELON »

La Structure de choix permet, en fonction de plusieurs conditions de type booléen, d’effectuer des actions

différentes suivant les valeurs que peut prendre une même variable.

Algorigramme Pseudo-code

SELON cas

Cas 1 : FAIRE Opération 1 ;

Cas 2 : FAIRE Opération 2 ;

|

|

Cas n : FAIRE Opération n ;

AUTREMENT

FAIRE Opération n+1 ;

FIN SELON ;

Exemples de structure « SELON » dans différents langages :

Flowcode Arduino

switch (var) {

case 1:

//do something 1

break;

case 2:

//do something 2

break;

default:

// if nothing else

matches, do the default

// default is

optional

break;

}

LabVIEW Python

switch(n) {

case 0:

printf("0");

break;

case 1:

printf("1");

break;

default:

printf("other");

break;

}

P a g e 14 | 18

8.4. Les structures itératives

Les structures itératives répètent l’exécution d’une opération ou d’un traitement.

8.4.1. La structure « TANT QUE…FAIRE » Dans cette structure, on commence par tester la condition ; si elle est vraie, le traitement est exécuté.

L’ACTION PEUT NE JAMAIS ETRE EXECUTEE.

Algorigramme Pseudo-code

TANT QUE condition

FAIRE Opération ;

FIN TANT QUE

Exemples de structure « TANT QUE…FAIRE » dans différents langages :

Flowcode LabVIEW

Arduino Python var = 0;

while(var < 200){

// do something repetitive 200 times

var++;

}

i = 1

while i <= 5:

print(i)

i = i + 1

print('Fini !')

P a g e 15 | 18

8.4.2. La structure « RÉPÉTER…JUSQU’À » Dans cette structure, le traitement est exécuté une première fois puis sa répétition se poursuit jusqu’à ce que la

condition soit vérifiée.

L’ACTION EST EXECUTEE AU MOINS UNE FOIS

Algorigramme Pseudo-code

RÉPÉTER

Opération ;

JUSQU’À Condition ;

FIN RÉPÉTER

Exemples de structure « RÉPÉTER…JUSQU’À » dans différents langages :

Flowcode LabVIEW

Arduino Python do

{

delay(50); // wait for sensors

to stabilize

x = readSensors(); // check the

sensors

} while (x < 100);

P a g e 16 | 18

8.4.3. La structure « POUR…DE…À… » Dans cette structure, le traitement est exécuté un nombre limité de fois, défini au préalable.

Algorigramme Pseudo-code

POUR i DE i1 À i2

FAIRE Opération ;

FIN POUR

Exemples de structure « POUR…DE…A » dans différents langages :

Flowcode LabVIEW

Arduino Python for (int i=0; i <= 255; i++){

analogWrite(PWMpin, i);

delay(10);

}

S = 0

for i in range(1, 31): # pour i allant de 1 à 30

S = S + i

print(S)

P a g e 17 | 18

9. 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

DEBUT

MANGER

Mettre_la_table

Manger

Débarrasser_la_table

INFORMATIQUE

Programmer

Lire_un_super_tuto

MANGER

Mettre_la_table

Manger

Débarrasser_la_table

BRICOLAGE

Faire_un_tire_bottes

Couper_un_arbre_mort

MANGER

Mettre_la_table

Manger

Débarrasser_la_table

FIN

ALGORITHME

DEBUT

Sous algorithme Manger

INFORMATIQUE

Programmer

Lire_un_super_tuto

Sous algorithme Manger

BRICOLAGE

Faire_un_tire_bottes

Couper_un_arbre_mort

Sous algorithme Manger

FIN

SOUS ALGORITHME Manger

DEBUT

MANGER

Mettre_la_table

Manger

Débarrasser_la_table

FIN

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

Regardez les textes surlignés,

ce sont les mêmes. Le but d'un

sous algorithme serait d'écrire

ceci :

P a g e 18 | 18

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 algorithme à l’intérieur de sous-algorithme.

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