Informatique

Chapitre 3 : ALGORITHMIQUE ET PROGRAMMATION

Objectifs du chapitre
- Comprendre un algorithme, expliquer ce qu'il fait, le modifier pour obtenir un résultat différent
- Concevoir un algorithme après avoir analysé, spécifié, modélisé et décomposé un problème de manière rigoureuse

INTRODUCTION : ALGORITHME ET PROGRAMME

Notion d'algorithme
• Un algorithme est une procédure permettant de résoudre un problème, écrite de façon suffisamment détaillée pour
pouvoir être suivie sans posséder de compétence particulière.
Un exemple commun est par exemple la recherche d'un mot dans le dictionnaire.
On regarde d'abord la 1ère lettre du mot, et on la compare avec celle des mots de
la page où le dictionnaire est actuellement ouvert. Suivant la position relative des
deux lettres en question dans l'ordre alphabétique, on tourne alors les pages en
avant ou en arrière, jusqu'à ce que les 1ères lettres coïncident. Puis on reproduit la
même procédure avec la 2ème lettre du mot, puis la 3ème, et ainsi de suite…

De la même façon, une notice de

montage peut constituer un algorithme
pour monter un meuble sans savoir
comment son assemblage a été conçu, à condition que tous les outils
nécessaires soient fournis avec la notice.

• Une autre particularité d’un algorithme est qu’il permet en réalité de

résoudre une classe de problèmes similaires, et non pas un problème unique.
Ainsi, un algorithme d’addition permet de calculer la somme de n’importe
quels nombres décimaux, et non pas seulement la somme de deux nombres
fixés une fois pour toutes. Algorithme de tri par
sélection dans un tableau
Pour faire fonctionner un algorithme, il faut donc lui fournir des d onnées
précisant l’instance du problème qu’il devra traiter. En retour, l’algorithme
construira un résultat répondant à cette instance du problème.

Notion de programme
• Les algorithmes ont existé bien avant les ordinateurs, pour réaliser des tâches matérielles comme pour résoudre des
problèmes calculatoires. L’exécution d’un algorithme étant complètement déterminée par celui-ci, la difficulté que
posait leur utilisation à la main résidait dans le volume de calculs parfois nécessaires, et les inévitables erreurs humaines
introduites dans le procédé. Avec l’apparition des premiers ordinateurs, il devenait possible de faire exécuter un
algorithme de façon beaucoup plus rapide et beaucoup plus sûre.

• Il faut cependant traduire cet algorithme sous une forme non ambiguë et lisible par la machine.
Un programme est la traduction d’un algorithme dans un langage particulier, à la fois interprétable par la machine et
compréhensible par l’homme. Il est constitué d’un assemblage d’instructions, regroupées dans un fichier texte appelé
le code source du programme.

• L’exécution du programme commence à la première instruction et continue en exécutant d’autres instructions en

suivant des règles précises. Le parcours des instructions au cours de l’exécution est appelé le flot d'exécution .

CPGE TSI – Lycée P.-P. Riquet – St-Orens de Gameville -1-

 Informatique

I/ POUR UNE BONNE PROGRAMMATION

1/ Différentes étapes de la création d'un programme

• L'ingénieur en informatique suit un "cycle en V" pour le

développement d'un projet :
- étude préalable : le développement doit-il avoir lieu ?
- spécification : que doit faire le logiciel ? C'est le cahier des charges ;
- conception : décrire une solution du problème dans un pseudo-
langage, en raffinant successivement ;
- codage : traduire la conception détaillée dans le langage adapté à la
cible à programmer ;
- tests : exécuter le programme sur des jeux de tests. Un logiciel doit
être correct (il fait ce qu’il est censé faire / cahier des charges) et
algorithmique
robuste (il se comporte bien dans les cas non prévus). Cette phase
programmation permet aussi d'évaluer les temps de réponse.

• L’algorithmique intervient essentiellement dans la phase de conception pour préparer l’opération de codage.
La programmation intervient dans la phase de codage. Elle ne constitue pas en général une étape compliquée. Des
études ont montré que moins de 7% des erreurs de développement se produisent en phase de codage.

2/ Exemple du robot
• But : Écrire un algorithme qui permet à un robot de se déplacer de la salle de cours (position initiale du robot) jusqu’au
secrétariat. Le robot est seulement capable d’avancer d’une case (instruction AVANCER) et de pivoter de 90° vers la
droite (instruction PIVOTER).

• Le programme sera exécuté par le processeur du robot.

AVANCER et PIVOTER constituent des instructions.

Algorithme Guider_robot

Début

• Rq : ici, l'algorithme est aussi le programme.

• Evaluons la solution proposée :

- Est-ce que le processeur comprend le programme ?

