Les structures repetitives

1.1. Introduction

Dans les problèmes quotidiens, on ne traite pas uniquement des séquences d'actions, sous ou sans conditions, mais il peut être fréquent d'être obligé d'exécuter un traitement (séquence d'actions), plusieurs fois. En effet, pour saisir les N notes d'un étudiant et calculer sa moyenne, on est amené à saisir N variables, puis faire la somme et ensuite diviser la somme par N. Cette solution nécessite la réservation de l'espace par la déclaration des variables, et une série de séquences d'écriture/lecture. Ce problème est résolu à l'aide des structures répétitives. Celles ci permettent de donner un ordre de répétition d'une action ou d'une séquence d'actions une ou plusieurs fois.

1.2. La boucle POUR

Cette structure exprime la répétition d'un traitement un nombre de fois.

Syntaxe

POUR Vc DE Vi A Vf [PAS Vp] FAIRE

            <Traitement>

FINFAIRE

Où       Vc est une variable entière, qui compte le nombre de répétition du <Traitement>,

            Vi la valeur initiale à laquelle Vc est initialisé,

            Vf la valeur finale à laquelle se termine Vc,

            Vp la valeur du pas, c'est la valeur qu'on rajoute à Vc à chaque fin de traitement.

Remarque

1.      La boucle POUR est utilisée lorsqu'on connaît le nombre de répétition du <Traitement> d'avance.

2.      La valeur du pas peut être positive ou négative et par conséquent, il faut; au départ de la boucle; que Vi <= Vf ou Vi >= Vf selon la positivité ou la négativité de cette valeur.

3.      La valeur du pas est égale à 1 par défaut.

Les étapes d'exécution de la boucle POUR

1)      Initialisation de Vc par la valeur de Vi (comme si on avait Vc¬Vi)

2)      Test si Vi dépasse (±) Vf (du côté supérieur ou inférieur, selon la positivité ou la négativité du pas).                                                                                                                Si oui, alors la boucle s'arrête et l'exécution se poursuit après le FINFAIRE                   Sinon,

·                    Exécution du <Traitement>,

·                    Incrémentation ou décrémentation de Vc par la valeur du pas,

·                    Retour à l'étape 2.

Application

Ecrire l'algorithme qui permet de saisir les moyennes des N étudiants de la classe Informatique et de calculer la moyenne générale de la classe.

Résolution

Sans les boucles, on est obligé de déclarer N variables, et d'écrire N actions LIRE.

LIRE(note)

S¬ S + MOY

LIRE(MOY)

S¬ S + MOY

…..

LIRE(MOY)

S¬ S + MOY

La boucle POUR donne l'ordre à la machine d'itérer les deux actions        N fois.

Donc le compteur varie de 1 jusqu'à N avec un pas de 1.

ALGORITHME MOYENNE

VAR i, N : entier

            MOY, MC : réel

DEBUT

ECRIRE("Donner le nombre d'étudiants")

LIRE(N)

SI (N > 0) ALORS

S ¬ 0 {Initialisation de S}

POUR i DE 1 A N FAIRE {Le pas égale 1 par défaut}

            ECRIRE("Donner la moyenne de l'étudiant n°", i)

            LIRE(MOY)

            S ¬ S + MOY {on rajoute la moyenne du i^ième étudiant à la somme}

            FIN FAIRE

            MC ¬ S / N

            ECRIRE("La moyenne de la classe est : ", MC)

SINON

            ECRIRE("Erreur dans le nombre d'étudiants")

FINSI

FIN

Remarque Juste Avant le FIN FAIRE, le changement de la valeur de i se fait automatiquement.

Application 1

Ecrire l'algorithme qui permet d'afficher tous les nombres pairs qui existent entre 1 et 10.

1^ière solution

POUR i de 2 à 10 pas 2 Faire

            ECRIRE(i)

FINFAIRE

2^ième solution

POUR i de 2 à 10 Faire

SI (i mod 2 = 0) ALORS

            ECRIRE(i)

FINSI

FINFAIRE

3^ième solution

POUR i de 1 à 5 Faire

            ECRIRE(2*i)

FINFAIRE

Application 2

