Comprendre l’organisation, les instructions élémentaires et l’ordre d’exécution

Fiche pédagogique du chapitre

Objectifs d’apprentissage

À la fin de ce chapitre, l’étudiant devra être capable de :

• identifier les différentes parties qui composent un algorithme ;
• choisir un nom d’algorithme clair et conforme aux règles de nommage ;
• distinguer la partie déclarative de la partie principale ;
• déclarer correctement des variables et des constantes ;
• utiliser les instructions d’affectation, de lecture et d’écriture ;
• insérer des commentaires utiles sans surcharger l’algorithme ;
• expliquer le principe de l’exécution séquentielle ;
• réaliser le traçage manuel d’un algorithme simple ;
• déterminer l’état d’une variable avant et après chaque instruction.

Prérequis

• comprendre la notion générale d’algorithme ;
• savoir distinguer un problème, un algorithme et un programme ;
• reconnaître les notions d’entrée, de traitement et de sortie ;
• maîtriser les opérations arithmétiques élémentaires.

Plan du chapitre

2.1 Organisation d’un algorithme

2.2 Instructions élémentaires

2.3 Ordre d’exécution

Synthèse, exercices d’application et corrigé indicatif

Organisation pédagogique indicative

2.1 Organisation d’un algorithme

2.1.1 Vue d’ensemble

Un algorithme simple est généralement composé de deux grandes parties : une partie déclarative et une partie principale. L’ensemble est encadré par un nom, une instruction de début et une instruction de fin. Cette organisation permet au lecteur de repérer immédiatement les données utilisées et les actions exécutées.

Structure générale

2.1.2 Nom de l’algorithme

Le nom de l’algorithme est placé au début. Il résume l’objectif principal et permet de distinguer l’algorithme d’autres solutions. Un bon nom doit être court, explicite et directement lié au problème traité.

• Privilégier un verbe ou un groupe nominal explicite : Calculer_Moyenne, Convertir_Temperature, Perimetre_Rectangle.
• Éviter les noms trop vagues : Algo1, Test, Programme, Exercice.
• Éviter les espaces dans le nom : on utilise généralement le caractère de soulignement « _ ».
• Éviter les caractères spéciaux : ponctuation, symboles mathématiques ou lettres susceptibles de poser un problème dans un langage de programmation.
• Conserver une convention stable : par exemple, commencer chaque mot par une majuscule ou utiliser uniquement des minuscules séparées par des soulignements.

Exemple

2.1.3 Partie déclarative

La partie déclarative présente les informations que l’algorithme devra mémoriser pendant son exécution. Elle contient principalement les constantes et les variables. Déclarer une donnée consiste à préciser son nom et, le plus souvent, son type.

Constantes

Une constante est une donnée dont la valeur ne change pas pendant l’exécution. Elle est utile pour représenter une valeur fixe possédant un sens particulier, comme un taux, une limite ou une valeur mathématique.

Variables

Une variable est une zone de mémoire identifiée par un nom. Sa valeur peut évoluer au cours de l’exécution. Le type indique la nature des valeurs qu’elle peut contenir : entier, réel, booléen, caractère ou chaîne de caractères.

Exemple de déclaration

2.1.4 Partie principale

La partie principale contient les instructions exécutables. Elle décrit le traitement à effectuer dans l’ordre où les actions doivent être réalisées. Dans un premier temps, les algorithmes étudiés sont séquentiels : chaque instruction est exécutée une seule fois, de haut en bas.

• les données peuvent être saisies à l’aide d’instructions de lecture ;
• les valeurs peuvent être calculées ou modifiées par des affectations ;
• les résultats peuvent être communiqués par des instructions d’écriture ;
• les commentaires expliquent une intention, mais ne sont pas exécutés.

Exemple de partie principale

Indentation et présentation

Les instructions de la partie principale sont décalées vers la droite. Cette indentation ne change pas le résultat mathématique, mais elle rend la structure visuelle plus facile à comprendre. Elle deviendra indispensable lorsque le cours abordera les conditions, les boucles, les fonctions et les procédures.

2.1.5 Instructions de début et de fin

Les mots-clés Début et Fin délimitent la partie exécutable de l’algorithme. Ils indiquent clairement où commence le traitement et où il s’achève. Tout ce qui se trouve avant Début appartient normalement à l’en-tête ou à la partie déclarative.