- Est-ce qu’un lecteur humain comprend le programme

écrit (par où passe le robot ?)

- Est-il facile de faire évoluer le programme (par exemple,

si on change la configuration des lieux, ou le robot).

- Le chemin suivi est-il le plus court ? le plus rapide ?

CPGE TSI – Lycée P.-P. Riquet – St-Orens de Gameville -2-

 Informatique
Conclusion :
- En plus du programme, il est nécessaire de conserver des informations qui expliquent le programme, facilitent sa
compréhension et permettent ses évolutions.
- il faut adopter une méthode pour produire un "bon" algorithme : les raffinages successifs.

• On peut commencer par nommer les pièces : salle de cours, couloir, vestibule, secrétariat, escalier, bureau du chef,
cafétéria, salle de cours 2. L'algorithme R1 (raffinage de niveau 1) est alors :

Début

Fin

Les algorithmes R2 seront :

Les algorithmes R3 seront :

3/ Conclusion : la stratégie à appliquer pour une bonne programmation

- Le problème est décomposé en étapes de haut niveau, abstraites. Elles sont nécessaires pour comprendre la
solution finale et garder la trace de notre raisonnement, mais elles ne sont pas comprises par le processeur et doivent
donc lui être détaillées.
- On arrête de raffiner quand toutes les opérations identifiées sont des
instructions élémentaires.
- La décomposition produit un arbre des raffinages dont les feuilles
contiennent les instructions élémentaires. Le programme s’obtient :
- ou bien en mettant l’arbre à plat, les étapes non élémentaires étant
conservées sous forme de commentaire.
- ou bien en gardant une structure d'arbre, et en décomposant
chaque niveau en sous-programmes. On parle alors de
programmation structurée, ou modulaire.
- Il est impératif de commenter abondamment chaque partie.
Le développement d'un programme (version simplifiée)
• De la même manière :
- un rapport, un livre comporte un plan, souvent explicité par la table des matières ;
- pour construire un bâtiment, un architecte commence par dessiner les plans ;
- une recette de cuisine décrit les étapes élémentaires à suivre, à partir de données d'entrée (les ingrédients).

CPGE TSI – Lycée P.-P. Riquet – St-Orens de Gameville -3-

 Informatique
II/ LES ELEMENTS DE BASE DU PSEUDO-LANGAGE ALGORITHMIQUE : VARIABLES ET EXPRESSIONS

1/ Structure d'un algorithme

• Un algorithme (comme un programme) est Algorithme périmètre_cercle
# Déterminer le périmètre d’un cercle à partir de son rayon
composé de deux parties principales : # Attention : aucun contrôle sur la saisie du rayon ==> non robuste !

- La partie déclarations permet de déclarer les Constante

PI = 3.1415
données qui sont utilisées par le programme. Les Variables
données sont représentées par des constantes, ou rayon: Réel # le rayon du cercle lu au clavier
des variables d'un certain type. Les variables peuvent périmètre: Réel # le perimètre du cercle

être initialisées à leur valeur de départ. Début

# Saisir le rayon
Identificateur de la variable
Écrire("Rayon = ")
- La partie instructions constitue le programme Lire(rayon) Commentaire issu du raffinage
principal. Les instructions sont exécutées par Commentaire de justification
l’ordinateur pour traiter les données. # Calculer le périmètre
périmètre  2 * PI * rayon # par définition

• Le raffinage de niveau R1 de cet algorithme est : # Afficher le périmètre

Écrire("Le périmètre est : ", périmètre)
Fin

• Dès que l'algorithme devient complexe, les raffinages peuvent conduire à des sous-programmes. Ils constituent alors
une 3ème partie, et sont appelés par le programme principal :
#--------- Programme principal---------- SOUS-PGM_1(paramètres) SOUS-PGM_2(paramètres)
Début Début Début
Instruction Instruction Instruction
SOUS-PGM_1(paramètres1) SOUS-PGM_2(paramètres4) Instruction
Instruction Instruction …
… Fin Fin
SOUS-PGM_1(paramètres2)
SOUS-PGM_2(paramètres3)
Fin

2/ Les variables et leur type

• Les données d'entrée du programme doivent être précisées par le programmeur, car elles ne peuvent pas être
devinées par le programme. Elles proviennent de l’extérieur du programme et sont utilisées dans le programme.

Inversement, le programme effectue des opérations dont les résultats devront être affichés à l’écran, imprimés, stockés
dans des bases de données, etc. Ce sont des informations qui sortent du programme. On les appelle données de sortie.

Ex : Pour calculer le montant d’une facture dans un algorithme, le programmeur utilisera au moins ces trois variables :
– prix_unitaire, le prix unitaire de l’article ;
– quantité, la quantité d’articles commandés ;
– montant, le montant de la facture.

