structures de données

algorithmique/cours/donnees.txt

@@ -30,8 +30,6 @@ Structures de données complexes
 - le parcours de graphes
 - les calculs de dates
 
-
-
 + **Récursivité**
 
     On en présente les avantages et les inconvénients.
@@ -43,3 +41,147 @@ Structures de données complexes
 
     On étudie et on compare ces algorithmes de tri du point de vue des complexités temporelles dans le meilleur et dans le
     pire cas.
+
+Les 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 longueur 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`
+
+
+Algorithmes de tri
+~~~~~~~~~~~~~~~~~~~
+
+On désigne par "tri" l'opération consistant à ordonner un ensemble d'éléments en fonction de clés sur lesquelles est définie une relation d'ordre.
+
+Les algorithmes de tri ont une grande importance pratique.
+Ils sont fondamentaux dans certains domaines (exemples : map-reduce en database non relationnelle).
+
+L'étude du tri est également intéressante en elle-même, c'est un des domaines de l'algorithmique très étudié et connu.
+
+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 ;
+    } ;

algorithmique/cours/fonctions.txt

@@ -223,7 +223,7 @@ curryfication
 
     let g = function n -> (function p -> p + 1) n;;
 
-typage d'une fonction
+Typage d'une fonction
 ~~~~~~~~~~~~~~~~~~~~~
 
 .. code-block:: ocaml
@@ -253,7 +253,7 @@ les fonctions sont des valeurs comme les autres
     # fun x -> x * x;;
     - : int -> int = <fun>
 
-récursivité
+Récursivité
 ~~~~~~~~~~~~
 
 .. code-block:: ocaml

algorithmique/cours/modularite.txt

@@ -57,8 +57,8 @@ Il y a dualité entre ces deux modèles.
 **La combinaison des deux paradigmes offre de nouvelles extensibilités pour les
 traitements et les données.**
 
-Structuration et sûreté d'exécution
+Sûreté d'exécution
------------------------------------
+--------------------
 
 La programmation raisonnée
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -184,8 +184,10 @@ sprint. Un sprint aboutit toujours sur la livraison d'un produit partiel fonctio
 temps, le facilitateur a la charge de réduire au maximum les perturbations extérieures et de
 résoudre les problèmes non techniques de l'équipe.
 
-Conception descendante d'un programme
+Conception descendante
--------------------------------------
+-----------------------
+
+Une vision **centripète** : du général au particulier.
 
 Il s'agit d'une méthode de résolution d'un problème. On le découpe en tâches
 de plus en plus fines, de plus en plus détaillées, qui aboutiront au programme final.

algorithmique/cours/programme.txt

@@ -57,149 +57,8 @@ 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 expressions se complexifient avec la complexification des données et des traitements,
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+mais le principe de l'expressivité d'un langage reste le même.
-
-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`
-
-
-Algorithmes de tri
-~~~~~~~~~~~~~~~~~~~
-
-On désigne par "tri" l'opération consistant à ordonner un ensemble d'éléments en fonction de clés sur lesquelles est définie une relation d'ordre.
-
-Les algorithmes de tri ont une grande importance pratique.
-Ils sont fondamentaux dans certains domaines (exemples : map-reduce en database non relationnelle).
-
-L'étude du tri est également intéressante en elle-même, c'est un des domaines de l'algorithmique très étudié et connu.
-
-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
 -----------------