Structures itératives

Objectifs

Connaitre les structures itératives

Les structures itératives (ou boucles) permettent de répéter une série d'instructions plusieurs fois. Elles sont composées de 3 parties essentielles :

l'initialisation
la condition de poursuite (ou le critère d'arrêt)
et l'évolution (incrémentation).

Les structures itératives de type Pour et Tant que sont détaillées ci-dessous.

Résumé

Rôle	Commande R	Syntaxe	Exemple	Exercice
Pour	for	Présentation	Exemple	ici
Tant que	while	Présentation	Exemple	ici

Exemple

Dans l'exemple ci-dessous, l'algorithme exécute d'abord l'Instruction n°1, préalable à la structure itérative. Puis l'Instruction n°2 est exécutée pour toutes les valeurs de i allant de début à fin par pas de increment. Et pour finir, il exécute une seule fois l'Instruction n°3, postérieure à la structure itérative :

    Début
    Instruction n°1
    Pour i allant de début à fin par pas de increment faire
        Instruction n°2
    Fin du Pour
    Instruction n°3
Fin

Et en langage R, cet algorithme se traduit de la façon suivante :

    Instruction n°1
    for(i in seq(from=debut, to=fin, by=increment)){
        Instruction n°2
    }
    Instruction n°3

Bien évidemment, il est tout à fait possible d'exécuter plusieurs instructions avant la boucle, après la boucle, mais aussi à l'intérieur de la boucle (c'est à dire à chaque itération).

Remarque

L'instruction seq(from=debut, to=fin, by=increment) permet de créer une séquence de nombres allant de la valeur début à la valeur fin par pas de increment. Par exemple, pour créer la séquence allant de 1 à 5, on utilise l'instruction seq(from=1, to=5, by=1). De la même façon, l'instruction seq(from=5, to=1, by=-1) permet de créer une séquence allant de 5 à 1.
S'il n'y a qu'une instruction entre les accolades, alors celles-ci deviennent facultatives.

Exemple

L'algorithme ci-dessous permet d'afficher à l'écran les entiers de 1 à N, N étant un entier saisi par l'utilisateur. Le pseudo-code est le suivant :

    Début
    Affectation de N
    Pour i allant de 1 à N par pas de 1 faire
        Afficher i
    Fin du Pour
    Fin

Pour la traduction en langage R, la valeur N = 4 est choisie :

    N ‹- 4
    for(i in seq(from=1, to=N, by=1)){
        print(i)
    }

## [1] 1
## [1] 2
## [1] 3
## [1] 4

Exercice : Somme des entiers de 1 à N

Le pseudo-code suivant permet de calculer la somme des entiers de 1 à N en utilisant la structure itérative Pour.

    Début
    Affectation de N
    Somme ‹- 0
    i ‹- 1
    Pour i allant de 1 à N par pas de 1 faire
        Somme ‹- Somme + i
    Fin du Pour
    Afficher Somme
    Fin

Traduire cet algorithme en langage R et le tester pour N = 5.

Corrigé

Traduction en langage R.

    N ‹- 5
    Somme ‹- 0
    i ‹- 1
    for(i in seq(from=1, to=N, by=1)){
        Somme ‹- Somme + i
    }
    print(Somme)

## [1] 15

Exemple

Comme pour une structure itérative de type Pour, la structure itérative Tant que permet d'exécuter une série d'instructions plusieurs fois. Dans l'exemple ci-dessous, l'algorithme exécute d'abord l'Instruction n°1. Puis l'Instruction n°2 est exécutée tant que la condition est vraie. Et pour finir, il exécute une seule fois l'Instruction n°3 :

    Début
    Instruction n°1
    Tant que ‹condition› faire
        Instruction n°2
    Fin du Tant que
    Instruction n°3
    Fin

En langage R, cet algorithme se traduit de la façon suivante :

    Instruction n°1
    while(condition){
        Instruction n°2
    }
    Instruction n°3

Remarque

Comme l'Instruction n°2 est répétée tant que la condition est vraie, il y a un risque de boucle infinie si la condition n'évolue pas au cours des itérations.
Dans une boucle Tant que, les instructions situées dans la boucle ne sont jamais exécutées si la condition n'est pas vraie au départ.
Le bloc Tant que peut contenir plusieurs instructions.
S'il n'y a qu'une instruction entre les accolades, alors celles-ci deviennent facultatives.

Exemple

L'exemple précédent qui permet d'afficher à l'écran les entiers de 1 à N, N étant un entier saisi par l'utilisateur peut également être traduit en utilisant la structure itérative Tant que. Le pseudo-code est le suivant :

    Début
    Affectation de N
    i ‹- 1
    Tant que (i ‹= N) faire
        Afficher i
        i ‹- i+1
    Fin du Tant que
    Fin

Pour la traduction en langage R, la valeur N = 4 est choisie :

    N ‹- 4
    i ‹- 1
    while (i ‹= N) {
        print(i)
        i ‹- i+1
    }

## [1] 1
## [1] 2
## [1] 3
## [1] 4

Exercice : Somme des entiers de 1 à N

Le pseudo-code suivant permet de calculer la somme des entiers de 1 à N en utilisant la structure itérative Tant que.

    Début
    Affectation de N
    Somme ‹- 0
    i ‹- 1
    Tant que (i‹=N) faire
        Somme ‹- Somme + i
        i ‹- i + 1
    Fin du Tant que
    Afficher Somme
    Fin

Traduire cet algorithme en langage R. On considèrera que N est égal à 5.

Corrigé

Traduction en langage R.

    N ‹- 5
    Somme ‹- 0
    i ‹- 1
    while(i‹=N){
        Somme ‹- Somme + i
        i ‹- i + 1
    }
    print(Somme)

## [1] 15

Remarque

Cet exemple est équivalent à celui utilisant la boucle for de l'exercice précédent.

Suite Structure algorithmiques et fonctions

Préambule : de l'algorithme au programme

Les opérateurs

Structures algorithmiques

Structures alternatives

Structures itératives

Fonctions

Exercices bilan

Structures itératives

Objectifs

Résumé

Exemple

Remarque

Exemple

Exercice : Somme des entiers de 1 à N

Corrigé+

Exemple

Remarque

Exemple

Exercice : Somme des entiers de 1 à N

Corrigé+

Remarque

Suite Structure algorithmiques et fonctions +

Corrigé

Corrigé

Suite Structure algorithmiques et fonctions