• Une variable est une zone dans la mémoire vive de l’ordinateur qui est utilisée pour conserver les données qui
seront manipulées par le programme.
Elle est caractérisée par 4 informations :

CPGE TSI – Lycée P.-P. Riquet – St-Orens de Gameville -4-

 Informatique
- Son nom : composé uniquement de lettres minuscules, majuscules, de chiffres et du caractère souligné (pas d'espace
!), il permet d’identifier la variable : on parle d’"identificateur". Ce nom doit être significatif, c'est-à-dire refléter le rôle
de la variable, mais ne pas être trop long.

- Son rôle : il est conseillé de l'indiquer en commentaire, s'il n'est pas évident.

- Son type : il est utilisé pour caractériser l’ensemble des valeurs qu’une variable peut prendre .
Par exemple, prix_unitaire représente le prix d’un article exprimé en euros.
On peut considèrer qu’il est représenté par un réel. Il ne peut alors prendre
prix_unitaire: Réel # prix unitaire d’un article (en €)
que ce type de valeurs. De la même manière, la quantité ne peut prendre quantité: Entier # quantité d’articles commandés
que des valeurs entières et le nom_article est une chaîne de caractères. On nom_article: Chaîne # nom de l’article
dira respectivement que le type de prix_unitaire est Réel, le type de
quantité est Entier et le type de nom_article est Chaîne.

Rq : En langage Python, les types simples sont les entiers (int), flottants (float), booléens (bool) et
chaînes de caractères (string).

Type entier : pour les nombres entiers positifs, nuls ou négatifs. Les limites varient selon le langage, ou la
machine où le programme est exécuté (ex : 32 bits  - 65535 à 65536). En Python, la seule limite est la capacité
mémoire de la machine !
Type réel : pour les nombres décimaux. Il faut utiliser le point comme caractère décimal et celui-ci doit toujours
être suivi et précédé d'un chiffre (ex : 6.53, -58.124, 1.0, …)
Type chaînes de caractères : pour les variables dont la valeur a plus d'un caractère. (ex : "bonjour").
Type booléen : pour les variables dont la valeur est logique (True / False en Python).

- Sa valeur : La variable contient une information qui peut varier au cours de l’exécution d’un programme.
C’est cette information que l’on appelle valeur de la variable. La valeur d’une variable doit correspondre au type de la
variable.

Ex : Déclaration des variables permettant de traiter l’état civil d’une personne.

 Concrètement, une variable est une représentation idéale d’une zone mémoire de l’ordinateur. Il s’agit donc d’un
endroit (une adresse) où l’on peut stocker une valeur, auquel on peut accéder et changer cette valeur. Le nom de la
variable est une étiquette "collée" sur cet emplacement mémoire.

3/ Expressions
 Une expression est "quelque chose" qui a une valeur. Une expression est donc :
- une constante (sa valeur ne change jamais tout au long du programme),
- une variable (sa valeur peut changer au fil du programme),
- toute combinaison d’expressions utilisant des opérateurs arithmétiques, logiques ou de comparaison.

Exemples d’expressions :
10.0 constante littérale
PI constante symbolique
rayon variable de type réel
CPGE TSI – Lycée P.-P. Riquet – St-Orens de Gameville -5-
 Informatique
2*rayon expression utilisant l’opérateur * appliqué sur 2 et rayon
2*PI*rayon expression mêlant opérateurs, constantes et variables
rayon >= 0 expression avec un opérateur de comparaison

 Attention, pour qu’une expression soit acceptable, il est nécessaire que les types des opérandes d’un opérateur
soient compatibles. Par exemple, faire l’addition d’un entier et d’un booléen n’a pas de sens. La règle de compatibilité
est la suivante : le type A est compatible avec le type B si et seulement si le passage d’un type A à un type B se fait sans
perte d’information. Par exemple, Entier est compatible avec Réel mais l’inverse est faux.

 Règle d’évaluation d’une expression : Une expression est évaluée en fonction de la priorité des opérateurs qui la
composent, en commençant par ceux de priorité plus forte. À priorité égale, les opérateurs sont évalués de gauche à
droite.

Voici les opérateurs rangés par priorité décroissante :

