utilisation de l'extension ifconfig pour les exercices et les corrections

algorithmique/cours/algo.txt

@@ -269,7 +269,6 @@ Comment rendre un algorithme lisible
 - Le bon algorithme est structuré.
 - Le bon algorithme est indenté.
 
-
 Complexité d'un algorithme
 --------------------------
 
@@ -278,5 +277,10 @@ C'est utile pour pouvoir comparer des algorithmes.
 
 complexité
 
-	estimer la complexité d'un algorithme,
+	estimer la complexité d'un algorithme, c'est estimer le nombre de calculs qu'il utilise.
-  c'est-à-dire estimer le nombre de calculs qu'il utilise.
+
+Si f est la fonction caractérisant exactement le coût d’un algorithme et n
+la taille des données, on s’intéresse à la façon dont augment f(n) lorsque n augmente
+on va montrer que f(n) n'augmente pas plus vite qu’une autre fonction
+g(n). Du point de vue mathématique, on dit que la fonction f est dominée
+asymptotiquement par la fonction g ce qui se note f = O(g)

algorithmique/cours/annexes/exercices.txt

@@ -11,6 +11,10 @@ Première journée : Le langage Python
 | Recherche d’un mot dans une chaîne de caractères.    | On se limite ici à l’algorithme "naïf", en estimant sa complexité.     |
 +------------------------------------------------------+------------------------------------------------------------------------+
 
+.. ifconfig:: correction
+
+    bla bla bla
+
 
 Séance 1 : Un apercu des possibles utilisations de Python
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

algorithmique/cours/conf.py

@@ -29,9 +29,15 @@ import os
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 # ones.
 extensions = [
-    'sphinx.ext.pngmath',
+    'sphinx.ext.pngmath', 'sphinx.ext.ifconfig',
 ]
 
+# ajout des cours avec solution des exercices ou non
+def setup(app):
+    app.add_config_value('correction', False, 'env')
+
+correction = True
+
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']
 

algorithmique/cours/control.txt

@@ -1,8 +1,8 @@
-Les tructures de contrôle
+Les structures de contrôle
 ==========================
 
-L'instruction de saut conditionnel
+L'instruction de saut
-----------------------------------
+----------------------
 
 .. raw:: latex
 
@@ -53,9 +53,10 @@ Description générique d'une instruction de saut::
                dans le langage cible, car c'est le meilleur moyen d'aboutir à
                du **code spaghetti**.
 
-L'instruction de test
+L'instruction de branchement conditionnel
-~~~~~~~~~~~~~~~~~~~~~~
+------------------------------------------
 
+On appelle structure conditionnelle les instructions qui permettent de tester si une condition est vraie ou non.
 
 .. raw:: latex
 
@@ -81,13 +82,22 @@ L'instruction de test
     \end{algorithm}
 
 
-Les boucles
+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'à
 ~~~~~~~~~~~~~~~~~~~
 
@@ -137,3 +147,20 @@ La boucle tant que (while)
     \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}

algorithmique/cours/langage.txt

@@ -28,6 +28,8 @@ Un langage de programmation doit permettre :
 Approche historique et chronologique
 -------------------------------------
 
+- Lambda calcul (1930)
+- machines de Turing (1936)
 - début des langages vers les années 1950 (A0, Fortran(impératif),
   Lisp(impératif et fonctionnel), Cobol)
 - années 60 : Simula (classes), CPL (compilation séparée)

algorithmique/cours/modularite.txt

@@ -1,7 +1,6 @@
 Introduction à la modularité
 =============================
 
-
 Un langage de programmation doit permettre la programmation structurée.
 
 .. important:: La structuration et l'organisation modulaire sert à maintenir de grands programmes,

algorithmique/cours/programme.txt

@@ -45,6 +45,9 @@ Par exemple, la ligne suivante est une expression effectuant une addition::
 
     5 + 6
 
+Expressions à partir de types de base
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
 Autres exemples d'expressions :
 
 - 5 est une expression de type int
@@ -54,6 +57,142 @@ Autres exemples d'expressions :
 - print ('c') est une expression de type None
 - raw_input est une expression de type string
 
