M106- Automatiser les tâches d’administration (Partie I)

Algorithmique (ver : 1.4)

I : Introduction
La DEMARCHE ALGORITHMIQUE est une composante essentielle de l’activité mathématique.

• L’usage et le développement des algorithmes font partie de notre quotidien ; ils sont notamment à la base
du fonctionnement des automates, des calculatrices et des ordinateurs.
• De nombreux algorithmes sont connus depuis l’Antiquité, dont l’algorithme d’Euclide, qui permet de calculer
le PGCD de deux nombres entiers non nuls.

Ce cours se donne pour objectif la maîtrise des COMPÉTENCES suivantes :

• Comprendre et examiner un algorithme préexistant, son fonctionnement ou son but ;

• Modifier un algorithme pour obtenir un résultat précis ;
• Analyser une situation : identifier les données d’entrée et de sortie, le traitement, les instructions... ;
• Créer une solution algorithmique à un problème donné : comment écrire un algorithme en « langage
courant » en respectant un code, identifier les boucles, les tests, les opérations d’écriture, d’affichage... ;

En résumé, on peut considérer dans une PREMIERE APPROCHE qu’un algorithme décrit un processus de résolution
d’un problème défini, rédigé dans un langage formalisé et produisant un résultat en un temps fini.

Le mot ALGORITHME tire son nom du mathématicien persan Al-Khuwarizmi (né vers 780 - mort vers 850) qui a écrit
en langue arabe le plus ancien traité d’algèbre baptisé « Abrégé de calcul par la complétion et la simplification »
dans lequel il décrivait des procédés de calcul à suivre étape par étape pour résoudre des problèmes ramenés à des
équations.

II : Qu’est-ce qu’un algorithme ?

1) Définition
Algorithme : procédure de calcul bien définie qui prend en entrée une valeur, ou un ensemble de valeurs, et qui
donne en sortie une valeur, ou un ensemble de valeurs.

Un algorithme est donc une séquence d’étapes de calcul qui transforment l’entrée en sortie.

L’on peut aussi considérer un algorithme comme un outil permettant de résoudre un problème de calcul bien
spécifié.

L’énoncé du problème spécifie, en termes généraux, la relation désirée entre l’entrée et la sortie.

L’algorithme décrit une procédure de calcul spécifique permettant d’obtenir cette relation entrée/sortie.

Un ALGORITHME est une suite finie d’instructions élémentaires (règles), qui s’appliquent dans un ordre déterminé à
un nombre fini de données pour fournir un résultat.

Supposons, par exemple, qu’il faille trier une suite de nombres dans l’ordre croissant.

Problème : tri ; données : ensemble des nombres ; résultat ou sortie : les nombres en ordre.

Tout algorithme est donc caractérisé par :

• Un ensemble d’instructions à exécuter

Algorithmique Page 1 sur 23

 • Un ordre d’exécution de ces différentes actions, déterminé par la logique d’enchaînement et conditionné
par les structures mises en œuvre
• Un début et une fin

2) Conception d’un algorithme

La conception d’un algorithme passe par plusieurs étapes :

• Analyse : définition du problème en termes de séquences d’opérations de calcul de stockage de données,

etc. ;
• Conception : définition précise des données, des traitements et de leur séquencement ;
• Implantation : traduction et réalisation de l’algorithme dans un langage précis ;
• Test : Vérification du bon fonctionnement de l’algorithme.

3) Langage et règles d’écriture d’un algorithme

Un algorithme peut être écrit en utilisant un langage de description d’algorithme (LDA). Ce langage utilise un
ensemble de mots clés et de structures permettant de décrire de manière complète et claire l’ensemble des
opérations à exécuter sur des données pour obtenir des résultats. Un tel langage présente un réel avantage, celui de
pouvoir être transcrit dans un langage de programmation structuré et lisible. Il ne faut donc pas confondre
algorithme et programme.

4) Organigramme
En algorithmique, on peut aussi utiliser un
Organigramme, c’est-à-dire représenter
graphiquement l’algorithme à l’aide de symboles
normalisés.

Exemples :
• Symbole de traitement (symbole général)
(rectangle ou parallélogramme)
• Symbole de test (symbole de branchement)
(losange)
• Symbole auxiliaire (symbole de début, fin ou
interruption d’algorithme) (Ellipse)

Algorithmique Page 2 sur 23

III : Phases d’un algorithme
1) La préparation du traitement
Cette phase consiste à repérer les données, c’est-à-dire les éléments nécessaires, voire indispensables, à la
résolution. Elles peuvent être de nature :
• Numérique (des nombres entiers ou réels)
• Textuelle (des caractères, c’est-à-dire une lettre, un chiffre ou un symbole, ou des chaînes de caractères,
c’est-à-dire une suite de caractères formés de lettre(s), de chiffre(s) et/ou de symbole(s))
• Booléenne (de type logique, à deux valeurs possibles « vrai » ou « faux »)
• Graphique (des points)

Autrement dit, après avoir précisé en en-tête le nom de l’algorithme afin d’en identifier le but, l’algorithme se
compose des déclarations de constantes, de variables et de structures, qui correspondent à une liste exhaustive
des ressources utilisées et manipulées dans le corps de l’algorithme.

Remarque : L’entrée des données (saisie de caractères ou de nombres sur le clavier, lecture de la position du
pointeur de la souris, lecture d’un fichier contenant ces nombres ou caractères …) s’intègre dans cette phase de
préparation du traitement.

2) Le traitement de données
Cette phase, qui correspond au corps de l’algorithme, consiste à spécifier toutes les étapes des instructions à
donner pour une exécution automatique.
Il existe plusieurs types d’algorithmes, déterminés selon le type d’exécution des instructions :
• Si les instructions s’exécutent en séquence, on parle d’algorithme séquentiel ;
• Si les opérations s’exécutent sur plusieurs processeurs en parallèle, on parle d’algorithme parallèle ;
• Si les instructions s’exécutent sur un réseau de processeurs, on parle d’algorithme réparti ou distribué.

3) La sortie de résultats
Les résultats obtenus, graphiques ou sonores, peuvent être :
• Affichés sur l’écran
• Conservés en mémoire jusqu’à la prochaine exécution
• Imprimés sur papier
• Conservés dans un fichier
• Perdus !

