algo avancée

This commit is contained in:
gwen 2017-10-17 16:23:38 +02:00 committed by Benjamin Bohard
parent 2ed2488a47
commit 1d4ba95e00
4 changed files with 238 additions and 86 deletions

View File

@ -468,6 +468,7 @@ Les piles
- FIFO : "first in first out" - FIFO : "first in first out"
Traduction d'une structure de données dans une autre 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 .. 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 of int | Reel of float | Cplx of float × float
Ent, Reel, Cplx sont les constructeurs du type. 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 dun 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
dordre quelconque si :
- cest larbre vide (Vide)
- cest 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 deffectuer
la recherche dun é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 Autres structures de données complexes
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- arbres
- graphes - graphes
- dates - dates
- le parcours de graphes - le parcours de graphes
- les calculs de dates - les calculs de dates

View File

@ -3,6 +3,20 @@
Définitions par filtrage 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 : Lorsqu'un argument est passé à un ensemble de clauses :
- la première clause qui filtre l'argument est exécutée, les autres sont - la première clause qui filtre l'argument est exécutée, les autres sont

View File

@ -69,6 +69,9 @@ Description d'une procédure
En programmation impérative, un programme est une suite dinstructions qui font En programmation impérative, un programme est une suite dinstructions qui font
évoluer létat mémoire, le résultat est dans létat final de la mémoire. é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 - une procédure peut prendre des paramètres
- elle modifie l'état courant du système - 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, En programmation fonctionnelle, programme est un ensemble de définitions de fonctions,
un résultat est l'application dune fonction à une structure de données effective. un résultat est l'application dune 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 : lapplication - opération de base : lapplication
.. raw:: latex .. raw:: latex

View File

@ -32,93 +32,21 @@ programme :
2. communiquer avec des fichiers, 2. communiquer avec des fichiers,
3. communiquer avec d'autres programmes. 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 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 : Exemple de déclarations :
@ -341,6 +269,122 @@ Exercices : algorithmes sur les affectations
>>> c >>> c
'42312' '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 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()) 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) La REPL (boucle d'interaction)
------------------------------- -------------------------------