From 05e68b4d5ef687008bacd24b177d9825d5764ac3 Mon Sep 17 00:00:00 2001 From: gwen Date: Tue, 17 Oct 2017 16:23:38 +0200 Subject: [PATCH] =?UTF-8?q?algo=20avanc=C3=A9e?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- algo/AlgoApprofondie/cours/donnees.txt | 80 ++++++++- algo/AlgoApprofondie/cours/fonctions.txt | 14 ++ algo/tronCommun/fonctions.txt | 14 +- algo/tronCommun/programme.txt | 216 ++++++++++++++--------- 4 files changed, 238 insertions(+), 86 deletions(-) diff --git a/algo/AlgoApprofondie/cours/donnees.txt b/algo/AlgoApprofondie/cours/donnees.txt index 96507b8..109ae9b 100644 --- a/algo/AlgoApprofondie/cours/donnees.txt +++ b/algo/AlgoApprofondie/cours/donnees.txt @@ -468,6 +468,7 @@ Les piles - FIFO : "first in first out" + Traduction d'une structure de données dans une autre ----------------------------------------------------- @@ -730,8 +731,10 @@ On les appelle enregistrements, dictionnaires ou tables de hachage. -- les types sommes (constructeurs) : modélisation de domaines finis +les types sommes +~~~~~~~~~~~~~~~~ +appelés aussi type construits, ou types algébriques .. code-block:: ocaml @@ -748,12 +751,83 @@ On les appelle enregistrements, dictionnaires ou tables de hachage. Ent of int | Reel of float | Cplx of float × float Ent, Reel, Cplx sont les constructeurs du type. +Les arbres +---------- + +Structure de données construite sur un type somme récursif. + +arbre binaire : + +.. code-block:: ocaml + + type arbre = Vide | Noeud of int * arbre * arbre + let a = + Noeud(10, + Noeud(2,Noeud(8,Vide,Vide),Vide), + Noeud(5,Noeud(11,Vide,Vide),Noeud(3,Vide,Vide)));; + +arbre binaire polymorphe : + + +.. code-block:: ocaml + + type ’a arbre = Vide | Noeud of ’a * ’a arbre * ’a arbre;; + let b = Noeud(10,Noeud(5,Vide,Vide),Vide);; + let c = Noeud(’f’,Vide,Noeud(’a’,Vide,Noeud(’g’,Vide,Vide)));; + +- parcours d’un arbre binaire +- itérateurs sur un arbre binaire +- taille d'un arbre + +arbre n-aire:: + + type ’a arbre = Vide | Noeud of ’a * ’a arbre list;; + +- transformation d'un arbre en un autre +- arbre ordonné (arbre de recherche) +- équilibrage des arbres de recherche + + +Un arbre binaire est ordonné (ou de recherche) par rapport à une relation +d’ordre quelconque si : + +- c’est l’arbre vide (Vide) +- c’est un arbre non-vide Noeud(x,g,d) et + +1. les éléments du sous-arbre gauche g sont inférieurs à la racine x +2. la racine x est inférieure aux éléments du sous-arbre droit d +3. les sous-arbres g et d sont eux-mêmes ordonnés + +:: + + let a1 = + Noeud(5, Noeud(2, Vide, Vide), + Noeud(20, Noeud(10, Noeud(6, Vide, Vide), + Noeud(14,Vide, Vide)), + Noeud(21,Vide,Vide)));; + +.. image:: _static/AbreOrdonne.png + +Recherche d'un élément dans un arbre ordonné +--------------------------------------------- + +La structure ordonnée des arbres binaires de recherche permet d’effectuer +la recherche d’un élément avec une compléxité en moyenne de O(log n) + +:: + + let rec recherche elt abr = + match abr with + | Vide -> false + | Noeud (x,_,_) when x = elt -> true + | Noeud (x,g,_) when elt < x -> recherche elt g + | Noeud (_,_,d) -> recherche elt d + ;; + Autres structures de données complexes ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -- arbres - graphes - dates - - le parcours de graphes - les calculs de dates diff --git a/algo/AlgoApprofondie/cours/fonctions.txt b/algo/AlgoApprofondie/cours/fonctions.txt index 90340ae..0ac871c 100644 --- a/algo/AlgoApprofondie/cours/fonctions.txt +++ b/algo/AlgoApprofondie/cours/fonctions.txt @@ -3,6 +3,20 @@ Définitions par filtrage -------------------------- +:: + + type formule = Vrai | Faux | Conjonction of formule * formule + + +le fitrage permet un examen par cas sur les valeurs construites:: + + let rec evalue = function + | Vrai -> true + | Faux -> false + | Conjonction (Faux, _) | Conjonction (_, Faux) -> false + | Conjonction (f1, f2) -> evalue f1 && evalue f2;; + + Lorsqu'un argument est passé à un ensemble de clauses : - la première clause qui filtre l'argument est exécutée, les autres sont diff --git a/algo/tronCommun/fonctions.txt b/algo/tronCommun/fonctions.txt index 316477a..5e1c12b 100644 --- a/algo/tronCommun/fonctions.txt +++ b/algo/tronCommun/fonctions.txt @@ -69,6 +69,9 @@ Description d'une procédure En programmation impérative, un programme est une suite d’instructions qui font évoluer l’état mémoire, le résultat est dans l’état final de la mémoire. +Une procédure n'est rien d'autre qu'une fonction dont le résultat est de +type unit + - une procédure peut prendre des paramètres - elle modifie l'état courant du système @@ -329,7 +332,16 @@ en cours d'exécution ni ne réalise d'effets de bord. Elle renvoie En programmation fonctionnelle, programme est un ensemble de définitions de fonctions, un résultat est l'application d’une fonction à une structure de données effective. -- composant de base : la fonction +Les fonctions en programmation fonctionelles vont en réalité beaucoup plus loin, justifiant +le nom de programmation fonctionnelle. + +- elles sont des valeurs de première classe c'est-à-dire des valeurs pouvant être créées par des calculs, + passées en argument à des + fonctions ou retournées, comme n'importe quelles autres valeurs. +- une fonction peut être une expression comme une autre, alors anonyme +- une application partielle peut être définie (curryfication) + +- base : la fonction - opération de base : l’application .. raw:: latex diff --git a/algo/tronCommun/programme.txt b/algo/tronCommun/programme.txt index b7eeee1..0197190 100644 --- a/algo/tronCommun/programme.txt +++ b/algo/tronCommun/programme.txt @@ -32,93 +32,21 @@ programme : 2. communiquer avec des fichiers, 3. communiquer avec d'autres programmes. -Les expressions ----------------- - -expression - - Une expression est une valeur caculée du langage, une opération arithmétique - qui retourne une valeur (entier, texte, valeur logique...). - C'est donc une suite sémantiquement correcte de **valeurs de base** et **d'opérateurs** - -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 -- 4.5 est une expression de type float -- 'c' est une expression de type char -- true est une expression de type bool -- print ('c') est une expression de type None -- raw_input est une expression de type string - -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. - - -.. ifconfig:: exercice - - **Exercice** : - Le parenthésage et les opérateurs booléens:: - - Variables A, B, C, D, E en Booléen - Variable X en Entier - Début - Lire X - A <- X > 12 - B <- X > 2 - C <- X < 6 - D <- (A ET B) OU C - E <- A ET (B OU C) - Ecrire D, E - Fin - - **Que valent D et E si X = 3 ?** - - -.. ifconfig:: correction - - **Correction** : D sera VRAI alors que E sera FAUX - - - - Les déclarations ----------------- -Un autre exemple d'expression : +déclarations. affectations par valeur ? par référence ? Bien faire la +différence entre les deux. -.. raw:: latex +**déclaration par référence** + +.. code-block:: ocaml + + let x = ref 1;; + print_int !x;; + x := !x + 1;; + print_int !x;; - \begin{algorithm} - \caption{Exemple d'expression} - \begin{algorithmic}[1] - \BState \emph{sortie}: $l$ \Comment{C'est l'expression calculée renvoyée} - \ForAll {$v \in V(G)$} - \State $l(v) \leftarrow \infty$ - \EndFor - \State $l(u) \leftarrow 0$ - \Repeat - \For {$i \leftarrow 1, n$} - \State $min \leftarrow l(v_i)$ - \For {$j \leftarrow 1, n$} - \If {$min > e(v_i, v_j) + l(v_j)$} - \State $min \leftarrow e(v_i, v_j) + l(v_j)$ - \State $p(i) \leftarrow v_j$ - \EndIf - \EndFor - \State $l(i) \leftarrow min$ - \EndFor - \State $changed \leftarrow l \not= l’$ - \State $l \leftarrow l$ - \Until{$\neg changed$} - \end{algorithmic} - \end{algorithm} Exemple de déclarations : @@ -341,6 +269,122 @@ Exercices : algorithmes sur les affectations >>> c '42312' +Les expressions +---------------- + +expression + + Une expression est une valeur caculée du langage, une opération arithmétique + qui retourne une valeur (entier, texte, valeur logique...). + C'est donc une suite sémantiquement correcte de **valeurs de base** et **d'opérateurs** + +Par exemple, la ligne suivante est une expression effectuant une addition:: + + 5 + 6 + +La séquence s'écrit avec le traditionnel point-virgule, comme +dans:: + + x := 1; 2 + !x + +expression séquentielle:: + + 3 * (x := 1; 2 + !x) + + +Un autre exemple d'expression : + +.. raw:: latex + + \begin{algorithm} + \caption{Exemple d'expression} + \begin{algorithmic}[1] + \BState \emph{sortie}: $l$ \Comment{C'est l'expression calculée renvoyée} + \ForAll {$v \in V(G)$} + \State $l(v) \leftarrow \infty$ + \EndFor + \State $l(u) \leftarrow 0$ + \Repeat + \For {$i \leftarrow 1, n$} + \State $min \leftarrow l(v_i)$ + \For {$j \leftarrow 1, n$} + \If {$min > e(v_i, v_j) + l(v_j)$} + \State $min \leftarrow e(v_i, v_j) + l(v_j)$ + \State $p(i) \leftarrow v_j$ + \EndIf + \EndFor + \State $l(i) \leftarrow min$ + \EndFor + \State $changed \leftarrow l \not= l’$ + \State $l \leftarrow l$ + \Until{$\neg changed$} + \end{algorithmic} + \end{algorithm} +Expressions à partir de types de base +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Autres exemples d'expressions : + +- 5 est une expression de type int +- 4.5 est une expression de type float +- 'c' est une expression de type char +- true est une expression de type bool +- print ('c') est une expression de type None +- raw_input est une expression de type string + +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. + + +.. ifconfig:: exercice + + **Exercice** : + Le parenthésage et les opérateurs booléens:: + + Variables A, B, C, D, E en Booléen + Variable X en Entier + Début + Lire X + A <- X > 12 + B <- X > 2 + C <- X < 6 + D <- (A ET B) OU C + E <- A ET (B OU C) + Ecrire D, E + Fin + + **Que valent D et E si X = 3 ?** + + +.. ifconfig:: correction + + **Correction** : D sera VRAI alors que E sera FAUX + +Les instructions +---------------- + +Dans les langages impératifs, expressions et instructions sont deux catégories syntaxiques bien distinctes : une +conditionnelle, if-then-else ou une boucle for n'est pas acceptée en position d'expression, et +inversement certaines expressions ne sont pas autorisées en position d'instruction. + +En OCaml , il n'y a pas de telle distinction expression/instruction : il n'y a +que des expressions. Ainsi on peut écrire:: + + 1 + (if x = 0 then 2 else 3) + + +exemple d'expression de base:: + + # let x = 5;; + val x : int = 5 + # 1 + (if (x == 0) then 3 else 6);; + - : int = 7 + +exemple de présence d'instruction dans notre expression de base:: + + # 1 + (if (x == 0) then (let b=5 in b) else (let a=2 in a));; + - : int = 3 + Interaction avec l'utilisateur ------------------------------ @@ -379,6 +423,14 @@ Il est possible de communiquer de la manière suivante avec un programme : print("bonjour, je m'appelle " + prenom.capitalize()) + +Pour résumer en ocaml, nous avons vu + +- qu'un programme est une suite d'expressions et de déclarations ; +- que les variables introduites par le mot clé let ne sont pas modifiables ; +- qu'il n'y a pas de distinction entre expressions et instructions. + + La REPL (boucle d'interaction) -------------------------------