IV : Constantes et variables
Les constantes et les variables sont des éléments fondamentaux, indispensables au bon déroulement d’un
algorithme, caractérisés par un identificateur, une valeur et un type.

1) Définitions
▪ Une VARIABLE est une donnée (emplacement) stockée dans la mémoire de la calculatrice ou de
l’ordinateur. Elle est repérée par un identificateur (nom de la variable constitué de lettres et/ou de chiffres,
sans espace) et contient une valeur dont le type (nature de la variable) peut être un entier, un réel, un
booléen, un caractère, une chaîne de caractères…
▪ Une CONSTANTE, comme une variable, peut représenter un chiffre, un nombre, un caractère, une chaîne de
caractères, un booléen.

Toutefois, contrairement à une variable dont la valeur peut être modifiée au cours de l’exécution de
l’algorithme, la valeur d’une constante ne varie pas.

Algorithmique Page 3 sur 23

Remarque :

▪ Ne pas confondre la variable et son identificateur. En effet, la variable possède une valeur (son contenu) et
une adresse (emplacement dans la mémoire où est stockée la valeur). L’identificateur n’est que le nom de la
variable, c’est-à-dire un constituant de cette variable.
▪ Le type d’une variable détermine l’ensemble des valeurs qu’elle peut prendre et les opérations réalisables
qu’elle peut subir.
▪ L’utilisation d’une variable doit être précédée de sa déclaration. La syntaxe pour déclarer une variable est la
suivante :
Variables :
Identificateur de la variable_1 : type de la variable_1
Identificateur de la variable_2 : type de la variable_2
…
Identificateur de la variable_N : type de la variable_N
▪ Si la valeur de la variable peut changer au cours du déroulement de l’algorithme, en revanche son type est
figé lors de déclaration.

2) Conventions de nommage

Le nom d’un algorithme, d’une variable ou d’une constante doit respecter les règles suivantes :

• Commencer par une lettre ;

• Ne comporter ni caractère spécial (comme l’espace) ni ponctuation ;
• Ne pas être un mot du langage algorithmique (comme « algorithme », « début », « fin », « variable », «
non », « ou », « et », « si », « sinon », « pour » …)

V : Opérandes et opérateurs
1) Définitions
❖ Un OPERATEUR est un outil qui permet d’agir sur une variable ou d’effectuer des calculs.
❖ Un OPERANDE est une donnée utilisée par un opérateur.

Exemple : Dans «7-x », « - » désigne l’opérateur ; « 7 » et « x » sont les opérandes.

2) Types d’opérateurs

Il existe plusieurs types d’opérateurs :

▪ Les opérateurs arithmétiques qui permettent d’effectuer des opérations arithmétiques entre opérandes
numériques :
✓ Opérateurs élémentaires : « + », « - », « × », « ÷ », « / » (division entière)
✓ Changement de signe : « - »
✓ Elévation à la puissance : « ^ »
✓ Reste d’une division entière : « modulo » (ou « mod »)
▪ Les opérateurs de comparaison (« = », « ≠ », « < », « > », « ≤ » et « ≥ ») qui permettent de comparer deux
opérandes et produisent une valeur booléenne, en s’appuyant sur des relations d’ordre :
✓ Ordre naturel pour les entiers et les réels
✓ Ordre lexicographique ASCII pour les chaînes de caractère
▪ Les opérateurs logiques qui combinent des opérandes booléens pour former des expressions logiques plus
complexes :
✓ Opérateur unaire : « non » (négation)
✓ Opérateurs binaires : « et » (conjonction), « ou » (disjonction), « ou_exclusif »
✓ L’opérateur de concaténation qui permet de créer une chaîne de caractères à partir de deux chaînes
de caractère en les mettant bout à bout.

Algorithmique Page 4 sur 23

 ✓ L’opérateur d’affectation, représenté par le symbole « ← », qui confère une valeur à une variable ou
à une constante.

a ←7 (affectation de la valeur7 à la variable a (ou à la constante) a)

Remarque : Les opérateurs dépendent du type de la constante ou de la variable :

✓ Opérateurs sur les entiers et les réels : addition, soustraction, multiplication, division, division entière,
puissance, comparaisons, modulo (reste d’une division entière)
✓ Opérateurs sur les booléens : comparaisons, négation, conjonction, disjonction
✓ Opérateurs sur les caractères : comparaisons
✓ Opérateurs sur les chaînes de caractères : comparaisons, concaténation

3) Priorité des opérateurs

A chaque opérateur est associée une priorité. Lors de l’évaluation d’une expression, la priorité de chaque opérateur
permet de définir l’ordre d’exécution des différentes opérations. Aussi, pour lever toute ambiguïté ou pour modifier
l’ordre d’exécution, on peut utiliser des parenthèses.

▪ Ordre de priorité décroissante des opérateurs arithmétiques et de concaténation :

✓ « ^ » (élévation à la puissance)
✓ « - » (changement de signe)
✓ « × », « ÷ » et « / »
✓ « modulo »
✓ « + » et « - »
✓ « + » (concaténation)
▪ Ordre de priorité décroissante des opérateurs logiques :
✓ « non »
✓ « et »
✓ « ou »
✓ « ou_exclusif »

Remarques :

▪ La question de l’ordre de priorité des opérateurs de comparaison ne se pose pas.

▪ Les opérations entre parenthèses sont prioritaires.

VI : Instructions de base
1) Définitions :
▪ L’instruction d’AFFECTATION permet d’attribuer une valeur à une variable. Cette instruction est notée «
identificateur prend valeur ».
Comme il a été vu précédemment, on peut aussi noter : « identificateur ← valeur ».
▪ L’ENTREE ou la lecture de données correspond à l’opération qui permet de saisir des valeurs pour qu’elles
soient utilisées par le programme. Cette instruction est notée « saisir identificateur » ou « lire identificateur ».
▪ La SORTIE ou l’écriture des données permet l’affichage des valeurs des variables après traitement.
Cette instruction est notée « afficher identificateur ».

Remarques :

✓ L’affectation d’une valeur à une variable peut être assimilée au rangement d’un objet dans un tiroir, sur la
façade duquel figure l’identificateur, et qui ne peut contenir qu’un objet à la fois.
✓ En sortie, on peut également afficher un message suivi d’une expression ; l’instruction est alors notée «
afficher (message, expression) ».