. (accès à un champ) la priorité la plus forte
+, -, Non (unaires)
** (exponentiation)
*, /, Div, Mod, Et (Div = division entière = // en Python ; Mod = reste de la division entière = % en Python)
+, -, Ou
<, >, <=, >=, == et != priorité la plus faible (!= veut dire "différent")
Il est toujours possible de mettre des parenthèses pour modifier les priorités.

III/ LES INSTRUCTIONS SIMPLES

 Une instruction est un ordre, donné au processeur, de modifier l'état d'une ou plusieurs variables du programme.

On sépare les instructions en deux grandes familles :

- d’une part les instructions simples qui manipulent directement l’état courant d'une variable : instructions d'entrée-
sortie, affectation d'une valeur à une variable ;
- d’autre part les instructions composées qui permettent d’assembler d’autres instructions et de modifier le flot
d’exécution en fonction de l’état courant des variables.

1/ Instructions d'entrée-sortie
 Le point de référence est le programme. Ainsi les informations d’entrée sont les informations extérieures au
programme et qui rentrent dans le programme (saisie clavier par exemple) ; les informations de sortie sont élaborées
par le programme et communiquées à l’extérieur (à l’écran par exemple).

 Instruction d'entrée en pseudo-langage :

Lire(var) # Lire sur le périphérique d’entrée une valeur et la ranger dans la variable var.
# Autre formulation : affecter la variable var avec une valeur lue au clavier.

Le paramètre var est nécessairement une variable. En effet, la valeur lue sur le périphérique d’entrée doit être rangée
dans var. L’évaluation de cette instruction se fait en deux temps :
- récupérer l’information sur le périphérique d’entrée (elle est convertie dans le type de la variable var) ;
- ranger cette information dans la variable var.

 Un algorigramme (ou organigramme) est la traduction graphique de l'algorithm e

CPGE TSI – Lycée P.-P. Riquet – St-Orens de Gameville -6-
 Informatique
L'instruction Lire(var) est inscrite dans un parallélogramme :

 Instruction de sortie en pseudo-langage :

Écrire(expr) # Communiquer (afficher, imprimer...) la valeur de l’expression expr au périphérique de sortie.

expr est une expression d'un type quelconque. L’évaluation se fait en deux temps :
- évaluer l’expression expr, c’est-à-dire calculer sa valeur ;
- afficher sur le périphérique de sortie la valeur de l’expression.

 Instruction de sortie Écrire(expr) dans un algorigramme : elle est inscrite dans un parallélogramme :

2/ Affectation
 L’affectation permet de modifier la valeur associée à une variable.

 L'affectation en pseudo-langage s'écrit :

var  expr

Le type de expr doit être compatible avec le type de var. L’évaluation de l’affectation se fait en deux temps :
- calculer la valeur de l’expression expr ;
- ranger cette valeur dans la variable var.

 L'affectation dans un algorigramme est inscrite dans un rectangle :

 Ex :
rayon
diamètre
périmètre

IV/ LES INSTRUCTIONS COMPOSEES : STRUCTURES DE CONTROLE DU FLOT D'EXECUTION

 L’exécution d’un programme est une séquence d’affectations qui font passer d’un état initial (où les valeurs des
variables sont indéterminées) à un état final considéré comme le résultat.
Les structures de contrôle décrivent comment les affectations s’enchaînent séquentiellement.
CPGE TSI – Lycée P.-P. Riquet – St-Orens de Gameville -7-
 Informatique
Elles définissent dont le "transfert du contrôle" après la fin de l’exécution d’une instruction.

 Les instructions composées sont au nombre de trois :
- la séquence permet d’exécuter plusieurs instructions l’une à la suite de l’autre ;
- le test ou instruction conditionnelle permet de n’exécuter une instruction que dans certains états ;
- la boucle qui permet d’exécuter plusieurs fois la même instruction dans un programme.

Ces trois instructions, complétées par l'affectation, suffisent à exprimer tous les algorithmes que l’on peut imaginer !

1/ La séquence d'instructions
 Les instructions sont exécutées dans l’ordre où elles apparaissent. En pseudo-langage algorithmique :
Début
instruction1
...
instructionn
Fin

 Dans un algorigramme :

Rqs :
- Un rectangle peut contenir plusieurs instructions
pour simplifier l'écriture.
- Un algorigramme de haut-niveau peut comporter des
ordres sous forme de verbes à l'infinitif : Tourner,
Monter, Attendre, etc. Il faudra ensuite raffiner ces
ordres en instructions élémentaires.

2/ L'instruction conditionnelle (ou "alternative")

 L'instruction conditionnelle permet un branchement dans l'algorithme : un test est effectué (une expression
booléenne qui a la valeur Vrai ou Faux) ; si la valeur est Vrai, alors une séquence est exécutée ; si la valeur est Faux,
une autre séquence peut être effectuée (c'est optionnel).

 La traduction algorithmique est la suivante :

Si condition Alors
séquence1 # séquence exécutée ssi la condition est Vrai
Sinon
séquence2 # séquence exécutée ssi la condition est Faux
FinSi

Si la condition est vraie, c’est séquence1 qui est exécutée, sinon c’est séquence2. Dans les deux cas, après l’exécution de
la séquence, l’instruction suivante à exécuter est celle qui suit le FinSi.

 Algorigramme correspondant :

S'il n'y a pas de séquence exécutée

dans le cas de la condition fausse, on aura :

CPGE TSI – Lycée P.-P. Riquet – St-Orens de Gameville -8-

 Informatique
 La clause SinonSi
L'instruction conditionnelle Si ... Alors ... Sinon ... FinSi peut être complétée avec des clauses SinonSi suivant la structure
suivante :
Pseudo-langage : Algorigramme :
Si condition1 Alors
séquence1
SinonSi condition2 Alors
séquence2
...
SinonSi conditionN Alors
séquenceN
Sinon # Expliciter la condition !
séquence
FinSi

3/ Les instructions itératives (ou répétitives) : boucles

 Par itération, on désigne toute répétition de l'exécution d'un traitement.
Les structures itératives ont pour objet de contrôler le déroulement correct du nombre de répétitions. Lorsque ce
nombre est atteint la structure est terminée : c'est la sortie de boucle.

Deux cas sont à considérer :

- le nombre de répétitions est inconnu ou variable, il dépend uniquement d'une ou plusieurs conditions ; la sortie
dépend alors d'un test effectué sur ces conditions ;
- le nombre de répétitions est connu à l'avance ; la sortie de la boucle d'itération dépend alors d'un test effectué sur le
nombre de répétitions déjà effectuées.

1er cas : nombre de répétitions inconnu : Répétition TantQue … Faire

 L'algorithme présente la structure suivante :
TantQue condition Faire
séquence
FinTQ

La condition doit être une expression booléenne. Pour que la boucle se termine, il est nécessaire que la séquence
modifie la condition.
La condition est évaluée. Si elle vaut FAUX alors la boucle se termine et l’exécution se poursuit avec l’instruction qui suit
FinTQ. Si elle vaut VRAI alors la séquence d’instructions est exécutée et la condition est de nouveau évaluée.

Rq : Après le FinTQ, il est recommandé d'écrire en commentaire la condition fausse (éventuellement exprimée avec De
Morgan). Cela permet de mettre en évidence l'état du programme avant qu'il se poursuive.

 Traduction graphique :

Rq : Comme le test de la condition est fait en premier, on voit bien ici

que la séquence peut ne pas être exécutée. Il suffit que la condition soit
fausse dès le début.

CPGE TSI – Lycée P.-P. Riquet – St-Orens de Gameville -9-

 Informatique
Une variante du 1er cas : Répétition Répéter … Jusqu'à
 Algorithme :
Répéter
séquence
Jusqu'à condition

La condition n’est évaluée qu’après l’exécution de la séquence ; la séquence est donc exécutée au moins une fois.
Comme tout à l'heure, la condition doit être modifiée par la séquence pour que la boucle se termine.

 Algorigramme :

 Exercice : Écrire la répétition Répéter à partir du TantQue et réciproquement.

Répéter devient : séquence
séquence TantQue non condition Faire
Jusqu'à condition séquence
FinTQ

TantQue condition Faire devient : Si condition Alors

séquence Répéter
FinTQ séquence
Jusqu'à non condition
FinSi

2ème cas : nombre de répétitions connu : Répétition Pour

 Algorithme :
Pour var  val_min Jusqu'à var = val_max Faire
sequence
FinPour
ou bien :
Pour Chaque var Dans val_min ... val_max Faire
sequence
FinPour

La variable var est d’un type itérable ; elle est dite variable de contrôle. Les expressions val_min et val_max sont d’un
type compatible avec celui de var. Enfin, la séquence d’instructions ne doit pas modifier la valeur de la variable var.
Les expressions val_min et val_max sont évaluées. La variable var prend alors successivement chacune des valeurs de
l’intervalle [val_min ... val_max] dans l’ordre indiqué et pour chaque valeur, la séquence est exécutée.
Les expressions val_min et val_max ne sont évaluées qu’une seule fois. La séquence peut ne pas être exécutée (si
val_min > val_max).

CPGE TSI – Lycée P.-P. Riquet – St-Orens de Gameville - 10 -

 Informatique
 Algorigramme : il reprend la forme d'un TantQue … Faire :

Quelle répétition choisir ?

 La première question à se poser est : "Est-ce que je
connais a priori le nombre d’itérations à effectuer ?". Dans
l’affirmative, on choisit la boucle Pour. Dans la négative, on
peut généralement employer soit un TantQue, soit un
Répéter.

Dans le cas où on choisit d’utiliser un Répéter, il faut faire attention car les instructions qu’il contrôle seront exécutées
au moins une fois. S’il existe des cas où la séquence d’instructions ne doit pas être exécutée, alors il faut utiliser un
TantQue (ou protéger le Répéter par un Si).

 Une méthode pour choisir entre TantQue et Répéter est de se demander combien de fois on fait l’itération. Si c’est au
moins une fois alors on peut utiliser un Répéter sinon on préfèrera un TantQue.
Rq : Pour aider au choix, il est parfois judicieux de se poser les questions suivantes :
– qu’est ce qui est répété (quelle est la séquence) ?
– quand est-ce qu’on arrête (ou continue) ?

 On peut traduire la stratégie de choix par l'algorithme suivant (!) :

Algorithme Quelle répétition choisir ?
Début
Si nombre d’itérations connu Alors
Résultat  Pour
Sinon
Si itération exécutée au moins une fois Alors
Résultat  Répéter
Sinon
Résultat  TantQue
FinSi
FinSi
Fin

Les problèmes de terminaison et de validité d'une boucle

 Une propriété importante d’un algorithme/programme est qu’il doit se terminer. Sans les boucles, la terminaison est
assurée car avec seulement la séquence et les instructions conditionnelles, l’exécution du programme se fait toujours
vers l’avant. On doit donc nécessairement atteindre la fin.
Avec les répétitions, on peut revenir en arrière dans le programme. Il est alors important de s’assurer que l’on finira
toujours par sortir des répétitions d’un programme. Sinon, le programme risque de s’exécuter indéfiniment. On parle
alors de boucle infinie.

Pour démontrer qu'une boucle se termine effectivement, on identifie un variant, autrement dit une expression (c’est
souvent le simple contenu d’une variable) :
- qui est un entier positif tout au long de la boucle,
- et qui diminue strictement après chaque itération.
On peut alors en conclure que la boucle se termine.
CPGE TSI – Lycée P.-P. Riquet – St-Orens de Gameville - 11 -
 Informatique
 Un programme qui se termine n’est pas forcément un programme correct, c'est-à-dire calculant bien ce que l'on
attend.
Pour vérifier la validité d’une boucle, on utilise un invariant de boucle. C’est une expression booléenne qui est vraie :
- avant d'entrer dans la boucle ;
- après chaque itération dans la boucle ;
- en sortie de boucle.
Le raisonnement employé est en général la récurrence.
Elle aide à prouver la validité d’une boucle et d’un programme. L’invariant est cependant généralement difficile à
trouver et la preuve difficile à faire. Nous y reviendrons au cours de quelques exemples.

V/ LES FONCTIONS

1/ Qu'est-ce qu'une fonction ?

• Une fonction permet au programmeur d’étendre le langage de programmation en définissant ses propres
instructions et ses propres expressions, pour une réutilisation dans différents contextes. Une fonction dépend de
paramètres (ou arguments).

• En toute rigueur, on devrait parler de sous-programme, terme générique pouvant désigner :

- une procédure : elle réalise un traitement et est assimilable à une instruction car elle ne renvoie pas de résultat ;
- une fonction : elle réalise un traitement et est assimilable à une expression car renvoie un résultat. L'appel d'une
fonction peut donc apparaître là où une expression peut être utilisée (à droite de l’affectation , dans une expression,
dans une condition, etc.)
Dans la suite, on utilisera le terme de fonction comme terme générique pour simplifier et rester proche de la notion
de sous-programme dans Python.