Exemple complet et annoté

Le problème consiste à calculer le prix toutes taxes comprises à partir d’un prix hors taxe et d’un taux de TVA fixé à 20 %.

2.2 Instructions élémentaires

Les instructions élémentaires constituent les briques de base d’un algorithme. Avant d’étudier les choix et les répétitions, il faut maîtriser les opérations simples permettant de créer des données, de leur attribuer une valeur, de recevoir des informations et d’afficher des résultats.

2.2.1 Déclaration

La déclaration prépare les données utilisées par l’algorithme. Elle associe un nom à un type. Selon les conventions, plusieurs variables de même type peuvent être déclarées sur la même ligne.

Règles de nommage des variables

• utiliser un nom qui exprime le contenu de la variable ;
• ne pas commencer par un chiffre ;
• ne pas utiliser d’espace ;
• éviter les accents et les caractères spéciaux lorsqu’une traduction en programme est prévue ;
• ne pas utiliser un mot-clé du pseudo-code ou du langage de programmation ;
• conserver la même orthographe à chaque utilisation.

2.2.2 Affectation

L’affectation place une valeur dans une variable. Elle est représentée en pseudo-code par une flèche orientée vers la variable : ←. L’expression placée à droite est d’abord évaluée, puis son résultat est enregistré dans la variable située à gauche.

Affectation et égalité mathématique

L’affectation ne doit pas être confondue avec l’égalité mathématique. En mathématiques, l’écriture x = x + 1 est impossible. En algorithmique, x ← x + 1 signifie que la nouvelle valeur de x est calculée à partir de son ancienne valeur.

Compatibilité des types

La valeur affectée doit être compatible avec le type de la variable. Une variable entière peut recevoir 12, mais elle ne devrait pas recevoir directement une chaîne comme « douze ». Les conversions de types seront étudiées lors du passage à la programmation.

Exemple : échanger deux valeurs

Pour échanger le contenu de deux variables, une variable temporaire est nécessaire afin de ne pas perdre la première valeur.

2.2.3 Lecture

L’instruction de lecture permet à l’algorithme de recevoir une valeur provenant de l’utilisateur, d’un fichier, d’un capteur ou d’un autre système. Dans les premiers exercices, on considère généralement que la valeur est saisie au clavier.

Lors de l’exécution, l’algorithme s’arrête temporairement au niveau de Lire(age), attend une valeur, puis place cette valeur dans la variable age. La variable doit avoir été déclarée auparavant.

Invite de saisie

Il est conseillé d’afficher un message avant une lecture afin que l’utilisateur sache quelle information fournir. Une suite d’instructions Lire(a), Lire(b) sans explication peut fonctionner, mais elle rend l’utilisation difficile.

2.2.4 Écriture

L’instruction d’écriture communique une information. Elle peut afficher un texte fixe, la valeur d’une variable, le résultat d’une expression ou une combinaison de plusieurs éléments.

Texte et variables

Le texte fixe est généralement placé entre guillemets. Le nom d’une variable n’est pas placé entre guillemets, car l’algorithme doit afficher son contenu et non son nom.

2.2.5 Commentaires

Un commentaire est un texte destiné au lecteur. Il explique l’objectif d’une instruction, justifie un choix ou sépare les grandes étapes. Il n’est pas exécuté par l’ordinateur. Dans ce support, on utilise la notation // pour introduire un commentaire sur une ligne.

Caractéristiques d’un bon commentaire

• il explique l’intention plutôt que de répéter mot à mot l’instruction ;
• il reste court et directement lié au traitement ;
• il est mis à jour lorsque l’algorithme change ;
• il aide à comprendre un calcul, une convention ou une étape importante ;
• il n’est pas utilisé pour compenser des noms de variables imprécis.

Exemple intégrateur : conversion d’une durée

On souhaite convertir une durée exprimée en secondes en heures, minutes et secondes. Cet exemple réunit la déclaration, la lecture, l’affectation, l’écriture et les commentaires.

2.3 Ordre d’exécution

2.3.1 Exécution séquentielle

Dans un algorithme séquentiel, les instructions sont exécutées une par une, de haut en bas, dans l’ordre où elles sont écrites. Une instruction ne commence normalement qu’après la fin de l’instruction précédente.

L’affichage vaut 11 et non 17. La variable somme a été calculée avant que a ne reçoive la valeur 10. Une affectation ultérieure de a ne modifie pas automatiquement les valeurs déjà calculées et enregistrées dans d’autres variables.