Algorithmique Page 5 sur 23

Exemple 1 (numérique) : Proposons un algorithme qui permet de calculer le prix toutes taxes comprises d’un article
après l’application d’une TVA à 19,6 % sur le prix hors taxes.

Algorithme Calcul_Prix_TTC (nom de l’algorithme)

Constantes
TVA: réel (ici, seule la variable est déclarée TVA ; son type est réel car le nombre 19,6 % n’est pas entier ; remarque :
cette constante peut aussi être intégrée dans les variables)

Variables
prixHT, prixTTC : réels (déclaration des variables pour lesquelles il reste préférable de donner un identificateur
explicite ; ici prixHT désigne le prix hors taxe et prixTTC le prix toutes taxes comprises)

Début
prend TVA prend 0,196 ; (on affecte la valeur 0,196, soit 19,6%, à la variable TVA; on peut également noter
cette affectation TVA←0,196)
afficher (« Renseigner le prix hors taxes de l’article. ») ; (affichage de la phrase entre guillemets)
saisir (prixHT) ; (lecture de la valeur de la variable prixHT )
prixTTC prend (prixHT+prixHT*TVA); (calcul du prix TTC avec l’opérateur × prioritaire devant l’opérateur + )

afficher (« Après application de la TVA, le prix de l’article devient », prixTTC, « toutes taxes comprises. »)
(sortie du résultat qui proposera l’affichage de la 1ère locution entre guillemets, puis le prix hors taxes qui
avait été saisi par l’utilisateur, puis la 2 locution entre guillemets, et enfin le prix toutes taxes comprises qui a
été calculé dans le corps de l’algorithme)
Fin

2) Exercices sur la construction d'un Algorithme

Exercice 1 :
Ecrire un algorithme qui affiche le résultat de l’addition, la soustraction, la multiplication et la division de
deux nombres entiers A et B.

Exercice 2 :
Soit un nombre entier à multiplier par son suivant.
1. Ecrire l'algorithme correspondant.
2. Dessiner l'organigramme

Exercice 3 :
Quelle seront les valeurs des variables A et B après l’exécution de l'algorithme suivant ?

Algorithme Algo_1
Var A,B : entier
Début
A←1;
B←A+1;
A←3;
FIN

Exercice 4 :
Quelle seront les valeurs des variables A, B et C après l’exécution de l'algorithme suivant ?

Algorithme Algo_1.2
Début
Algorithmique Page 6 sur 23
A←7;
B←10;
C←A+B;
A←3;
C←B-A;
Fin

Exercices 5 :
Ecrire un Algorithme "Permut" permettant d'échanger les valeurs de deux variables entières
(permutation).

Exercice 6 :
Ecrire un Algorithme permettant de lire une variable et de calculer et afficher son carrée.
3) Solution des exercices
Exercice 1 :
Algorithme sous_add_mul_div
Var add , mul , sous , div , A , B : entier ;
Début
Ecrire ("entrer deux variables");
Lire (A,B);
add←A+B;
mul←AxB;
sous←A-B;
div←A/B; * / donne la division entière de A et B
Ecrire("Le résultat de la multiplication est", mul);
Ecrire("Le résultat de l'addition est", add);
Ecrire("Le résultat de la soustraction est", sous);
Ecrire("Le résultat de la division est", div);

Exercice 2 :
Algorithme mul_svt
Var X
Début
Ecrire ("saisir un nombre");
Lire X ;
X←X x(X+1)
Ecrire(X);
Fin

Exercice 3 :
A=3;
B=2;

Exercice 4 :

A=3;
B=10;
C=7
Algorithmique Page 7 sur 23
Exercice 5 :
Algorithme Permut
Var A,B,C: entier
Début
C←A; *On stocke la valeur de A dans une variable intermédiaire C , car après la
première permutation on perd la valeur de A.
A←B;
B←C .
Fin

Exercice 6 :
Algorithme Carré
Var val ,C : entier;
Lire Val ;
Début
Ecrire("entrer une valeur entière");
C←val x val ;
Ecrire(C);
Fin ;

VII : Structures de contrôle

Le traitement de données est parfois conditionné et se réalise de manière spécifique. On parle alors de STRUCTURES
DE CONTROLE. Ces structures algorithmiques peuvent être organisées suivant quatre familles principales :

✓ Les structures linéaires

✓ Les structures répétitives
✓ Les structures alternatives
✓ Les structures de choix

1) Définitions :

▪ Une STRUCTURE LINEAIRE (ou STRUCTURE SEQUENTIELLE) se caractérise par une suite de traitements à
exécuter successivement, dans l’ordre énoncé.

Une CONDITION est une expression logique booléenne, prenant la valeur « vrai » ou « faux » (c’est-à-dire « oui »
ou « non »).

▪ Une STRUCTURE ALTERNATIVE (ou STRUCTURE CONDITIONNELLE) n’offre que deux issues possibles à la
poursuite de l’algorithme, qui s’excluent mutuellement. Selon qu’une condition est vraie ou fausse, on
effectue un traitement ou un autre. On parle de traitements conditionnels. Une structure alternative est
donc une structure de test.
▪ Une STRUCTURE REPETITIVE (ou STRUCTURE ITERATIVE) répète l’exécution d’un traitement, dans un ordre
précis, un nombre déterminé ou indéterminé de fois. Une structure itérative est aussi appelée boucle.
▪ Une STRUCTURE DE CHOIX permet, en fonction de plusieurs conditions de type booléen, d’exécuter des
traitements différents selon les valeurs que peut prendre une même variable.

Algorithmique Page 8 sur 23

 2) Structures linéaires

On note très simplement les structures linéaires, comme une suite de traitements à exécuter dans l’ordre où ils
sont énoncés :
Faire traitement 1 ;
Faire traitement 2 ;
…;
Faire traitement N ;

3) Structures alternatives

La résolution de certains problèmes nécessite parfois la mise en place d’un test pour effectuer une tâche :

▪ Si le test est positif, on effectue un certain traitement ;

▪ Sinon, c’est-à-dire si le test est négatif, on effectue un autre traitement.

En algorithmique, on traduit cette structure alternative à l’aide d’INSTRUCTIONS CONDITIONNELLES.

a) STRUCTURE ALTERNATIVE COMPLETE

