Skip to content
Snippets Groups Projects
Commit f28dcb3f authored by COQUERY EMMANUEL's avatar COQUERY EMMANUEL
Browse files

MAJ séance 2/3

parent 64f92ce1
No related branches found
No related tags found
No related merge requests found
...@@ -8,28 +8,28 @@ ...@@ -8,28 +8,28 @@
(2024) indique qu'il s'agit des supports de l'an dernier qui sont à mettre à jour (2024) indique qu'il s'agit des supports de l'an dernier qui sont à mettre à jour
| jour | heure | type | sujet | supports / remarques | | jour | heure | type | sujet | supports / remarques |
| ----- | ------------- | ---------- | --------------------------- | ------------------------------------------------------------------------------- | | ----- | ------------- | ---------- | --------------------------- | ------------------------------------------------------------------------------ |
| 20/01 | 8h | CM1 | Intro & Lambda-Calcul | [Diapositives Intro](cm/lifpf-cm0.pdf), [Diapositives Cours](cm/lifpf-cm1.pdf) | | 20/01 | 8h | CM1 | Intro & Lambda-Calcul | [Diapositives Intro](cm/lifpf-cm0.pdf), [Diapositives Cours](cm/lifpf-cm1.pdf) |
| | 9h45 | TD1 sauf B | Lambda-Calcul | [Sujet](td/lifpf-td1-enonce.pdf), [corrigé](td/lifpf-td1-correction.pdf) | | | 9h45 | TD1 sauf B | Lambda-Calcul | [Sujet](td/lifpf-td1-enonce.pdf), [corrigé](td/lifpf-td1-correction.pdf) |
| | 11h30 | TD1 Grp B | | | | | 11h30 | TD1 Grp B | | |
| 27/01 | 8h | CM2 | OCaml | (2024) [Diapositives](cm/lifpf-cm2.pdf), [Script démos](cm/cm2-demo.md) | | 27/01 | 8h | CM2 | OCaml | [Diapositives](cm/lifpf-cm2.pdf), [Script démos](cm/cm2-demo.md) |
| | 9h45 ou 11h30 | TP1 | Prise en main | (2024) [Sujet](tp/tp1.md), [corrigé](tp/tp1.ml) | | | 9h45 ou 11h30 | TP1 | Prise en main | [Sujet](tp/tp1.md), [corrigé](tp/tp1.ml) |
| 03/02 | 8h | TD2 | Lambda-Calcul | (2024) [Sujet](td/lifpf-td2-enonce.pdf), [corrigé](td/lifpf-td2-correction.pdf) | | 03/02 | 8h | TD2 | Lambda-Calcul | [Sujet](td/lifpf-td2-enonce.pdf) |
| | 9h45 ou 11h30 | TP2 | Listes | (2024) [Sujet](tp/tp2.md), [corrigé](tp/tp2.ml) | | | 9h45 ou 11h30 | TP2 | Listes | [Sujet](tp/tp2.md) |
| 10/02 | 8h | CM3 | Struct. ind. + types param. | (2024) [Diapositives](cm/lifpf-cm3.pdf) | | 10/02 | 8h | CM3 | Struct. ind. + types param. | (2024) [Diapositives](cm/lifpf-cm3.pdf) |
| | 9h45 ou 11h30 | TP3 | Arbres | (2024) [Sujet](tp/tp3.md), [corrigé](tp/tp3.ml) | | | 9h45 ou 11h30 | TP3 | Arbres | (2024) [Sujet](tp/tp3.md) |
| 17/02 | 8h | TD3 | Arbres | (2024) [Sujet](td/lifpf-td3-enonce.pdf), [corrigé](td/lifpf-td3-correction.pdf) | | 17/02 | 8h | TD3 | Arbres | (2024) [Sujet](td/lifpf-td3-enonce.pdf) |
| | 9h45 ou 11h30 | TP4 | Arbres génériques | (2024) [Sujet](tp/tp4.md), [corrigé](tp/tp4.ml) | | | 9h45 ou 11h30 | TP4 | Arbres génériques | (2024) [Sujet](tp/tp4.md) |
| 10/03 | 8h | CM4 | Ordre sup. | (2024) [Diapositives](cm/lifpf-cm4.pdf) | | 10/03 | 8h | CM4 | Ordre sup. | (2024) [Diapositives](cm/lifpf-cm4.pdf) |
| | 9h45 | TD4 | Ordre sup. | (2024) [Sujet](td/lifpf-td4-enonce.pdf), [corrigé](td/lifpf-td4-correction.pdf) | | | 9h45 | TD4 | Ordre sup. | (2024) [Sujet](td/lifpf-td4-enonce.pdf) |
| 17/03 | 8h | CM5 | Modules | (2024) [Diapositives](cm/lifpf-cm5.pdf) | | 17/03 | 8h | CM5 | Modules | (2024) [Diapositives](cm/lifpf-cm5.pdf) |
| | 9h45 ou 11h30 | TP5 | Struct. gen. | (2024) [Sujet](tp/tp5.md), [corrigé de l'exercice 1](tp/tp5.ml) | | | 9h45 ou 11h30 | TP5 | Struct. gen. | (2024) [Sujet](tp/tp5.md) |
| 24/03 | 8h | TD5 | Ordre sup. | (2024) [Sujet](td/lifpf-td5-enonce.pdf), [corrigé](td/lifpf-td5-correction.pdf) | | 24/03 | 8h | TD5 | Ordre sup. | (2024) [Sujet](td/lifpf-td5-enonce.pdf) |
| | 9h45 ou 11h30 | TP6 | Transf. struct. | (2024) [Sujet](tp/tp6.md), corrigés dans les TD/TPs référencés dans le sujet | | | 9h45 ou 11h30 | TP6 | Transf. struct. | (2024) [Sujet](tp/tp6.md) |
| 31/03 | 9h45 ou 11h15 | TP7 | App. OCaml (à changer ?) | (2024) [Sujet](tp/tp7.md), [corrigé](tp/tp7.zip) | | 31/03 | 9h45 ou 11h15 | TP7 | App. OCaml (à changer ?) | (2024) [Sujet](tp/tp7.md) |
| 07/04 | 8h | CM6 | Foncteurs | (2024) [Diapositives](cm/lifpf-cm6.pdf), [code](cm/cm6-code.ml) | | 07/04 | 8h | CM6 | Foncteurs | (2024) [Diapositives](cm/lifpf-cm6.pdf), [code](cm/cm6-code.ml) |
| | 9h45 | TD6 | Foncteurs | (2024) [Sujet](td/lifpf-td6-enonce.pdf), [corrigé](td/lifpf-td6-correction.pdf) | | | 9h45 | TD6 | Foncteurs | (2024) [Sujet](td/lifpf-td6-enonce.pdf) |
### Annales ### Annales
......
No preview for this file type
No preview for this file type
No preview for this file type
tp/tp1.ml 0 → 100644
(**********************************************************************)
(* 1.1.1 *)
(3 * 2) + (5 / 2);;
3.2 +. (7.4 /. 2.0);;
"AC" ^ "/" ^ "DC";;
true || (false && false);;
(* && est prioritaire sur || *)
(false && false) || true;;
(* 3 < 2.0 provoque une erreur car 3 et 2.0 n'ont pas le même type *)
(**********************************************************************)
(* 1.1.2 *)
(* float_of_int 3.0 provoque une erreur car 3.0 n'est pas un int *)
float_of_int 3;;
int_of_float;;
int_of_float 3.5 + 2;;
float_of_int (int_of_float 3.6 + 2) +. 1.5;;
(not false) && false;;
2 < 3 && "b" < "ab";;
(**********************************************************************)
(* 1.1.3 *)
let x1 = 3.5 +. float_of_int 2 in
x1 +. 3.0
;;
let x1 = 3.5 +. float_of_int 2 in
let x2 = x1 *. x1 in
x2 *. 2.0
;;
(**********************************************************************)
(* 1.1.4 *)
(if true then 3 else 5) > 4
(**********************************************************************)
(* 1.2 *)
let f x = x + 1;;
3 + f 3
let discriminant a b c = (b *. b) -. (4.0 *. a *. c)
(* Le type affiche par l'interpréteur est float -> float -> float -> float *)
(** [discriminant a b c] calcule le discriminant d'un trinôme. Cette fonction
est utile pour trouver les racines d'un trinôme.
@param a le coefficient d'ordre 2
@param b le coefficient d'ordre 1
@param c le coefficient d'ordre 0
@return le discriminant *)
let discriminant (a : float) (b : float) (c : float) : float =
(b *. b) -. (4.0 *. a *. c)
;;
discriminant;;
discriminant 2.0 8.0 8.0
(* Erreur de type sur l'utilisation de a dans la def suivante: *)
(*
let discriminant (a:int) (b:float) (c:float): float =
b *. b -. 4.0 *. a *. c;;
*)
(**********************************************************************)
(* 1.3.1 *)
type couleur = Rouge | Jaune | Bleu;;
(* La valeur Rouge est bien définie et reconnue comme étant de type couleur *)
Rouge;;
(* L'égalité est bien (pré)définie sur les couleurs *)
Rouge = Rouge;;
Rouge != Bleu;;
(* De même il existe un ordre par défaut sur les couleurs *)
Bleu > Jaune
type couleur = Rouge | Jaune | Bleu | Violet | Orange | Vert
type couleur =
| Rouge
| Jaune
| Bleu
| Violet
| Orange
| Vert
| RJB of int * int * int
;;
(* le type est "int * float" c'est-à-dire une paire d'int et de float *)
3, 5.6;;
(* c'est le triplet de type int * int * int *)
3, 5, 6
(**********************************************************************)
(* 1.3.2 *)
let nom_couleur c =
match c with
| Rouge -> "rouge"
| Jaune -> "jaune"
| Bleu -> "bleu"
| Vert -> "vert"
| Violet -> "violet"
| Orange -> "orange"
| _ -> "mélange"
(*
let nom_couleur c =
match c with
| Rouge -> "rouge"
| Jaune -> "jaune"
| Bleu -> "bleu"
| Vert -> "vert"
| Violet -> "violet"
| Orange -> "orange";;
Erreur: this pattern-matching is not exhaustive.
Elle indique que le match ne couvre pas tous les cas possibles.
*)
(*
let nom_couleur c =
match c with
| _ -> "mélange"
| Rouge -> "rouge"
| Jaune -> "jaune"
| Bleu -> "bleu"
| Vert -> "vert"
| Violet -> "violet"
| Orange -> "orange";;
Erreur: this pattern-matching is not exhaustive.
Elle indique que le match ne couvre pas tous les cas possibles.
*)
(** Génère le paragraphe pour [n] bouteilles de bières.
@param n
le nombre de bouteilles de bièere sur le mur au début du paragraphe.
@return le paragraphe *)
let paragraphe_bottles (n : int) : string =
match n with
| 0 ->
"No more bottles of beer on the wall, no more bottles of beer.\n"
^ "Go to the store and buy some more, 99 bottles of beer on the wall."
| 1 ->
"1 bottle of beer on the wall, 1 bottle of beer.\n"
^ "Take one down and pass it around, no more bottles of beer on the wall."
| 2 ->
"2 bottles of beer on the wall, 2 bottles of beer.\n"
^ "Take one down and pass it around, 1 bottle of beer on the wall."
| k ->
string_of_int k ^ " bottles of beer on the wall, " ^ string_of_int k
^ " bottles of beer.\n" ^ "Take one down and pass it around, "
^ string_of_int (k - 1)
^ " bottles of beer on the wall."
;;
(* tests *)
paragraphe_bottles 0;;
paragraphe_bottles 1;;
paragraphe_bottles 2;;
paragraphe_bottles 7
(**********************************************************************)
(* 2.1 *)
(** Renvoie la somme des n premiers entiers
@param n le nombre d'entiers à sommer
@return la somme *)
let rec sum_n (n : int) : int = if n <= 0 then 0 else n + sum_n (n - 1)
(** [factorielle n] calcule la factorielle des [n] premiers entiers
@param n doit être supérieur ou égal à 1
@return !n *)
let rec factorielle n = if n <= 1 then 1 else n * factorielle (n - 1)
(**********************************************************************)
(* 2.2 *)
(* Erreur car on essaie d'ajouter une string dans une int list
"2" :: 3 :: [];;
*)
(** Cette fonction calcule la longueur d'une liste de `string`.
@param l la liste dont on veut la longueur
@return la longueur de l *)
let rec longueur (l : string list) : int =
match l with [] -> 0 | _ :: l2 -> 1 + longueur l2
(* La valeur de l'élément de list n'est pas utilisée dans le deuxième cas du match.
On a donc pas besoin de la recupérer dans une variable et on met _ pour plus de clarté. *)
(** Cette fonction calcule la somme des éléments de la liste
@param l la liste dont on veut additionner les éléments
@return la somme des éléments de la liste *)
let rec sum_f (l : float list) : float =
match l with [] -> 0.0 | x :: l2 -> x +. sum_f l2
(** Cette fonction concatène les éléments de la liste en les séparant par [sep].
@param l la liste dont on veut concaténer les éléments
@param sep le séparateur
@return
les éléments de la liste [l] concaténé et séparés les uns des autres par
[sep] *)
let rec join_s (l : string list) (sep : string) : string =
match l with
| [] -> ""
| s :: [] -> s
| s :: l2 ->
(* Plus général que le cas précédent car l2 n'est pas forcément vide.
Comme le match applique le premier cas dans l'ordre du programme,
Les listes à 1 élément ne passent pas dans le 3eme cas du match. *)
s ^ sep ^ join_s l2 sep
;;
(* test *)
join_s [ "a"; "b"; "c" ] "|"
(** Cette fonction créée une liste des int de n à 0 inclus.
@param n l'int de début de liste
@return la liste des entiers décroissants *)
let rec liste_n_0 (n : int) : int list =
if n <= 0 then [ 0 ] else n :: liste_n_0 (n - 1)
;;
(* test *)
liste_n_0 12
(** [bottles_of_list [n1; n2; ...]] crée la liste des paragraphes de la chanson
99 bottles of beer pour n1 puis n2 ... bouteilles.
@param l la liste des nombres de bouteilles à transformer
@return la liste des paragraphes correspondant aux int de l *)
let rec bottles_of_list (l : int list) : string list =
match l with
| [] -> []
| n :: l2 -> paragraphe_bottles n :: bottles_of_list l2
let chanson_99_bottles =
let nums = liste_n_0 99 in
let paragraphes = bottles_of_list nums in
join_s paragraphes "\n\n"
;;
print_endline chanson_99_bottles
# LIFPF: TP2 récursion sur les listes # LIFPF: TP2 récursion sur les listes
Finir le [TP1](tp1.md) avant de commencer ce TP. Ce TP consiste à travailler la récursion sur les listes.
Le reste du TP consiste à travailler la récursion sur les listes.
Comme dans le TP précédent, on prendra soin: Comme dans le TP précédent, on prendra soin:
- de **donner le type** des arguments et le type de retour de chaque fonction; - de **donner le type** des arguments et le type de retour de chaque fonction;
...@@ -39,9 +37,11 @@ applatit [ [ 1; 2 ]; [ 3; 4; 5 ]; []; [ 6 ] ] = [ 1; 2; 3; 4; 5; 6 ];; ...@@ -39,9 +37,11 @@ applatit [ [ 1; 2 ]; [ 3; 4; 5 ]; []; [ 6 ] ] = [ 1; 2; 3; 4; 5; 6 ];;
applatit [ [ 1 ] ] = [ 1 ];; applatit [ [ 1 ] ] = [ 1 ];;
``` ```
Faire une deuxième version `applatit2` ayant la même spécification que `applatit` mais qui n'utilise **pas** `concatene`. Faire une deuxième version `applatit2` ayant la même spécification que `applatit` mais qui n'utilise **pas** `concatene` (et qui n'utilise aucune autre fonction, en particulier pas l'opérateur de concaténation prédéfini en OCaml).
Tester cette fonction avec les mêmes tests que `applatit`. Tester cette fonction avec les mêmes tests que `applatit`.
> Fin de la partie 1, prévenez votre chargé de TP.
## 2. Retournement de liste ## 2. Retournement de liste
On souhaite implémenter une fonction `renverse` qui renverse une liste. On souhaite implémenter une fonction `renverse` qui renverse une liste.
...@@ -70,6 +70,8 @@ On peut aussi remarquer que `renverse` peut se coder très facilement à partir ...@@ -70,6 +70,8 @@ On peut aussi remarquer que `renverse` peut se coder très facilement à partir
Coder `renverse` en définissant `renverse_ajoute`. Coder `renverse` en définissant `renverse_ajoute`.
Définir tout d'abord `renverse_ajoute` avant `renverse` et tester. Essayer ensuite d'intégrer la définition de `renverse_ajoute` à l'intérieur de celle de renverse via un `let rec renverse_ajoute ... in ...`. Définir tout d'abord `renverse_ajoute` avant `renverse` et tester. Essayer ensuite d'intégrer la définition de `renverse_ajoute` à l'intérieur de celle de renverse via un `let rec renverse_ajoute ... in ...`.
> Fin de la partie 2, prévenez votre chargé de TP
## 3. Tri par insertion ## 3. Tri par insertion
On code [l'algorithme de tri par insertion](https://fr.wikipedia.org/wiki/Tri_par_insertion) qui consiste, pour chaque élément, à l'insérer à la bonne place dans le reste de la liste préalablement triée. On code [l'algorithme de tri par insertion](https://fr.wikipedia.org/wiki/Tri_par_insertion) qui consiste, pour chaque élément, à l'insérer à la bonne place dans le reste de la liste préalablement triée.
...@@ -96,6 +98,8 @@ tri_insertion [ 1; 4; 2; 3 ] = [ 1; 2; 3; 4 ];; ...@@ -96,6 +98,8 @@ tri_insertion [ 1; 4; 2; 3 ] = [ 1; 2; 3; 4 ];;
tri_insertion [ 1; 2; 3; 4 ] = [ 1; 2; 3; 4 ];; tri_insertion [ 1; 2; 3; 4 ] = [ 1; 2; 3; 4 ];;
``` ```
> Fin de la 3eme partie, prévenez votre chargé de TP
## 4. Recherche dans une liste d'association ## 4. Recherche dans une liste d'association
On rappelle qu'une liste d'association est _une liste de paires `(clé, valeur)`_. On rappelle qu'une liste d'association est _une liste de paires `(clé, valeur)`_.
...@@ -114,6 +118,8 @@ Coder la fonction `cherche` qui va chercher une clé dans une liste d'associatio ...@@ -114,6 +118,8 @@ Coder la fonction `cherche` qui va chercher une clé dans une liste d'associatio
Bien penser à écrire des tests pour cette fonction. Bien penser à écrire des tests pour cette fonction.
> Fin de la 4eme partie, prévenez votre chargé de TP.
## 5. Calculatrice en notation polonaise ## 5. Calculatrice en notation polonaise
On souhaite implémenter une calculatrice en notation polonaise, c'est-à-dire calculant le résultat d'expressions dans lesquelles les **opérateurs sont placés avant leurs arguments**. On souhaite implémenter une calculatrice en notation polonaise, c'est-à-dire calculant le résultat d'expressions dans lesquelles les **opérateurs sont placés avant leurs arguments**.
...@@ -180,3 +186,5 @@ eval_expr [ Op Mult; Cst 3; Cst 2 ] = [ Ok 6 ];; ...@@ -180,3 +186,5 @@ eval_expr [ Op Mult; Cst 3; Cst 2 ] = [ Ok 6 ];;
eval_expr [ Op Plus; Cst 3; Cst 5; Op Moins; Cst 2; Cst 7 ] = [ Ok 8; Ok (-5) ];; eval_expr [ Op Plus; Cst 3; Cst 5; Op Moins; Cst 2; Cst 7 ] = [ Ok 8; Ok (-5) ];;
eval_expr [ Op Plus; Op Div; Cst 7; Cst 3 ] = [ ErrExpr ];; eval_expr [ Op Plus; Op Div; Cst 7; Cst 3 ] = [ ErrExpr ];;
``` ```
> Fin de la 5eme partie, prévenez votre chargé de TP.
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment