algo avancée
This commit is contained in:
gwen
parent
2ed2488a47
commit
1d4ba95e00
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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)
|
||||
-------------------------------
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user