Si condition
Alors traitement 1 ; (instructions à effectuer si la condition est vérifiée)
Sinon
traitement 2 ; (instructions à effectuer si la condition n’est pas vérifiée)
FinSi

Exemple 1 (numérique) : Proposons un algorithme qui compare deux nombres.

L’utilisateur doit saisir deux nombres (variables a et b).
Si la valeur de la variable « a » est plus petite que la valeur de la variable « b », alors la variable « m » est affecté de
la valeur de la variable « b ».
Sinon, c’est-à-dire si la valeur de la variable « a » est plus grande que la valeur de la variable « b », alors « m » prend
la valeur de la variable « a ».
Le résultat retourné est la valeur de la variable « m », qui correspond au plus grand des deux nombres choisis
initialement par l’utilisateur.

Remarque : Il existe des conditions simples et des conditions complexes :

❖ Une condition simple peut correspondre à un test d’égalité (par exemple : A = B ) ou d’inégalité (par
exemple : A ≤ B ) ;
❖ Une condition complexe est une combinaison logique de conditions simples (par exemple : A = B et B < C ).

b) STRUCTURE ALTERNATIVE REDUITE

La structure proposée précédemment est qualifiée de « complète » mais, selon le cas, il se peut que, si la condition
n’est pas vérifiée, il n’y ait pas à effectuer de traitement 2. On écrira ainsi la structure alternative « réduite ».

Si condition

Alors traitement (instructions à effectuer si la condition est vérifiée)

FinSi (la condition s’achève sans qu’on ait eu à effectuer de traitement 2 lorsque la condition n’a pas été vérifiée ;
l’algorithme passe alors à l’instruction suivante)

Algorithmique Page 9 sur 23

Exemple (fonction) : Ecrivons un algorithme qui calcule la racine d’un nombre, si elle existe.
Rappel : La fonction racine carrée est définie sur ℝ

• Lorsque le nombre saisi est supérieur ou égal à 0 :

• Lorsque le nombre saisi est strictement négatif :

c) STRUCTURES ALTERNATIVES IMBRIQUEES

Plusieurs structures alternatives peuvent être imbriquées, si bien que dans un traitement peut (peuvent) figurer une
ou plusieurs structure(s) alternative(s).

Pour une meilleure lisibilité de l’algorithme, on utilise l’INDENTATION, qui consiste à écrire les instructions sur des
lignes différentes en procédant à des décalages.

Remarque : Il s’avère parfois nécessaire d’exécuter plusieurs fois de suite le même traitement, c’est-à-dire la même
série d’instructions. Dans ce cas, il convient de faire appel aux structures répétitives.

4) Les structures de choix

La structure de choix permet, en fonction de plusieurs conditions de type booléen, d’effectuer des traitements
spécifiques.

Exemple (numérique) : Proposons un algorithme qui choisit de manière aléatoire un nombre entier compris entre 1
et 6 et précise si ce nombre est pair ou impair, premier ou pas.

Rappel :
Un nombre entier est premier si, et seulement si, il a pour uniques diviseurs 1 et lui-même. Les nombres 2, 3, 5 et 7
sont les seuls nombres premiers inférieurs à 10.
Remarque : 2 est le seul nombre premier pair.

Algorithmique Page 10 sur 23

 5) Les structures répétitives (boucles)

Toutes les structures itératives répètent l’exécution de traitement(s). Deux cas sont cependant à envisager, selon
que :
• Le nombre de répétitions est connu à l’avance : c’est le cas des boucles itératives
• Le nombre de répétitions n’est pas connu ou est variable : c’est le cas des boucles conditionnelles

a) La structure POUR … DE … A …, FAIRE

Cette structure est une BOUCLE ITERATIVE ; elle consiste à répéter un certain traitement un nombre de fois fixé à
l’avance. En algorithmique, on traduit cette structure itérative à l’aide des instructions :

Pour i De 1 Jusqu’à N (on répète un nombre connu de fois le même traitement ; ici, de 1 à, donc fois)

Faire traitement 1 (instructions à effectuer)

FinPour

Remarques :

La variable i est un compteur, dont la valeur augmente automatiquement de 1 à chaque tour. Cette variable permet
en définitive de contrôler le nombre entier de tours. Cette variable est en d’autres termes une variable de contrôle
d’itération, caractérisée par sa valeur initiale, sa valeur finale et son pas de variation.

La sortie de la boucle s’effectue lorsque le nombre souhaité d’itérations est atteint, c’est-à-dire lorsque i prend la
valeur N.

Exemple 1 (fonction) : Proposons un algorithme qui calcule le carré de tous les entiers compris entre 1 et 50.

Remarque : A chaque tour de boucle, on affiche la locution « Le nombre » suivie de la valeur du nombre nb, suivie de
la locution « a pour cube », suivie de la valeur du cube du nombre, à savoir la valeur de la variable cube.

Exemple 2 (numérique) : Ecrivons un algorithme permettant de calculer la somme des entiers de 1 à N, le nombre N
étant renseigné par l’utilisateur.

Remarque : A chaque tour de boucle, la somme est affectée de la somme et du nombre.

b) La structure TANT QUE …, FAIRE

Parfois, pour réaliser une tâche, on doit effectuer plusieurs fois les mêmes instructions, sans que le nombre de fois
soit déterminé à l’avance. On utilise alors une BOUCLE CONDITIONNELLE. Dans cette structure, le même traitement
est effectué tant qu’une condition reste valide ; la boucle s’arrête quand celle-ci n’est plus remplie. Cette structure
répétitive est ainsi formulée :

Tant que condition (on répète un nombre inconnu de fois le même traitement, autant de fois que la condition est
vérifiée)
Faire traitement (instructions à effectuer)
FinTant

Remarques :
• Le nombre de répétitions dépendra de la condition.
• Si la condition n’est pas vérifiée au début, alors le traitement 1 ne sera pas exécuté du tout.
• Si la condition est vérifiée au début et si la condition n’est pas susceptible d’être modifiée lors du traitement
1, alors le traitement 1 sera indéfiniment exécuté et l’utilisateur sera contraint d’arrêter le programme. Dans

Algorithmique Page 11 sur 23

 ce cas, il s’agit d’une erreur majeure car un programme ne doit pas boucler indéfiniment mais au contraire