Ecrire l'algorithme qui permet d'afficher tous les nombres impairs entre 50 et 100 dans l'ordre décroissant.

POUR i de 99 à 50 PAS (-2) FAIRE

            ECRIRE(i)

FIN FAIRE

La valeur finale peut être 50 ou 51 car le test de sortie est i < Vf (49 < 50 ou à 51)

1.3. La boucle Répéter … Jusqu'à

Syntaxe

Répéter

            <Traitement>

Jusqu'à (condition d'arrêt)

Cet ordre d'itération permet de répéter le <Traitement> une ou plusieurs fois et de s'arrêter sur une condition. En effet, lorsque la condition est vérifiée, la boucle s'arrête, si non elle ré-exécute le <Traitement>.

Remarques

1.      Dans cette boucle, le traitement est exécuté au moins une fois avant l'évaluation de la condition d'arrêt.

2.      Il doit y avoir une action dans le <Traitement> qui modifie la valeur de la condition.

Les étapes d'exécution de la boucle Répéter

1)      Exécution du <Traitement>

2)      Test de la valeur de la <condition d'arrêt>

Si elle est vérifiée Alors la boucle s'arrête

Sinon Retour à l'étape 1.

Application

Ecrire un algorithme qui saisit un nombre pair et qui détermine combien de fois il est divisible par 2. Exemple 8 est divisible 3 fois par 2 (2*2*2).

ALGORITHME PAIR-NBDIV2

VAR N, N2 : entier

DEBUT

{Saisie d'un entier qui doit être pair}

Répéter

            ECRIRE("Donner un entier pair")

            LIRE(N)

Jusqu'à (N MOD 2 = 0) {condition pour que N soit pair}

{Détermination du nombre de division par 2}

N2 ¬ 0

NB ¬ N

Répéter

            NB ¬ NB div 2

            N2 ¬ N2 +1

Jusqu'à (NB MOD 2 <> 0) {On s'arrête lorsque NB n'est plus divisible par 2}

ECRIRE(N, "est divisible par 2", N2,"fois")

FIN

1.4. La boucle TANT QUE

Syntaxe

TANT QUE (condition d'exécution)

FAIRE

            <Traitement>

FIN FAIRE

Cet ordre d'itération permet de répéter le <Traitement> zéro ou plusieurs fois et de s'arrêter lorsque la condition d'exécution n'est plus vérifiée. En effet, lorsque la condition d'exécution est vérifiée, le <Traitement> est exécuté, si non elle s'arrête.

Les étapes d'exécution de la boucle Répéter

1)      Test de la valeur de la <condition d'exécution>

2)      Si elle est vérifiée Alors

Exécution du <Traitement>

    Retour à l'étape 1.

Sinon Arrêt de la boucle.

Remarques

1.      Dans cette boucle, le traitement peut ne pas être exécuté aucune fois, c'est lorsque la condition d'exécution est à faux dés le départ.

2.      Les paramètres de la condition doivent être initialisés par lecture ou par affectation avant la boucle.

3.      Il doit y avoir une action dans le <Traitement> qui modifie la valeur de la condition.

Application

Ecrire un algorithme qui saisit un nombre pair et qui détermine combien de fois il est divisible par 2. Exemple 8 est divisible 3 fois par 2 (2*2*2).

ALGORITHME PAIR-NBDIV2

VAR N, N2 : entier

DEBUT

{Saisie d'un entier qui doit être pair}

Répéter

            ECRIRE("Donner un entier pair")

            LIRE(N)

Jusqu'à (N MOD 2 = 0) {condition pour que N soit pair}

{Détermination du nombre de division par 2}

N2 ¬ 0

NB ¬ N

TANT QUE (NB MOD 2 = 0)

FAIRE

            NB ¬ NB div 2

            N2 ¬ N2 +1

FIN FAIRE {On s'arrête lorsque NB n'est plus divisible par 2}

ECRIRE(N, "est divisible par 2", N2,"fois")

FIN

Ä La condition d'arrêt avec la boucle Répéter est l'inverse de la condition d'exécution de la boucle TANTQUE.

Remarque

Le Traitement d'une boucle peut contenir lui aussi une autre boucle. On l'appelle dans ce cas des boucles imbriquées.