formations/algorithmique/cours/control.txt

Les structures de contrôle
==========================

L'instruction de saut
----------------------

.. raw:: latex

   \begin{algorithm}
   \caption{Exemple de saut conditionnel}\label{saut}
   \begin{algorithmic}[1]
   \Procedure{Euclide}{} \Comment{c'est l'algorithme d'Euclide}
   \State $\textit{stringlen} \gets \text{length of }\textit{string}$
   \State $i \gets \textit{patlen}$
   \BState \emph{top}:
   \If {$i > \textit{stringlen}$} \Return false
   \EndIf
   \State $j \gets \textit{patlen}$
   \BState \emph{loop}: \Comment{C'est le label (l'étiquette)} \label{etiquette}
   \If {$\textit{string}(i) = \textit{path}(j)$}
   \State $j \gets j-1$.
   \State $i \gets i-1$.
   \State \textbf{goto} \emph{loop}. \label{goto}
   \State \textbf{close};
   \EndIf
   \State $i \gets
   i+\max(\textit{delta}_1(\textit{string}(i)),\textit{delta}_2(j))$.
   \State \textbf{goto} \emph{top}. \Comment{C'est l'instruction de saut}
   \EndProcedure
   \end{algorithmic}
   \end{algorithm}


.. raw:: latex

    Ligne \ref{etiquette}, le bloc `loop` est aussi un label (une étiquette),
    c'est-à-dire une marque posée qu'il est possible de retrouver dans le programme. \\

.. raw:: latex

    Ligne \ref{goto}, l'instruction \texttt{goto} (aller à ) est le saut vers le label. \\

Description générique d'une instruction de saut::

  Instruction 1
  Saut Label1
  Instruction 2
  ...
  Label1:
    Instruction n

.. important:: les sauts conditionnels sont à éviter, même s'ils sont implémentés
               dans le langage cible, car c'est le meilleur moyen d'aboutir à
               du **code spaghetti**.

L'instruction de branchement conditionnel
------------------------------------------

On appelle structure conditionnelle les instructions qui permettent de tester si une condition est vraie ou non.

.. raw:: latex

    \begin{algorithm}
    \caption{Exemple d'instruction de test}
    \begin{algorithmic}[1]
    \BState \emph{entrée}: $quality\gets 0$ \Comment{C'est cette valeur qui sera testée}
    \BState \emph{locale}: $a\gets ""$
    \BState \emph{sortie}: $a$ \Comment{La sortie est la valeur de $a$}
    \BState \emph{corps}:
    \If{$quality\ge 9$}
    \State $a\gets perfect$
    \ElsIf{$quality\ge 7$}
    \State $a\gets good$
    \ElsIf{$quality\ge 5$}
    \State $a\gets medium$
    \ElsIf{$quality\ge 3$}
    \State $a\gets bad$
    \Else
    \State $a\gets unusable$
    \EndIf
    \end{algorithmic}
    \end{algorithm}


L'instruction switch
--------------------

L'instruction switch permet de faire plusieurs tests de valeurs sur le contenu d'une même variable.
Ce branchement conditionnel simplifie beaucoup le test de plusieurs valeurs d'une variable.

Les instructions d'itérations (boucles)
---------------------------------------

.. important:: Toutes les boucles concernent le paradigme de programmation impératif
               et ne sont pas valides dans le paradigme de programmation fonctionnel
               (puisque l'ordre d'évaluation importe)

- arrêt conditionnel (break)
- passage d'un pas (continue)

Répéter ... jusqu'à
~~~~~~~~~~~~~~~~~~~

.. raw:: latex

   \begin{algorithm}
    \caption{Exemple de répéter ... jusqu'à}
   \begin{algorithmic}[1]
   \Require $i \gets 1$ \Comment{déclaration et initialisation de i}
   \Statex
   \Repeat \Comment{c'est le label de début du répéter}
   \State $i \gets \textit{i+1}$
   \Until{i == 100} \Comment{condition de fin de la boucle}
   \end{algorithmic}
   \end{algorithm}

La boucle **pour** (for)
~~~~~~~~~~~~~~~~~~~~~~~~

.. raw:: latex

    \begin{algorithm}
    \caption{Exemple de boucle for}
    \begin{algorithmic}[1]
    \Require  $sum\gets 0$
    \Statex
    \For{$i\gets 1, n$}
    \State $sum\gets sum+i$
    \EndFor
    \end{algorithmic}
    \end{algorithm}

La boucle tant que (while)
~~~~~~~~~~~~~~~~~~~~~~~~~~

.. raw:: latex

    \begin{algorithm}
    \caption{Exemple de boucle while}
    \begin{algorithmic}[1]
    \Require $sum\gets 0$
    \Statex
    \State $i\gets 1$
    \While{$i\le n$}
    \State $sum\gets sum+i$
    \State $i\gets i+1$
    \EndWhile
    \end{algorithmic}
    \end{algorithm}

Et les autres boucles : répéter... jusqu'à, etc...

.. raw:: latex

    \begin{algorithm}
    \caption{Exemple de boucle répéter}

    \begin{algorithmic}[1]
    \State $sum\gets 0$
    \State $i\gets 1$
    \Repeat
    \State $sum\gets sum+i$
    \State $i\gets i+1$
    \Until{$i>n$}
    \end{algorithmic}
    \end{algorithm}