s’arrêter automatiquement une fois que la condition cesse d’être vérifiée.

Exemple 1 (fonction) : Proposons un algorithme qui permet d’afficher tous les nombres entiers naturels dont le cube
est inférieur à 500.
Exemple 2 (numérique) : Ecrivons un algorithme permettant de déterminer le PGCD de deux nombres entiers.
Rappel : En arithmétique, le plus grand commun diviseur (PGCD) de deux nombres entiers naturels est le plus grand
entier naturel qui divise simultanément ces deux entiers.

c) La structure REPETER … JUSQU’A …

Une variante de structure répétitive avec BOUCLE CONDITIONNELLE consiste à répéter un traitement jusqu’à ce
qu’une certaine condition soit vérifiée. On la traduit par l’instruction :

Répète (on répète un nombre inconnu de fois le même traitement, autant de fois que la condition n’est pas
vérifiée)
FAIRE traitement (instructions à effectuer)
Jusqu’à condition

Remarque : Dans ce type d’instruction, le test est effectué à la fin de la boucle, si bien que le traitement est
exécuté au moins une fois, que la condition soit ou non vérifiée au début.

Algorithmique Page 12 sur 23

XII : Les structures de données statiques
1) Tableaux à une dimension

Imaginons que dans un programme, nous ayons besoin simultanément de 25 valeurs (par exemple, des notes pour
calculer une moyenne). La solution consiste à déclarer 25 variables réelles, appelées par exemple n1,n2,n3,…,n25 et la
variable moyenne réelle.
moyenne = (n1+n2+n3+…+n25) / 25

Un ensemble de valeurs portant ainsi le même nom de variable et repérées par un nombre, s’appelle un tableau,
et le nombre qui sert à repérer chaque valeur s’appelle un indice.

Un tableau de taille n est une structure très simple constituée de n emplacements consécutifs en mémoire. Il est
donc possible d'accéder à un élément d'un tableau en temps constant pourvu que l'on connaisse sa position (ou
indice). Un tableau est donc une structure très simple et très efficace.

Dans notre exemple, nous créerons donc un tableau appelé Note[]. Et chaque note individuelle sera désignée par :
Note[i] (l’élément qui se trouve à la position i).
Pour déclarer un tableau il faut préciser le nombre et le type de valeurs qu’il contiendra.
Tableau Note[25] : réels

Cette déclaration réserve l’emplacement de 25 éléments de type réels. Chaque élément est repéré par son indice
(position de l’élément dans le tableau). Dans la plupart des langages de programmation la première position porte le
numéro 0. Dans notre exemple, les indices vont de 0 à 24. Le premier élément du tableau sera désigné par Note[0],
le deuxième par Note[1], le dernier par Note[24]. L’utilisation de Note[25] déclenchera une erreur.

On peut créer des tableaux contenant des variables de tous types, mais on ne peut pas faire un mixage de types
différents de valeurs au sein d’un même tableau.

L’énorme avantage des tableaux, c’est qu’on va pouvoir les traiter en faisant des boucles.

Exemple
Voici un programme qui comporte la déclaration d’un tableau de 25 réels (les notes d’une classe), on commence par
effectuer la saisie des notes, et ensuite on calcul la moyenne des 25 notes et on affiche la moyenne :

Variables tableau Note[25], i, somme : entier

moyenne : réel
début
/* saisir les notes */
pour i allant de 0 à 24 faire
ecrire("entrer une note :")
lire(Note[i])
finpour
/* effectuer la moyenne des notes */
somme ←0
pour i allant de 0 à 24 faire
somme ← somme + Note[i]
finPour
moyenne = somme / 25
/* affichage de la moyenne */
ecrire ("la moyenne des notes est :",moyenne)
fin

Algorithmique Page 13 sur 23

 2) Les tableaux dynamiques

Il arrive fréquemment que l’on ne connaisse pas à l’avance le nombre d’éléments que devra comporter un tableau.
Bien sûr, une solution consisterait à déclarer un tableau gigantesque (10 000 éléments) pour être sûr que "ça
rentre". Mais d’une part, on n’en sera jamais parfaitement sûr (si le nombre n des éléments du tableau dépasse 10
000, ça provoquera une erreur), d’autre part, en raison de l’immensité de la place mémoire réservée (la plupart du
temps non utilisée), c’est un gâchis qui affectera la taille de notre algorithme, ainsi que sa rapidité.

Pour résoudre ce problème, on a la possibilité de déclarer le tableau sans préciser au départ son nombre d’éléments.

Ce n’est que dans un second temps, au cours du programme, que l’on va fixer ce nombre via une instruction
d’allocation : Allocation(nom,nombre,type), Dans laquelle il faut préciser le nom du tableau, le nombre d’éléments
et le type des éléments à allouer. Notez que tant qu’on n’a pas précisé le nombre d’éléments d’un tableau, d’une
manière ou d’une autre, ce tableau est inutilisable. Il ne faut pas oublier de libérer le tableau à la fin de son
utilisation avec l’instruction : libère(nom).

Exemple : on veut faire saisir des notes pour un calcul de moyenne, mais on ne sait pas combien il y aura de notes à
saisir. L’algorithme sera :

Variables tableau Note[], moyenne, somme : réels

i, n : entiers
début
écrire("entrer le nombre de notes à saisir : ")
lire(n)
/* allouer n nombres de types réels */
allocation(Notes,n,réels)
/* saisir les notes */
écrire("entrer les ",n," notes :")
pour i allant de 0 à n-1 faire

lire(Note[i])
finpour
/* effectuer la moyenne des notes */
somme ← 0
pour i allant de 0 à n-1 faire
somme ← somme + Note[i]
finPour
moyenne = somme / n
/* affichage de la moyenne */
écrire("la moyenne des ",n," notes est :",moyenne)
/* libérer le tableau Notes */
libère(Notes)
fin

3) Tableaux à deux dimensions

Pour représenter par exemple les matrices dans un ordinateur, un tableau ne suffit pas, puisque chaque ligne de
la matrice est en effet un tableau, donc une matrice n×k peut par exemple être représenter par n tableaux de k
éléments chacun. Mais cette représentation sera difficile à gérer, surtout si on veut implémenter un algorithme
qui effectue la multiplication ou l’addition de deux matrices. L’informatique nous offre la possibilité de déclarer
des tableaux dans lesquels les valeurs ne sont pas repérées par un indice seule, mais par deux indices. C’est la
solution à notre problème de représentation de matrice.

