(* Corrige d'Introduction à la programmation *)
(* Exercices sur les listes : premiers exercices *)
(* Ancien TD7 *)

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

(* Détecter si une liste a un seul élément *)

let EstSingleton = function | t::[] -> true | _ -> false ;;

(* ou bien *)

let EstSingleton l = match l with | [t] -> true | _ -> false;;

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

(* Le deuxième élément d'une liste *)

let DeuxiemeElement = function
	| t::r::s -> r
        | _ -> failwith "DeuxiemeElement : la liste a moins de deux éléments";;


(* ou bien *)

let DeuxiemeElement l = match l with t::r::s -> r
                 | _ -> failwith "DeuxiemeElement : la liste a moins de deux éléments";; 

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

(* Le nombre d'éléments d'une liste *)

let rec longueur = function [] -> 0 | t::r -> 1+longueur r;;

(* ou bien *)

let rec longueur l = match l with [] -> 0 | t::r -> 1+longueur r;;

(* Ces fonctions marchent pour tous les types de listes.*)

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

(* La somme des éléments d'une liste *)

let rec somme_int = function 
    [] -> 0 
| t::r -> t + somme_int r;;

 
let rec somme_float = function 
    [] -> 0.0
| t::r -> t +. somme_float r;;


(* la premiere fonction est utilisee pour les *)
(* listes d'entiers et la deuxieme, pour les *)
(* listes de flottants. *)

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

(* La concaténation de deux listes *)

let rec concat l1 l2 =
  match (l1,l2) with
        ([],l2) -> l2
        |(x::r1,l2) -> x::concat r1 l2;;

(* Avec filtrage implicite, la fonction a ete vue en cours. *)

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

(* L'appartenance à une liste *)

let rec Membre x= function
 [] -> false
|t::r -> if x=t then true else Membre x r;;


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

(* Tester l'égalité entre deux listes *)

(* Avec le filtrage implicite, la fonction a été deja *)
(* vue en cours. *)

let rec MemeListe l1 l2=
match (l1,l2) with
       ([],[]) -> true
       |(x1::r1,x2::r2) -> if x1=x2 then MemeListe r1 r2 else false
       |_ -> false;;

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

(* Comparer la longueur de deux listes *)

let rec MemeLongueur l1 l2 =
   match (l1,l2) with
         ([],[]) -> true
         |(_::r1,_::r2) -> MemeLongueur r1 r2
         |_ -> false;;

(* La durée de calcul est celle du parcours de la liste la plus courte. *)

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

(* Renverser une liste *)

let rec Renverser = function
  [] -> []
 |x::r -> concat (Renverser r) [x];;