2/ Exemple du robot (cf. I/) : variable locale, paramètre formel et paramètre effectif
• Dans les niveaux de raffinage intermédiaires, nous avions identifié les étapes "Tourner à gauche", "Tourner à droite",
"Progresser de n cases" (avec n entier positif). Le processeur du robot ne connaissant que les instructions élémentaires
AVANCER et PIVOTER, il est fastidieux de répéter ces instructions pour produire l'algorithme final, qui n'est
compréhensible que grâce aux commentaires précisant les étapes du raffinage. Il est donc judicieux et élégant de définir
les fonctions suivantes expliquant une fois pour toutes au processeur comment les comprendre :

Fonction Tourner_gauche # Faire tourner le robot à gauche ou bien, avec i : Entier

Début Début
PIVOTER Le corps de la fonction Pour i  1 Jusqu'à i = 3 Faire
PIVOTER doit respecter les règles PIVOTER
PIVOTER d'indentation. FinPour
Fin Fin

Dans ce dernier cas, pour réaliser la fonction, on utilise une variable i. Cette variable est dite variable locale à la
fonction car elle est seulement utilisable dans le traitement réalisé par la fonction.
L'algorithme "appelant" cette fonction ne connait pas l’existence de cette variable. Ainsi :
– la durée de vie de cette variable est celle de la fonction (elle est créée quand la fonction est appelée et est détruite
lorsqu’elle se termine).
– sa portée est loc ale, c'est-à-dire qu'elle est limitée aux instructions de la fonction.