Algorithmique Page 14 sur 23

 Un tel tableau se déclare ainsi :
tableau matrice[10][12] : entier

Cette déclaration signifie : réserver un espace de mémoire pour 10 x 12 entiers, et quand j’aurai besoin de l’une
de ces valeurs, je les repèrerai par deux indices.
matrice[i][j] est l’élément de la matrice qui se trouve à l’intersection de la ligne i et la colonne j.
matrice[2][3] ← 5

Cette instruction signifie : mettre à l’emplacement qui se trouve à l’intersection de la deuxième ligne avec la
troisième colonne la valeur 5.
Dans la mémoire l’ordinateur représente un tableau matrice[10][12] par un seul tableau avec la taille 10×10.

4) Initialisation de matrice :

Pour initialiser une matrice on peut utiliser par exemple les instructions suivantes :
T1[3][3] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
T2[3][3] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

Ces instructions initialisent quatre tableaux de la manière suivantes :

lire(n)
/* lecture de la matrice A */
pour i allant de 1 à n faire
écrire("donner les éléments de la ",i," ligne:")
pour j allant de 1 à n faire
lire(A[i][j])
finpour
fipour
/* lecture de la matrice B */
pour i allant de 1 à n faire
écrire("donner les éléments de la ",i," ligne:")
pour j allant de 1 à n faire
lire(B[i][j])
finpour
fipour
/* la somme de C = A + B */
pour i allant de 1 à n faire
pour j allant de 1 à n faire
C[i][j] ← A[i][j]+B[i][j]
finpour
fipour
/* affichage de la matrice de C */
pour i allant de 1 à n faire
pour j allant de 1 à n faire
écrire(C[i][j]," ")
finpour
écrire("\n") /* retour à la ligne */
finpour
fin

Algorithmique Page 15 sur 23

XIII : Applications
1) Les algorithmes de recherche dans un tableau
Problème : recherche d’un élément dans un tableau.
a) Recherche séquentielle

Analyse :
• Parcours séquentiel du tableau
• Arrêt lorsque la valeur est trouvée
• Retour l’indice correspondant
• La valeur n’est pas trouvée
• Retour d’une valeur spéciale

Conception :
Un programme qui demande la taille du tableau T, les éléments du tableau T, la valeur de x (la valeur cherchée), le
programme donne la première position de x dans le tableau T, si x est dans le tableau T et donne la valeur -1 si x
n’est pas dans le tableau T.

variables n,i : entier

tableau T : réel
x : réel
début
écrire("donner la taille de T :")
lire(n)
écrire("donner les ",n," éléments de T :")
pour i allant de 0 jusqu’à n-1 faire
lire(T[i])
finpour
écrire("donner la valeur de x :")
lire(x)
i←0
Tant que ( i < n et T[i] != x) faire
i←i+1
fintantque
si (i<n) alors retourne(i)
sinon retourne(-1)
fin

b) Recherche dichotomique

On se place dans le cas où le tableau est ordonné et les éléments du tableau sont deux à deux distincts.

Analyse :
x : élément recherché,
T : tableau ordonné, sans duplication,
n : la taille du tableau (le nombre d’éléments du tableau)
mil : indice du milieu du tableau,
si x = T[mil] alors retourne mil
sinon
si x < T[mil] alors
recherche dans la 1ère moitié du tableau (T[d … mil-1])
sinon recherche dans la 2ème moitié du tableau (T[mil+1 … f])
finsi

Algorithmique Page 16 sur 23

finsi
écrire(" l’élément x n’est pas dans T ")

Conception :

variables n, i, d, f, mil : entier

tableau T : réel
x : réel
début
écrire("donner la taille de T :")
lire(n)
écrire("donner les ",n," éléments de T :")
pour i allant de 0 jusqu’à n-1 faire
lire(T[i])
finpour
écrire("donner la valeur de x :")
lire(x)
début
d←0
f←n–1
Tantque (d<=f)
mil ← (d + f)/2
si (x = T[mil])
écrire(" l’élément x est à la position ",mil)
sinon si (x<T[mil]) f ← mil-1
sinon d ← mil + 1
finsi
finsi
fintantque
écrire(" l’élément x n’est pas dans T ")
fin

2) LES STRUCTURES

Imaginons que l’on veuille afficher les notes d’une classe d’élèves par ordre croissant avec les noms et prénoms de
chaque élève. On va donc utiliser trois tableaux (pour stocker les noms, les prénoms et les notes). Lorsque l’on va
trier le tableau des notes il faut aussi modifier l’ordre les tableaux qui contiennent les noms et prénoms. Mais cela
multiplie le risque d’erreur. Il serait donc intéressant d’utiliser ce qu’on appelle les structures.
Les structures contrairement aux tableaux servent à rassembler au sein d’une seule entité un ensemble fini
d’éléments de type éventuellement différents. C’est le deuxième type complexe disponible en algorithmique.
A la différence des tableaux, il n’existe pas par défaut de type structure c'est-à-dire qu’on ne peut pas déclarer une
variable de type structure. Ce qu’on peut faire c’est de construire toujours un nouveau type basé sur une structure
et après on déclare des variables sur ce nouveau type.
La syntaxe de construction d’un type basé sur une structure est :
TYPE NomDuType = STRUCTURE
attribut1 : Type
attribut2 : Type
...
attributn : Type
FIN STRUCTURE

Algorithmique Page 17 sur 23

Le type d’un attribut peut être :

✓ Un type simple
✓ Un type complexe :
- Un tableau
- Un type basé sur une structure

Exemple :

TYPE Etudiant = STRUCTURE

nom : chaîne
prenom : chaîne
note : Réel
FIN STRUCTURE
Dans cet exemple on a construit un type Etudiant basé sur une structure. Cette structure a trois attributs (on dit aussi champ) :
nom, prenom et note.
TYPE Date = STRUCTURE
jour : Entier
mois : Entier
annee : Entier
FIN STRUCTURE
Dans ce deuxième exemple, on a construit un type Date basé sur une structure. Cette structure a aussi trois attributs : jour, mois
et annee.
Après on peut déclarer des variables basées sur ce type. Par exemple :
Variable Etud : Etudiant
Donc Etud est une variable de type Etudiant.
Il est possible de déclarer un tableau d’éléments de ce type Etudiant par exemple. On pourra écrire donc :
Tableau Etud (20) : Etudiant
Etud (1) représente le premier étudiant.

