tp1.ml

(**********************************************************************)
(* 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.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.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.4 *)

(if true then 3 else 5) > 4

(**********************************************************************)
(* 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;;
*)

(**********************************************************************)

(* 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

(**********************************************************************)
(* 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

(**********************************************************************)
(* 4 *)

(**
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)

(**********************************************************************)
(* 5 *)
(* 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