Begin'R
Les statistiques avec R
Navigation
[Retour au sommaire]
# Structures itératives :Objectifs Connaitre les structures itératives <style> div.pseudocode pre.r { background-color:#EEEEEE; } </style> 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](#Presentation_pour) | [Exemple](#example_pour) | [ici](#exo_pour) | | Tant que |while | [Présentation](#Presentation_while) | [Exemple](#example_while) | [ici](#exo_while) | :Exemple {#Presentation_pour, toggle=popup} 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 : <div class = "pseudocode"> ```r 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 ``` </div> Et en langage R, cet algorithme se traduit de la façon suivante : ```r 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{#remarque_seq} * 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 {#example_pour, toggle=popup} 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 : <div class = "pseudocode"> ```r Début Affectation de N Pour i allant de 1 à N par pas de 1 faire Afficher i Fin du Pour Fin ``` </div> Pour la traduction en langage R, la valeur `N = 4` est choisie : ```r 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 {#exo_pour, toggle=popup} * Le pseudo-code suivant permet de calculer la somme des entiers de `1` à `N` en utilisant la structure itérative `Pour`. <div class = "pseudocode"> ```r 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 ``` </div> * Traduire cet algorithme en langage R et le tester pour `N = 5`. :Corrigé{#corrige_pour, toggle=collapse, title-display=show} * Traduction en langage R. ```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 {#Presentation_while, toggle=popup} 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` : <div class = "pseudocode"> ```r Début Instruction n°1 Tant que <condition> faire Instruction n°2 Fin du Tant que Instruction n°3 Fin ``` </div> En langage R, cet algorithme se traduit de la façon suivante : ```r Instruction n°1 while(condition){ Instruction n°2 } Instruction n°3 ``` :Remarque{#remarque_tantque} * 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 {#example_while, toggle=popup} 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 : <div class = "pseudocode"> ```r Début Affectation de N i <- 1 Tant que (i <= N) faire Afficher i i <- i+1 Fin du Tant que Fin ``` </div> Pour la traduction en langage R, la valeur `N = 4` est choisie : ```r 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 {#exo_while, toggle=popup} * Le pseudo-code suivant permet de calculer la somme des entiers de `1` à `N` en utilisant la structure itérative `Tant que`. <div class = "pseudocode"> ```r 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 ``` </div> * Traduire cet algorithme en langage R. On considèrera que `N` est égal à `5`. :Corrigé{#corrige_tantque, toggle=collapse, title-display=show} * Traduction en langage R. ```r N <- 5 Somme <- 0 i <- 1 while(i<=N){ Somme <- Somme + i i <- i + 1 } print(Somme) ``` ``` ## [1] 15 ``` :Remarque{#remarque_tantque} Cet exemple est équivalent à celui utilisant la boucle `for` de l'exercice précédent. :Suite Structure algorithmiques et fonctions {#algo, toggle=collapse, title-display=hidden} [Préambule : de l'algorithme au programme](caps_algo_1_de_l_algo_au_programme.html) [Les opérateurs](caps_algo_2_operateurs.html) [Structures algorithmiques](caps_algo_3_structures_algorithmiques.html) [Structures alternatives](caps_algo_4_structures_test.html) [Structures itératives](caps_algo_5_structures_iteratives.html) [Fonctions](caps_algo_6_fonctions.html) [Exercices bilan](caps_algo_7_exercice_bilan_programmation_R.html)