Dépendance entre les instructions

L’ordre devient particulièrement important lorsqu’une instruction utilise une valeur calculée auparavant. Une variable doit être initialisée avant d’être lue dans une expression.

2.3.2 Traçage manuel d’un algorithme

Le traçage manuel consiste à simuler l’exécution d’un algorithme sur papier. On suit les instructions dans l’ordre et on note, après chaque étape, la valeur des variables. Cette méthode permet de comprendre le fonctionnement, de vérifier un résultat et de détecter une erreur logique avant la programmation.

Méthode de traçage

1. Choisir un jeu de données d’entrée.

2. Écrire les variables dans les colonnes d’une table de trace.

3. Commencer avec des valeurs non définies pour les variables non initialisées.

4. Exécuter mentalement la première instruction.

5. Mettre à jour uniquement les variables modifiées par cette instruction.

6. Continuer jusqu’à l’instruction Fin.

7. Comparer la sortie obtenue avec le résultat attendu.

Exemple de traçage

2.3.3 État d’une variable avant et après une instruction

L’état d’un algorithme correspond à l’ensemble des valeurs actuellement mémorisées dans ses variables. Chaque instruction peut conserver cet état ou le modifier. Pour comprendre une affectation, il est utile de distinguer l’ancienne valeur de la nouvelle valeur.

Une affectation modifie uniquement la variable située à gauche de la flèche. Les variables utilisées à droite servent au calcul, mais leur valeur ne change pas sauf si une autre instruction les modifie explicitement.

Exemple : évolution d’un compteur

Exemple : perte d’une ancienne valeur

Lorsqu’une variable reçoit une nouvelle valeur, son ancienne valeur est remplacée. Elle n’est plus accessible, sauf si elle a été préalablement copiée dans une autre variable.

À la fin, x vaut 25 et ancien_x vaut 12. Sans la deuxième instruction, la valeur 12 aurait été perdue.

2.3.4 Erreurs courantes liées à l’ordre

Synthèse du chapitre

Exercices d’application

Exercice 1 — Repérer les différentes parties

On considère l’algorithme suivant :

1. Donner le nom de l’algorithme.

2. Identifier la partie déclarative.

3. Identifier les entrées.

4. Identifier le traitement.

5. Identifier la sortie.

6. Proposer deux messages d’invite de saisie et un libellé pour le résultat.

Exercice 2 — Corriger la structure

L’algorithme suivant contient plusieurs erreurs de présentation ou d’ordre. Le réécrire correctement.

Exercice 3 — Table de trace

Compléter la table de trace de l’algorithme suivant.

Exercice 4 — Échange de valeurs

Les variables a et b valent respectivement 7 et 12. Écrire les instructions permettant d’échanger leurs valeurs. Réaliser ensuite une table de trace.

Exercice 5 — Conception d’un algorithme complet

Concevoir un algorithme qui demande la longueur et la largeur d’un rectangle, calcule son aire et son périmètre, puis affiche les deux résultats avec des libellés clairs. Le pseudo-code doit comporter :

• un nom explicite ;
• une partie déclarative ;
• des messages d’invite ;
• deux lectures ;
• deux affectations de calcul ;
• deux écritures de résultat ;
• au moins un commentaire utile.

Corrigé indicatif

Correction de l’exercice 1

Correction de l’exercice 2

Le nom est placé au début, les variables sont déclarées avant utilisation, la lecture précède le calcul, et les instructions exécutables sont placées entre Début et Fin.

Correction de l’exercice 3

Correction de l’exercice 4

Correction de l’exercice 5

Éléments essentiels à mémoriser

1. Donner à l’algorithme un nom explicite.

2. Déclarer les constantes et les variables avant de les utiliser.

3. Placer les instructions exécutables entre Début et Fin.

4. Lire les données avant les calculs qui en dépendent.

5. Comprendre que variable ← expression remplace l’ancienne valeur de la variable.

6. Afficher des résultats accompagnés de libellés clairs.

7. Utiliser les commentaires pour expliquer l’intention et non l’évidence.

8. Respecter l’ordre d’exécution séquentiel.

9. Utiliser une table de trace pour vérifier l’évolution des variables.

10. Contrôler qu’aucune variable n’est utilisée avant son initialisation.