• Pour "Tourner à droite" :

Fonction Tourner_droite # Faire tourner le robot à droite
Début
PIVOTER # On remarque que l'instruction Tourner_droite sera strictement identique à PIVOTER.
Fin
CPGE TSI – Lycée P.-P. Riquet – St-Orens de Gameville - 12 -
 Informatique
• Enfin, "Progresser de n cases" sera :
Fonction Progresser(n) # Faire avancer le robot de n cases dans la direction courante
# n : Entier > 0
Variable
i : Entier

Début
Pour i  1 Jusqu'à i = n Faire
AVANCER
FinPour
Fin

La fonction Progresser ainsi définie possède un paramètre (ou argument) formel nommé n. Chaque paramètre
formel correspond à une information passée par l'algorithme appelant la fonction. Il est caractérisé par un nom et un
type. La valeur fournie à n par l'algorithme appelant est appelée le para mètre effectif.

Ainsi, lorsque l’on écrit une fonction, on raisonne sur la valeur des paramètres formels, sachant que les valeurs
effectives (réelles) ne sont pas encore connues. Dans le cas présent, on pourrait formuler la fonction de la manière
suivante : "étant donné un entier n, faire avancer le robot de n cases dans la direction courante".

Le commentaire "n : entier strictement positif" indique la condition que doit vérifier le paramètre effectif fourni par
l'algorithme appelant. Ici, il faut nécessairement donner une valeur strictement positive pour le paramètre formel n. Si
ceci n’est pas respecté, c’est l'auteur de l'algorithme appelant qui est en faute et non l’auteur de la fonction Progresser.

On peut passer un nombre quelconque de paramètres ; alors, l'ordre des paramètres effectifs doit être le même que
l'ordre des paramètres forme ls.
Ex : Soit la fonction suivante :
Fonction Vitesse(d, t) # Affiche la vitesse en m/s
# d : Réel = distance > 0 en mètres ; t : Réel = temps > 0 en secondes
Début
Ecrire("La vitesse est :", d / t, "m/s.")
Fin
Les paramètres formels sont d et t.
L'instruction Vitesse(100, 5) produit l'affichage La vitesse est : 20 m/s car d prend la valeur du paramètre effectif 100, et
t prend la valeur du paramètre effectif 5. L'ordre est bien respecté.

• L'algorithme permettant au robot d'aller de la salle de cours vers le secrétariat est maintenant structuré :

Algorithme Guider_robot
# Guider le robot de la salle de cours vers le secrétariat
Salle de cours

# Définitions des fonctions

Fonction …
Ici sont écrites toutes les fonctions.
Vestibule
# Algorithme principal
Début
# Sortir de la salle de cours
Couloir
Progresser(2)
Tourner_gauche
Progresser(3)

# Longer le couloir jusqu'à la porte du vestibule

Tourner_droite
Progresser(9)

CPGE TSI – Lycée P.-P. Riquet – St-Orens de Gameville - 13 -

 Informatique
# Traverser le vestibule et entrer dans le secrétariat
Tourner_droite
Progresser(3)
Tourner_droite
Progresser(1) # Idem AVANCER mais permet de rester homogène
Tourner_gauche
Progresser(1)
Fin

• Organiser un algorithme à l’aide de fonctions permet d’éviter les redondances. En outre, cela rend les algorithmes plus
clairs et plus faciles à lire : pour comprendre l'algorithme ci-dessus, il n’est pas nécessaire de savoir comment la fonction
Progresser est programmée, il suffit de savoir ce qu’elle fait. Enfin, cela permet d’organiser l’écriture de l'algorithme : on
peut décider d’écrire la fonction Progresser un jour et l'algorithme principal le lendemain. On peut aussi organiser une
équipe de manière à ce qu’un programmeur écrive la fonction Progresser et un autre l'algorithme principal.

3/ Comment se passe maintenant l'exécution d'un algorithme ?

• Le déroulement d'un algorithme sans fonction est :

Avec des fonctions, le déroulement devient :

• L'algorithme principal appelle une fo nction : il passe alors momentanément le contrôle de l'exécution à la fonction.
L’instruction à exécuter est donc la 1ère instruction de la fonction. Elle s’exécute en ne manipulant que les données qui
correspondent à ses paramètres formels (initialisés à partir des paramètres effectifs) et à ses variables locales.
Lors de la fin de l’exécution de la fonction, il y a le ret our : l’exécution de l'algorithme appelant reprend à
l'instruction suivant l'appel.
• Une fonction peut bien entendu en appeler une autre.

# Algorithme principal Fonction1(paramètres1 formels) Fonction2(paramètres2 formels)

