Les Structures Itératives
En Algorithme, les structures itératives, souvent appelées
boucles, sont des outils essentiels pour répéter un bloc
d'instructions plusieurs fois. Elles permettent
d'automatiser des tâches répétitives
AS
ITÉRATIVE = RÉPÉTER
Une structure ITÉRATIVE est un mécanisme de
programmation qui permet de répéter une suite d'instructions
un certain nombre de fois ou jusqu'à ce qu'une
CONDITION spécifique soit remplie
AS
Prenons le cas d’une saisie au clavier, par exemple, on pose une
question à laquelle l’utilisateur doit répondre par O (Oui) ou N
(Non).
L’utilisateur risque de taper autre chose (une autre lettre), le
programme peut soit planter par une erreur d’exécution soit se
dérouler normalement jusqu’au bout, mais en produisant des
résultats fantaisistes.
Pour remédier à ce problème, on peut mettre en place un contrôle de
saisie pour vérifier que les données entrées au clavier correspondent
AS
bien à celles attendues par l’algorithme.
Algorithme controleDeSaisie
Variable
Rep : caractère
Début
AFFICHER "Voulez vous une copie de ce cours ? (O/N)"
SAISIR Rep
Si Rep ≠ 'O' ET Rep ≠ 'N' Alors
AFFICHER "Erreur de saisie; recommencez"
SAISIR Rep
Finsi
Fin
L’algorithme ci-dessus résout le
problème si on se trompe qu’une seule
fois, et on fait entrer une valeur correcte
à la deuxième demande. Sinon en cas de
deuxième erreur, il faudrait rajouter un
SI. Et ainsi de suite, on peut rajouter des
centaines de SI.
LA SOLUTION À CE
PROBLÈME
CONSISTE À
UTILISER UNE
STRUCTURE RÉPÉTITIVE.
IL EXISTE TROIS TYPES DE BOUCLES OU
STRUCTURES ITERATIVES
• Boucle TANT QUE (WHILE)
• Boucle POUR (FOR)
• Boucle REPETER (DO-WHILE ou
REPEAT-UNTIL)
La Boucle TANT QUE (WHILE)
La boucle TANT QUE exécute un bloc d'instructions tant qu'une condition
donnée est vraie. Elle est utile lorsque le nombre d'itérations est inconnu à
l'avance.
Définition : Répète des instructions tant qu'une condition est
vraie
Syntaxe :
Tant que (condition)
instructions
Fin tant que
Exemple : Compter jusqu'à N:
compteur 1
Tant que (compteur <= N)
Afficher(compteur)
compteur compteur + 1
Fin tant que
Boucle infinie
compteur 1
Tant que (compteur <= N)
Afficher(compteur)
Fin tant que
Exemple :
Algorithme contrôle_de_saisie
Variable Rep : caractère
Début
AFFICHER ("Voulez vous une copie de ce cours ? (O/N)" )
SAISIR (Rep)
TantQue Rep ≠ 'O' ET Rep ≠ 'N' faire
AFFICHER (" Erreur de saisie")
AFFICHER ("Voulez vous une copie de ce cours ? (O/N)" )
SAISIR (Rep)
FinTantQue
Finsi
Ecrire un algorithme qui calcule S = 1
+ 2 + 3 + 4 + 5 + ... + N.
Ecrire un algorithme qui calcule S = 1 + 2 + 3 + 4 + 5 + ... + N.
Solution :
Algorithme Somme
Variables S, I, N : Entier
Début
AFFICHER ("Entrer la valeur de N : ")
SAISIR (N)
S <- 0
I <-1
TantQue I <= N faire
S <- S + I
I <-I +1
FinTantQue
AFFICHER (''La somme des '', N, '' premiers entiers est : '', S)
Fin
La Boucle POUR (FOR)
La boucle POUR est idéale lorsque le nombre d'itérations est
connu à l'avance. Elle combine L'INITIALISATION, la
CONDITION et l'INCRÉMENTATION en une seule ligne.
Propriétés :
- On utilise la structure pour quand le nombre d’itération est connu à l’avance.
- Le compteur est initialisé à 1.
- Le pas d’incrémentation =1/ on peut parfois incrémenter à 2, à 3 etc.
Syntaxe
POUR comptvaleur_initiale à Valeur_finale pas valeur
INSTRUCTION
FINPOUR
EXEMPLE
Ecrire un algo qui saisit 25 nombres qui fait la somme
des 25 nombres et affiche le résultat
Solution :
Algorithme Somme
Variables S, N : Entier
Début
S <- 0
POUR i 1 à 25 PAS 1 faire
AFFICHER ("saisir un nombre N : ")
SAISIR (N)
S <- S + N
FINPOUR
AFFICHER S
Fin
A RETENIR
Lorsque le pas n’est pas
signifié, par défaut, il est 1
La Boucle RÉPÉTER... JUSQU'À
La boucle RÉPÉTER... JUSQU'À est une structure de
contrôle qui exécute un bloc d’instructions au moins
une fois et continue à l’exécuter jusqu’à ce qu’une
condition donnée soit vraie.
Syntaxe
RÉPÉTER
Instructions
JUSQU’À (Condition)
EXEMPLE
Ecrire un Algo qui Affiche les
nombres de 1 à 5.
Solution :
Algorithme Somme
Variables i : Entier
Début
i ← 1 // Initialisation
RÉPÉTER
Afficher i // Afficher la valeur actuelle de i
i ← i + 1 // Incrémenter i
JUSQU’À (i > 5) // Arrêter quand i dépasse 5
Fin
Exemple :
Demander l’âge jusqu’à ce qu’il soit valide
On demande l’âge d’une personne, mais
l’âge doit être entre 0 et 20.
On répète tant que l’âge donné est incorrect.
Variables :
age : entier
Début
Répéter
Saisir"Veuillez entrer votre âge : "
afficher age
Jusqu’à (age ≥ 0 ET age ≤ 20)
Afficher "Âge accepté : ", age
Fin
TABLEAU
Imaginons que dans un programme,
nous avons besoin d’un grand
nombre de variables, il devient difficile
de donner un nom à chaque
variable.
Exemple :
Ecrire un algorithme permettant de
saisir cinq notes et de les afficher
après avoir multiplié toutes les notes
par trois.
Solution :
Algorithme Note
Variables N1, N2, N3, N4, N5 : Réel
Début
Saisir ("Entrer la valeur de la 1er note")
Afficher (N1)
Saisir ("Entrer la valeur de la 2ème note")
Afficher (N2)
Saisir ("Entrer la valeur de la 3ème note")
Afficher (N3)
Saisir ("Entrer la valeur de la 4ème note")
Afficher (N4)
Saisir ("Entrer la valeur de la 5ème note")
Afficher (N5)
Saisir ("La note 1 multipliée par 3 est : ", N1 * 3)
Saisir ("La note 2 multipliée par 3 est : ", N2 * 3)
Saisir ("La note 3 multipliée par 3 est : ", N3* 3)
Saisir ("La note 4 multipliée par 3 est : ", N4 * 3)
Saisir("La note 5 multipliée par 3 est : ", N5 * 3)
Fin
La même instruction se répète cinq fois. Imaginons que
si l'on voudrait réaliser cet algorithme avec 40 notes,
cela deviendrait fastidieux.
Comme les variables ont des noms différents, on ne
peut pas utiliser de
boucle,
ce qui allonge considérablement le code et le rend très
répétitif.
Pour résoudre ce problème, il existe un type de données
qui permet de définir plusieurs variables de même type.
•Constituée de cases dites éléments du
tableau,
•chaque élément est identifié par un
numéro appelé indice
•Chaque case peut accueillir une valeur
différente.
En commence souvent la numérotation des
cases à partir de 0 et on incrémente de 1
pour passer à la case suivante
Syntaxe
• On commence par le terme tableau,
• Identifiant qui est le nom du tableau qui contient le nombre
d’éléments
• Type : chaque tableau doit contenir des valeurs de même
type unique à savoir entier, réel, chaîne de caractère et
booléen
• Tableau nom (40) : Chaîne de caractères
• Tableau nom [ 40 ] : Chaîne de caractères
• Tableau nom [ 0 . . 39 ] : Chaîne de caractères
• Tableau nom [ 1 . . 40] : Chaîne de caractères
• COMMENT ACCEDER AUX ELEMENTS DE
CHAQUE CASE
nom [ NUMERO DE LA CASE ]
INDICE OU INDEX
EXEMPLE :
Pour accéder au 10 ème élément de notre
tableau
Nom [ 9 ] : si le premier indice est 0
Nom [ 10 ] : si le premier indice est 1
ECRIT UN ALGORITHME QUI PERMET A L’UTILISATEUR DE SAISIR LE NOM
DES 40 ETUDIANTS : REMPLISSAGE
Algorithme Etudiants
Variables
Tableau nom [ 40] : Chaîne de caractères
i : entier
Debut
pour i 0 à 39 Faire
Afficher ( ‘Nom de l’’étudiant’, i+1, ‘ : ‘)
Saisir (nom [ i ])
FINPOUR
FIN
REMPLISSAGE
Algorithme Etudiants
Variables
Tableau nom [ 40] : Chaîne de caractères
i : entier
X : chaîne de caractère
Debut
pour i 0 à 39 Faire
Afficher ( ‘Nom de l’’étudiant’, i+1, ‘ : ‘)
Saisir X
nom [ i ] X
FINPOUR
FIN
AFFICHAGE
Algorithme Etudiants
Variables
Tableau nom [ 40] : Chaîne de caractères
i : entier
Debut
Pour i 0 à 39 Faire
Afficher ( ‘Nom de l’’étudiant’, i+1, ‘ : ‘)
Saisir (nom [ i ])
FINPOUR
Pour i 0 à longueur (nom)-1 Faire
Afficher ( ‘ Etudiant’, i+1, ‘ : ‘, nom [ i ] )
FINPOUR
FIN
LES FONCTIONS
ET PROCEDURES
LES FONCTIONS
Une fonction est un ensemble d'instructions regroupées sous un
nom. Elle prend en entrée des paramètres (ou arguments) et
retourne un résultat.
Une fonction est écrite séparément du corps de l'algorithme
principal et peut être appelée par celui-ci lorsque cela est
nécessaire.
Un paramètre est une variable déclarée dans
la définition d’une fonction. Il sert de
référence pour les valeurs qui seront passées
à la fonction.
Un argument est la valeur réelle
passée à une fonction lors de son appel .
Exemple simple
Fonction qui calcule la somme de deux nombres
Fonction Somme(a, b) : entier
Variable Explication :
résultat: : entier • a et b sont les
Début paramètres
• La fonction
résultat ← a + b additionne a et b
retourner résultat • elle retourne le
résultat
Fin
Explication de la fonction (partie du haut)
Déclaration de la fonction
Fonction puissance (N : Entier) : Entier
👉 Cela signifie :
•le nom de la fonction est puissance
•elle reçoit un paramètre N de type
entier
•elle retourne un entier
🔹 Variable locale
Variables P : Entier
P est une variable locale à la fonction, utilisée uniquement à l’intérieur.
Corps de la fonction
👉 Étapes :
• on calcule le carré de N
• on stocke le résultat dans P
• la fonction retourne la valeur de P
Important :
Sans Retourne, ce n’est plus une fonction mais
une erreur.
Ce qui se passe :
1.L’utilisateur saisit un nombre x
[Link] appelle la fonction puissance(x)
[Link] fonction calcule x²
[Link] résultat est affiché
Comment la fonction fonctionne réellement (logique)
Si l’utilisateur saisit :
x=4
Alors :
•puissance(4)
•P ← 4 ^ 2
•P = 16
•la fonction retourne 16
•le programme affiche :
👉 La puissance du nombre 4 est : 16
POURQUOI UTILISER DES
FONCTIONS ?
Une fonction permet de :
✔éviter la répétition du code
✔rendre l’algorithme plus clair
✔faciliter la maintenance
✔découper un problème complexe en petites
parties
Algorithme exercice_fonction
// Définition de la fonction qui retourne le minimum entre deux nombres
Fonction minimum(x : entier, y : entier) : entier
Variables
min : entier
Début
Si x >= y alors
min ← y
Sinon
min ← x
FinSi
Retourne min
Fin
//Déclaration des variables principales
Variables x, y : entier
Début
// Demande à l'utilisateur d'entrer deux valeurs
Afficher("Veuillez entrer les valeurs de x et y : ")
Saisir(x, y)
Afficher("Le minimum est : ", minimum(x, y))
Fin
LES PROCEDURES
Qu’est-ce qu’une procédure ?
Une procédure est une suite d’instructions regroupées sous
un nom. Elle prend en entrée des paramètres (arguments)
mais ne retourne rien.
Une procédure est écrite séparément du corps de
l’algorithme principal et sera appelée par celui-ci lorsque cela
sera nécessaire.
Procédure puissance (N : Entier)
Variables P : Entier
Début
P←N^2
Ecrire("La puissance du nombre ", N, " est : ", P)
Fin