Begin'R

Navigation

# Structures algorithmiques
    
    
    :Objectifs
    
        Connaitre les structures algorithmiques de base
        
    
<style>
div.pseudocode pre.r { background-color:#EEEEEE; }
</style>

Il existe deux grands types de structure de contrôle :

* les [structures alternatives](caps_algo_4_structures_test.html) qui permettent d'exécuter une série d'instructions si une condition est vérifiée.

* les [structures itératives](caps_algo_5_structures_iteratives.html) qui permettent de répéter plusieurs fois une série d'instructions.

Ces structures de contrôle sont basées sur des concepts très similaires. Un ensemble d'instructions est exécuté ou répété selon le résultat d'une condition. Ces structures sont composées de mots clés (`if`, `else`, `while`, ...), des éléments de contrôle (condition) et de texte.

## Présentation générale d'une structure de contrôle : exemple de la structure de test
    
    Afin de se familariser avec les structures de contrôle, l'exemple ci-dessous détaille le cas d'utilisation de la structure de test. Lorsque la `condition` est vraie, l'algorithme exécutera l'`Instruction n°1` puis l'`Instruction n°2`. Et si la `condition` est fausse, l'algorithme exécutera uniquement l'`Instruction n°2` :
    
    <div class = "pseudocode">
        
    
    ```r
        Début
            Si <condition> Alors
                Instruction n°1
            Fin du Si
            Instruction n°2
        Fin
    ```
    
    </div>
    
    Et en langage R, cet algorithme se traduit de la façon suivante :
    
    ```r
        if(condition){
            Instruction n°1
        }
        Instruction n°2
    ```
    
    :Remarque {#remarquesi}
        
        * Les accolades peuvent contenir plusieurs instructions.
        
        * S'il n'y a qu'une instruction entre les accolades, alors celles-ci deviennent facultatives.
        
    
    
    :Exemple : Afficher la valeur absolue d'un nombre {#example_si1, toggle=collapse, title-display=show}
        
        
        L'algorithme suivant permet de calculer et d'afficher la valeur absolue d'un réel `N` saisi par l'utilisateur :
        
        <div class = "pseudocode">
        
        
        ```r
            Début
                Affectation de N
                Si (N < 0) Alors
                    N <- -N
                Fin du Si
                Afficher N
            Fin
        ```
        
        </div>
        
        Pour la traduction en langage R, la valeur `N = -3` est choisie :
        
        ```r
            N <- -3
            if(N < 0){
                N <- -N
            }
            print(N)
        ```
        
        ```
        ## [1] 3
        ```
        
        :Remarque{#remarque_abs1}
            
            Le calcul de la valeur absolue aurait également pu se faire en utilisant la fonction **`abs()`**. Cela n'aurait donc pas nécessité d'utiliser la structure alternative `Si`. L'instruction `abs(N)` retourne la valeur absolue de `N`.
            
: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)