Maintenant, pour accéder aux attributs d’une variable dont le type est basé sur une structure on suffixe le nom de la variable
d’un point « . » suivi du nom de l’attribut. Par exemple, dans notre cas pour affecter le nom "Dinar" à notre premier étudiant, on
utilisera le code suivant :
Etud (1).nom = « Dinar »

3) LES FONCTIONS ET PROCEDURES

En programmation, donc en algorithmique, il est possible de décomposer le programme qui résout un problème en
des sous-programmes qui résolvent des sous parties du problème initial. Ceci permettra d’améliorer la conception
du programme et ainsi sa lisibilité.
L’utilisation des sous-programmes s’avère utile aussi dans le cas où on constate qu’une suite d’actions se répète
plusieurs fois.
Il existe deux types de sous-programmes les fonctions et les procédures. Un sous- programme est obligatoirement
caractérisé par un nom (un identifiant) unique.
Le nom d’un sous-programme comme le nom d’une variable doit :

• Contenir que des lettres et des chiffres

• Commencer obligatoirement par une lettre

Le programme qui utilise un sous- programme est appelé programme appelant. Un sous-programme peut être
invoqué n'importe où dans le programme appelant en faisant référence à son nom.
Un programme ainsi doit suivre la structure suivante :

• Définition des constantes

• Définition des types
• Déclaration des variables
• Définition des sous- programmes

Algorithmique Page 18 sur 23

DEBUT
Instructions du programme principal
FIN

a) Les fonctions

Une fonction est un sous-programme qui retourne un seul résultat. Pour définir une fonction on utilise la
syntaxe suivante :
FONCTION nom_fonction (Argument1 : Type , Argument2 : Type ,….) : Type
Déclarations
DEBUT
Instructions de la fonction
nom_fonction ← Valeur renvoyée
FIN
On constate que la déclaration d’une fonction revient à lui préciser un nom, un type ainsi qu’une liste
d’arguments.
Un argument (appelé paramètre formel) d’un sous- programme est une variable locale particulière
qui est associée à une variable ou constante du programme appelant. Puisque qu’un argument est une
variable locale, il admet un type.
Lorsque le programme appelant appelle le sous-programme il doit indiquer la variable ou la constante de même
type, qui est associée au paramètre.
Par exemple, le sous-programme sqr permet de calculer la racine carrée d’un réel. Ce sous-programme admet un
seul paramètre de type réel positif.
Le programme qui utilise sqr doit donner le réel positif dont il veut calculer la racine carrée, cela peut être :
- une variable, par exemple a
- une constante, par exemple 5.25
Les arguments d’une fonction sont en nombre fixe (>=0).
Une fonction possède un seul type, qui est le type de la valeur retournée qui est affecté au nom de la fonction.
Une fois la fonction définie, il est possible (en fonction des besoins) à tout endroit du programme appelant de faire
appel à elle en utilisant simplement son nom suivi des arguments entre parenthèses.
Les parenthèses sont toujours présentes même lorsqu’il n’y a pas de paramètre.
Les arguments spécifiés lors de l’appel de la fonction doivent être en même nombre que dans la déclaration de la
fonction et des types prévus. Dans le programme appelant ces arguments sont appelés paramètres effectifs.
La valeur ainsi renvoyée par la fonction peut être utilisée dans n’importante quelle expression compatible avec son type.
Exemple :
FONCTION Calcul (x : Réel , y : Réel , z : Réel) : Réel
Variable a : Entier
DEBUT
a←3
Calcul ← (x + y + z) * a
FIN
Ça c’est un exemple de déclaration de fonction. Cette fonction appelée « Calcul » est de type réel et elle admet trois arguments
de type réel.
Maintenant voici un exemple de programme complet :
FONCTION Calcul (x : Réel , y : Réel , z : Réel) : Réel
Variable a : Entier
DEBUT
a←3
Calcul ← (x + y + z) * a
FIN
Variables i , j , k , b : Réels
DEBUT
Lire i
Lire j
Algorithmique Page 19 sur 23
Lire k
b ← Calcul (i , j , k) + 2
Ecrire b
FIN
Dans ce programme on fait appel à une fonction. Sa valeur est utilisée dans une expression.

a) Les variables locales et globales

La portée d’une variable est l’ensemble des sous- programmes où cette variable est connue c'est-à-dire que les instructions de
ces sous-programmes peuvent utiliser cette variable.
Une variable définie au niveau du programme principal (problème appelant) est appelée variable globale. Sa portée est totale :
tout sous-programme du programme principal peut utiliser cette variable.
Cependant, une variable définie au sein d’un sous-programme est appelée variable locale. La portée d’une variable locale est
uniquement le sous-programme qui la déclare.
Remarque :
Lorsque le nom d’une variable locale est identique à une variable globale, la variable globale est localement masquée. Dans ce
sous-programme la variable globale devient inaccessible.

Exemple
Soit le programme suivant :
Fonction Surface (a : Réel) : Réel
Variables valeur , resultat : Réels
DEBUT
valeur ← 3.14
resulat ← valeur * a
Surface ← resultat
FIN
Variable rayon : Réel
DEBUT
Ecrire « Entrez le rayon du cercle : »
Lire rayon
Ecrire « La surface de cette cercle est : » , Surface (rayon)
FIN
Les variables valeur et resultat déclarées dans la fonction Surface sont locales.
Considérons presque le même programme sauf que la variable valeur est déclarée maintenant dans le programme appelant.
Fonction Surface (a : Réel) : Réel
Variables resultat : Réels DEBUT
resulat ← valeur * a
Surface ← resultat
FIN
Variable valeur , rayon : Réel
DEBUT
valeur ← 3.14
Ecrire « Entrez le rayon du cercle : »
Lire rayon
Ecrire « La surface de cette cercle est : » , Surface (rayon)
FIN
Dans ce deuxième programme seule la variable resultat est locale. Tandis que la variable valeur est devenue globale. On peut
par conséquent accéder à sa valeur dans la fonction Surface.