+Expressions à partir de types produits
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Les types construits permettent de structurer l’information.
+
+- les produits (n-uplets)
+
+.. code-block:: ocaml
+
+    # type complexe = float * float ;;
+
+- les produits nommés (enregistrements)
+
+.. code-block:: ocaml
+
+    # type adresse = { rue : string ; ville : string ; cp : int};;
+    # type fiche = {
+    nom : string ;
+    prenom : string ;
+    adresse : adresse ;
+    date naissance : int * int * int ;
+    tel fixe : string ;
+    portable : string
+    };;
+    # let v1 = { a = 1 ; b = false ; c = 'r'};;
+
+-  les sommes (constructeurs)
+
+.. code-block:: ocaml
+
+    # type couleur = Pique | Coeur | Carreau | Trefle;;
+    # let v = (Pique , Coeur);;
+    val v : couleur * couleur = (Pique , Coeur)
+
+.. code-block:: ocaml
+
+    type nombre =
+    Ent of int | Reel of float | Cplx of float × float
+    Ent, Reel, Cplx sont les constructeurs du type.
+
+On voit qu'une expression peut-être complexe, mais dans tous les cas une valeur
+est renvoyée.
+
+- les types séquences (listes)
+
+.. code-block:: ocaml
+
+    # 4::1::5::8::1::[];;
+    - : int list = [4 ;1 ;5 ;8 ;1]
+
+Algorithme de la longeur d'une liste
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. code-block:: ocaml
+
+    # let rec longueur l =
+    match l with
+    [] -> 0
+    | ::s -> 1 + (longueur s);;
+
+Cette fonction est prédéfinie en Ocaml : `List.length`
+
+Algorithme de tri par insertion
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Cet algorithme de tri suit de manière naturelle la structure récursive des
+listes. Soit l une liste à trier :
+- si l est vide alors elle est déjà triée
+- sinon, l est de la forme x::s et on trie récursivement la suite s et on obtient une liste triée s’
+  on insert x au bon endroit dans s’ et on obtient une liste triée
+
+Description de l'algorithme
+
+- la fonction inserer permet d’insérer un élément x dans une liste l
+- si la liste l est triée alors x est inséré au bon endroit
+
+.. code-block:: ocaml
+
+    # let rec inserer x l =
+    match l with
+    [] -> [x]
+    | y::s -> if x<=y then x::l else y::(inserer x s);;
+    val inserer : ’a -> ’a list -> ’a list
+    # inserer 5 [3 ;7 ;10];;
+    - : int list = [3 ; 5 ; 7 ; 10]
+
+Algorithme de tri rapide
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+soit une liste l à trier :
+
+- si l est vide alors elle est triée
+- sinon, choisir un élément p de la liste (le premier par exemple)
+  nommé le **pivot**
+- partager l en deux listes g et d contenant les autres éléments de l
+  qui sont plus petits (resp. plus grands) que la valeur du pivot p
+- trier récursivement g et d, on obtient deux listes g’ et d’ triées
+
+.. code-block:: ocaml
+    :caption: fonction de partage d'une liste
+
+    #let rec partage p l =
+    match l with
+    [] -> ([] , [])
+    |x::s -> let g,d = partage p s in
+    if x<=p then (x::g , d) else (g , x::d) ;;
+    val partage : ’a -> ’a list -> ’a list * ’a list = <fun>
+    # partage 5 [1 ;9 ;7 ;3 ;2 ;4];;
+    - : int list * int list = ([1 ; 3 ; 2 ; 4], [9 ; 7])
+
+.. code-block:: ocaml
+    :caption: algorithme de tri rapide
+
+    # let rec tri rapide l =
+    match l with
+    [] -> []
+    | p::s -> let g , d = partage p s in
+    (tri rapide g)@[p]@(tri rapide d) ;;
+    val tri rapide : ’a list -> ’a list = <fun>
+    # tri rapide [5 ; 1 ; 9 ; 7 ; 3 ; 2 ; 4];;
+    - : int list = [1 ; 2 ; 3 ; 4 ; 5 ; 7 ; 9]
+
+
+Les listes chaînées
+~~~~~~~~~~~~~~~~~~~~
+
+.. code-block:: ocaml
+
+    typedef struct list{
+    int elt ;
+    struct list* suivant ;
+    } ;
+
+Les déclarations
+-----------------
+
 Un autre exemple d'expression :
 
 .. raw:: latex
@@ -83,12 +222,6 @@ Un autre exemple d'expression :
     \end{algorithmic}
     \end{algorithm}
 
-On voit qu'une expression peut-être complexe, dans tous les cas une valeur
-est renvoyée.
-
-Les déclarations
------------------
-
 Exemple de déclarations :
 
 - `a = 1`
@@ -173,8 +306,8 @@ Exemples dans la langue française :
 
 Voir aussi :
 
-- Déclarations de types primitifs et conversions de type
+- Les déclarations de types primitifs et conversions de type
-- Types de base::
+- Les types de base::
 
         Octets (8 bits) byte
         Entiers courts (16 bits) short
@@ -200,8 +333,8 @@ Il est possible de communiquer de la manière suivante avec un programme :
 - lire du texte ou un nombre
 - manipuler les prompts
 
-La REPL
+La REPL (boucle d'interaction)
---------
+-------------------------------
 
 .. glossary::
 
@@ -228,6 +361,7 @@ Le prompt python::
       >>> dir()
       ['__builtins__', '__doc__', '__name__', readline', 'rlcompleter']
       >>>
+
 Le prompt ipython::
 
     Python 2.7.12 (default, Nov 19 2016, 06:48:10)
@@ -247,3 +381,9 @@ Le prompt OCaml (utop)::
 
         ─( 09:21:24 )─< command 0 >──
         utop #
+        # let x = 1 in x + 2;;
+        - : int = 3
+        # let y = 1 + 2;;
+        val y : int = 3
+        # y * y;;
+        - : int = 9