(* 2025-2026 *)
(* Exercice 1 *)
(* 1. *)(* 2. *)
(* voir le cours *)
(* 3. *)
let somme_distance p0 points =
  List.fold_left
    (fun d p -> p_dist p p0 +. d)  0. points

(* 4. *)
let points_dans_disque centre rayon points =
  List.filter (fun point -> p_dist centre point <= rayon)

(* Exercice 2 *)
(* 5. *) (* à tester soi-même *)
(* 6 *) (* le produit de x et y *)
(* 7 *) (* O(x) *)
(* 8 *)
let rec  mystery_log x y =
  if x = 0 then 0
  else let r = 2 * mystery_log (x / 2) y in
       if x mod 2 = 0 then r
       else r + y

(* Exercice 3 *)
(* 9 *)
(* int -> int -> int list *)
(* 10 *)
(* la fonction retourne la liste des entiers de l'intervalle [n,p] *)
(* 11 *)
(* 1 n'est pas récursive terminale ce qui explique le Stack Overflow pour une grande valeur de n - p. 2 et 3 étant récursives terminales n'ont pas de problème de débordement de pile *)
(* 2 est en O((n-p)^2) (quadratique) du fait de l'ajout en fin de liste (@ [p])
   tandis que 1 et 3 sont en O(n-p) (linéaires). Ceci explique que 2 soit la plus lente *)
(* La meilleure solution est 3 (linéaire et récursive terminale *)

(* Exercice 4 *)
(* 12 *)
(* ('a -> 'b) list -> 'a -> 'b list *)
   
(* 13 *)
(* mapfun prend en paramètre une liste de fonctions de même type 'a -> 'b
   et une valeur de type 'a et retourne la liste des résultats des fonctions
   appliquées à cette valeur *)
(* 14 *)
(* 
# mapfun [pred; succ] 10;;
- : int list = [9; 11]
  *)
   
(* Exercice 5 *)
(* 15 *)
let empty_dict : ('k, 'v) dict = []

(* 17 *)
let rec add_k_v k v l =
  match l with
    [] -> [(k, [v])]
  | (k', vs) :: l' -> if k = k' then (k, v :: vs) :: l'
                        else (k', vs) :: (add_k_v k v l')

(* 16 *)
let dict_of_couples couples =
  let rec aux couples acc =
    match couples with
      [] -> acc
    | (k, v) :: couples' -> aux couples (add_k_v k v acc)
  in aux couples []