Début Début Début
Instruction Instruction Instruction
Fonction1(paramètres1 effectifs) Fonction2(paramètres2 effectifs) Instruction
Instruction Instruction …
Fonction1(paramètres1 effectifs) … Fin
Fonction2(paramètres2 effectifs) Fin
…
Fin Attention, la disposition suit ici la chronologie de l'exécution. En réalité, il
faudra rédiger dans l'ordre : Fonction2, Fonction1 (car appelle Fonction2)
puis finalement Algorithme principal.
Fonction5

• Par exemple, toujours avec le robot : Faire_demi_tour Reculer(n)

(Fonction1 : Tourner_droite, Début Début
Fonction2 : Tourner_gauche, PIVOTER Faire_demi_tour
Fonction4 PIVOTER Progresser(n)
Fonction3 : Progresser(n))
Fin Faire_demi_tour
Fin

CPGE TSI – Lycée P.-P. Riquet – St-Orens de Gameville - 14 -

 Informatique
4/ Une fonction peut retourner une valeur
• On peut écrire une fonction pour effectuer un calcul ou un test, et non pas seulement une action comme dans
l'algorithme précédent. La fonction retourne donc un résultat. Elle constitue alors une expression.
Par exemple : Utilisation dans l'algorithme appelant :
Fonction parallele(R1, R2) # Retourne Réquivalente Début
# R1, R2 : Réel > 0 …
Variable R  parallele (4700, 10000)
Req : Réel …
Début Fin
Req  (R1* R2) / (R1 + R2)
Retourne Req R1 et R2 sont les paramètres formels, 4700 et 10000 les
Fin paramètres effectifs. Req est le résultat retourné par la
fonction. R reçoit la valeur 3197,28.
5/ La portée des variables : variables globales et variables locales
• On appelle portée d’une variable la partie de l'algorithme où elle peut être utilisée (on dit
qu'elle y est visible). Cette partie commence avec la déclaration de la variable et se termine avec l’entité (algorithme
principal, fonction, module (= bibliothèque = fichier regroupant des fonctions) dans laquelle elle a été déclarée.
Par exemple, la variable i déclarée dans la fonction Progresser ne peut être utilisée et n'est visible que dans cette
fonction. On dit que sa portée est locale. Une autre variable i dans une autre fonction ou dans l'algorithme principal
sera différente en mémoire !

Variable globale
• On appelle variable globale une variable qui est visible (et donc utilisable et modifiable) par toutes les fonctions et
par l'algorithme principal.

Variable locale
•Une variable locale est une variable déclarée à l’intérieur d’une fonction. Sa portée est donc limitée à cette fonction.

Un exemple avec des erreurs

Algorithme Exemple_portée

Variable
ère
x : Entier # x est une variable globale de type Entier. Elle apparaît avant la 1 fonction

Fonction f(n) # n : Réel

Variable
i : Réel # i est une variable locale à la fonction f, qui "masque" la variable i locale à l'algorithme principal
Début
i  5.0 # OK
x3 # OK : la variable x est visible dans tout l'algorithme
c  "d" # Erreur : la variable c n'est pas visible, il faut la déclarer localement à f
Fin

# Algorithme principal
Variable
c : Chaîne # c est une variable locale à l'algorithme principal
Début
n3 # Erreur : la variable n n'est pas visible, il faut la déclarer localement
i  1.2 # Erreur : la variable i n'est pas visible, il faut la déclarer localement
x1 # OK : la variable x est visible dans tout l'algorithme car globale
c  "A" # OK
Fin

CPGE TSI – Lycée P.-P. Riquet – St-Orens de Gameville - 15 -

 Informatique
Du bon usage des variables globales
• De façon générale, les variables globales sont ABSOLUMENT A EVITER car elles correspondent à des paramètres
formels cachés, qui ne sont pas identifiés comme tels dans l'intitulé de la fonction. Elles entraînent alors des
confusions avec les variables locales, et rendent les programmes très difficiles à comprendre et à débugger.
Ceci est particulièrement vrai en Python, où la déclaration d'une variable n'est pas explicite, puisqu'elle est faite à sa 1ère
affectation !

• Une bonne pratique consiste donc à RESTREINDRE les variables globales aux constantes du problème. Comme pour
les fonctions, on donnera alors aux variables globales des noms longs et explicites, ce qui les distinguera de fait des
variables locales qui portent habituellement des noms courts (comme les paramètres formels).

Sources :
- Xavier Crégut, "Algorithmique et Programmation", INPT, 2013
- Benjamin Wack et al., "Informatique pour tous en classes préparatoires
aux grandes écoles", Eyrolles, 2013

CPGE TSI – Lycée P.-P. Riquet – St-Orens de Gameville - 16 -