(* Exercice 1 *)

(* 1 *)
let premierElement l = failwith "à coder" ;;

premierElement [1; 2; 3] ;; (* 1 *)

premierElement [] ;; (* erreur *)

(* 2 *)
let rec dernierElement l = failwith "à coder" ;;

dernierElement [1; 2; 3; 4] ;; (* 4 *)

(* 3 *)
let rec avantDernier l = failwith "à coder" ;;

avantDernier [ 1 ; 2 ; 3 ] ;; (* 2 *)

avantDernier [] ;; (* erreur *)

(* 4 *)
let rec element l k = failwith "à coder" ;;

element [12; 25; 42; 100] 0 ;; (* 12 *)

element [12; 25; 42; 100] 2 ;; (* 42 *)

element [12; 25; 42; 100] 4 ;; (* erreur *)

(* 5 *)
let rec indice l x = failwith "à coder" ;;

indice [12; 42; 25; 100]  12 ;; (* 0 *)

indice [12; 25; 42; 100]  42 ;; (* 2 *)

indice [12; 25; 42; 100]  3 ;; (* erreur *)

let indice l x = failwith "à coder" ;;

(* 6 *)
let rec ajouterEnQueue l x = failwith "à coder" ;;

ajouterEnQueue [1; 2; 3; 4] 5 (* [1; 2; 3; 4; 5] *)

(* 7 *)
let miroir l = failwith "à coder" ;;

miroir [1; 2; 3] ;; (* [3; 2; 1] *)

(* 8 *)
let rec maMap f l = failwith "à coder" ;;

maMap (fun x -> 2*x) [1; 2; 3] ;; (* [2; 4; 6] *)

(* 9 *)
let rec somme l = failwith "à coder" ;;

somme [1; 2; 3; 4] ;; (* 10 *)

(* Exercice 2 *)
let rec mystere f l = match l with
  | [] -> []
  | t::q -> (f t)::(mystere f q)
;;

(* Exercice 3 *)
let rec mystere' f = function
  | [] -> []
  | t::q when f t > 1 -> t::(mystere' f q)
  | t::q -> mystere' f q
;;

(* 3 *)
let rec filtrer f l = failwith "à coder" ;;

let est_pair n = n mod 2 = 0 ;;

filtrer est_pair [1; 2; 3; 4; 5; 6; 7] ;; (* [2; 4; 6] *)

(* Exercice 4 *)
let rec concat l1 l2 = failwith "à coder" ;;

concat [1; 2; 3] [4; 5; 6] ;; (* [1; 2; 3; 4; 5; 6] *)

(* Exercice 5 *)
let rec listIt f l b = failwith "à coder" ;;

listIt (fun x l -> x::l) [1; 2; 3] [4; 5; 6] ;; (* [1; 2; 3; 4; 5; 6] *)

(* Exercice 6 *)
(* 1 *)
let rec existe f l = failwith "à coder" ;;

existe est_pair [1; 2; 3] ;; (* true *)

existe est_pair [1; 5; 3] ;; (* false *)

(* 2 *)
let rec pourTout f l = failwith "à coder" ;;

pourTout est_pair [2; 4; 6] ;; (* true *)

pourTout est_pair [1; 2; 3] ;; (* false *)

(* Exercice 7 *)

(* 1 *)
let rec appartient x l = failwith "à coder" ;;

appartient 2 [1; 2; 3] ;; (* true *)

appartient 12 [1; 2; 3] ;; (* false *)

(* 2 *)
let rec purge l = failwith "à coder" ;;

purge [1; 2; 3; 1; 4; 3; 1] ;; (* [2; 4; 3; 1] *)

(* 3 *)
let purge' l = failwith "à coder" ;;

purge' [1; 2; 3; 1; 4; 3; 1] ;; (* [1; 2; 3; 4] *)

(* Exercice 8 *)

(* 1 *)
let rec membre x l = failwith "à coder" ;;

(* 2 *)
let rec union l1 l2 = failwith "à coder" ;;

(* 3 *)
let rec intersection l1 l2 = failwith "à coder" ;;

(* 4 *)
let rec union l1 l2 = failwith "à coder" ;;

(* Exercice 9 *)

let rec insere x l = failwith "à coder" ;;

let rec triInsertion l = failwith "à coder" ;;

triInsertion [12; 100; 25; 42; 12] ;;

(* Exercice 10 *)

let rec minimum l = failwith "à coder" ;;

let rec triSelection l = failwith "à coder" ;;

triSelection [12; 100; 25; 42; 12] ;;

(* Exercice 11 *)

let rec triBulle l = failwith "à coder" ;;

triBulle [12; 100; 25; 42; 12] ;;