b) Le passage de paramètres
Il existe deux types d’association (que l’on nomme passage de paramètre) entre le(s) paramètre(s) du sous-programme
(fonction ou procédure) et variable(s) du programme appelant :
- Passage par valeur
- Passage par adresse

Algorithmique Page 20 sur 23

Dans le cas où l’on choisit pour un paramètre effectif un passage par valeur, la valeur de ce paramètre effectif ne change pas
même si lors de l’appel du sous-programme la valeur du paramètre formel correspondant change. On peut dire que dans ce cas
le paramètre effectif et le paramètre formel ont font deux variables différentes qui ont seulement la même valeur. C’est le type
de passage par défaut. Dans le cas où l’on choisit pour un paramètre effectif un passage par adresse, la valeur de ce paramètre
effectif change si lors de l’appel du sous-programme la valeur du paramètre formel correspondant change.
On peut dire que dans ce cas le paramètre effectif et le paramètre formel ont font deux variables qui ont le même adresse (par
conséquent valeur). Pour préciser qu’il s’agit d’un passage par adresse, il faut soulignés les paramètres concernés lors de la
définition du sous-programme.

Exemple
Considérons l’algorithme suivant :

Fonction Calcul (a : Réel) : Réel

DEBUT
Calcul ← a * 2
a←a–1
FIN
Variable x : Réel
DEBUT
x←3
Ecrire Calcul (x)
Ecrire x
FIN

b) Les procédures

Les procédures sont des sous- programmes qui ne retournent aucun résultat. Elles admettent comme les fonctions des
paramètres.
On déclare une procédure de la façon suivante :
PROCEDURE nom_procedure (Argument1 : Type , Argument2 : Type ,….)
Déclarations
DEBUT
Instructions de la procédure
FIN
Et on appelle une procédure comme une fonction, en indiquant son nom suivi des paramètres entre parenthèses.

Exercice
1. Ecrire une procédure qui reçoit la longueur et la largeur d’une surface et qui affiche la valeur de la surface. Donnez à cette
procédure le nom « Surface ».
2. Ecrire une procédure qui permet d’échanger les valeurs de deux variables. Appelez cette procédure « Echanger ».
3. On dispose d’une phrase dont les mots sont séparés par des point virgules. Ecrivez une procédure qui permet de remplacer
les points virgules par des espaces. On suppose qu’on dispose des fonctions suivantes :

- Longueur : permet de calculer la longueur d’une chaîne de caractères.

Utilisation : Longueur (chaîne)
- Extraire : permet d’extraire une partie (ou la totalité) d’une chaîne.
Utilisation : Extraire (chaîne , position_debut, longueur)
Paramètre : chaîne de laquelle on fait l’extraction position_debut la position à partir de laquelle va commencer l’extraction
longueur désigne la longueur de la chaîne qui va être extraite.

Solutions
1. Le programme qui définit la procédure « Surface » est :
PROCEDURE Surface (longueur : Réel , largeur : Réel)
Variable s : Réel
DEBUT
s ← longueur * largeur
Ecrire « La surface obtenu est : » , s
FIN

Algorithmique Page 21 sur 23

Table des matières
I : Introduction .................................................................................................................................................................. 1
II : Qu’est-ce qu’un algorithme ? ..................................................................................................................................... 1
1) Définition .................................................................................................................................................................. 1
2) Conception d’un algorithme ..................................................................................................................................... 2
3) Langage et règles d’écriture d’un algorithme ........................................................................................................... 2
4) Organigramme .......................................................................................................................................................... 2
III : Phases d’un algorithme.............................................................................................................................................. 3
1) La préparation du traitement ................................................................................................................................... 3
2) Le traitement de données......................................................................................................................................... 3
3) La sortie de résultats................................................................................................................................................. 3
IV : Constantes et variables.............................................................................................................................................. 3
1) Définitions ............................................................................................................................................................. 3
2) Conventions de nommage .................................................................................................................................... 4
V : Opérandes et opérateurs ............................................................................................................................................ 4
1) Définitions ............................................................................................................................................................. 4
2) Types d’opérateurs ............................................................................................................................................... 4
3) Priorité des opérateurs ......................................................................................................................................... 5
VI : Instructions de base ................................................................................................................................................... 5
1) Définitions : ........................................................................................................................................................... 5
2) Exercices sur la construction d'un Algorithme...................................................................................................... 6
3) Solution des exercices ........................................................................................................................................... 7
VII : Structures de contrôle .............................................................................................................................................. 8
1) Définitions : ........................................................................................................................................................... 8
2) Structures linéaires ............................................................................................................................................... 9
3) Structures alternatives .......................................................................................................................................... 9
a) STRUCTURE ALTERNATIVE COMPLETE .............................................................................................................. 9
b) STRUCTURE ALTERNATIVE REDUITE ................................................................................................................. 9
c) STRUCTURES ALTERNATIVES IMBRIQUEES ..................................................................................................... 10
4) Les structures de choix........................................................................................................................................ 10
5) Les structures répétitives (boucles) .................................................................................................................... 11
a) La structure POUR … DE … A …, FAIRE ............................................................................................................ 11
b) La structure TANT QUE …, FAIRE..................................................................................................................... 11
c) La structure REPETER … JUSQU’A … ................................................................................................................ 12
XII : Les structures de données statiques ...................................................................................................................... 13
1) Tableaux à une dimension .................................................................................................................................. 13
2) Les tableaux dynamiques .................................................................................................................................... 14
3) Tableaux à deux dimensions ............................................................................................................................... 14
4) Initialisation de matrice : .................................................................................................................................... 15
XIII : Applications ............................................................................................................................................................ 16

Algorithmique Page 22 sur 23

 1) Les algorithmes de recherche dans un tableau .................................................................................................. 16
a) Recherche séquentielle ................................................................................................................................... 16
b) Recherche dichotomique ................................................................................................................................ 16
2) LES STRUCTURES ................................................................................................................................................. 17
3) LES FONCTIONS ET PROCEDURES ....................................................................................................................... 18
a) Les fonctions ................................................................................................................................................... 19
a) Les variables locales et globales ..................................................................................................................... 20
b) Le passage de paramètres .............................................................................................................................. 20
b) Les procédures ................................................................................................................................................ 21

Algorithmique Page 23 sur 23