(* Corrige Introduction à la programmation *)
(* Exercices sur les listes  *)
(* Ancien TD9 *)

(* --------------------------------------------------------- *)

(* Supprimer un élément d'une liste *)

let rec suppr x= function
  [] -> []
 |t::r -> if x=t then r else t::(suppr x r);;


(* --------------------------------------------------------- *)

(* Une liste est-elle la permutation d'une autre ? *)


let rec perm l1 l2=
   match (l1,l2) with
         ([],[]) -> true
         |(x::r1,l2) -> if Membre x l2 then perm r1 (suppr x l2) else false
         |_ -> false;;

(* --------------------------------------------------------- *)

(* Le nombre de multiples de 5 dans une liste *)

let rec compte_liste = function
  [] -> 0
 |x::l -> if (x mod 5) = 0 then 1 + compte_liste l
                   else compte_liste l;;

(* --------------------------------------------------------- *)

(* Éliminer d'une liste tous les multiples de 5 *)

let rec suppr_listeM5 = function
  [] -> []
 |x::l -> if (x mod 5) = 0 then suppr_listeM5 l else x::suppr_listeM5 l;;


(* --------------------------------------------------------- *)

(* Éliminer d'une liste tous les éléments qui vérifient $P$ *)

let rec suppr_listeP proprieteP = function
  [] -> []
 |x::l -> if (proprieteP x) then suppr_listeP proprieteP l else 
                              x::suppr_listeP proprieteP l;;
 
(* exemple d'utilisation : 
 
 suppr_listeP (function a -> a mod 5=0)  [5;5;10;1000;4;5;0] ;;
 - : int list = [4] 
*)

(* --------------------------------------------------------- *)

(* Que fait la fonction merp ? *)

(* Littéralement c'est une fonction qui met dans ll l'ensemble *)
(* de tous les éléments d'une liste qui sont différents de  *)
(* la longueur de cette liste. Ensuite cette fonction renvoie  *)
(* vrai seulement si en supprimant cet element la longueur de  *)
(* la liste n'a diminue que de 1 et qu'on peut en faire de  *)
(* meme pour toutes les listes qui s'en deduisent. Ce qui suppose  *)
(* qu'à chaque étape, on a un et un seul des éléments de  *)
(* qui est égal à la longueur de la liste. Donc cette liste  *)
(* renvoie true pour toutes les listes dont le contenu est une  *)
(* permutation des n permiers entiers (n etant la longueur de  *)
(* la liste).  *)