; LIF3 - TP2

; Ecrire une fonction qui supprime tous les elements d une liste qui sont egaux a un élément e passe en argument.

; sur une liste vide
(supprime '() 'a) ; -> ()
; sur une liste quelconque avec un element present dans la liste
(supprime '(a b c a a b c b a) 'a) ; -> (b c b c b)
(supprime '(a b c a a b c b a) 'b) ; -> (a c a a c a)
(supprime '(a b c a a b c b a) 'c) ; -> (a b a a b b a)
; avec un element non present dans la liste
(supprime '(a b c a a b c b a) 'w) ; -> (a b c a a b c b a)

          
; Ecrire une fonction qui verifie que tous les elements d une liste sont egaux.

; sur une liste vide
(egaux? '()) ; -> #t
; sur une liste de taille variee ou tous les elements sont egaux
(egaux? '(a a a a)) ; -> #t
(egaux? '(b b)) ; -> #t
(egaux? '(c)) ; -> #t
; sur une liste avec des elements differents
(egaux? '(a a b)) ; -> #f
(egaux? '(a b a)) ; -> #f
(egaux? '(b a a)) ; -> #f
(egaux? '(b a)) ; -> #f

; Ecrire une fonction qui, etant donnee une liste de longueur paire, regroupe deux elements consecutifs dans une liste.

; avec une liste de longueur paire
(regroupe '(a b c d e f)) ; -> ((a b) (c d) (e f))
(regroupe '(a b)) ; -> ((a b))
; avec une liste de longueur impaire : interdit
; avec une liste vide
(regroupe '()) ; -> ()

; Ecrire une fonction qui rend la liste de tous les elements de rang impair d une liste.

; avec une liste de longueur paire
(impairs '(a b c d e f)) ; -> (a c e)
(impairs '(a b)) ; -> (a)
; avec une liste de longueur impaire : interdit
(impairs '(a b c d e)) ; -> (a c e)
(impairs '(a)) ; -> (a)
; avec une liste vide
(impairs '()) ; -> ()

; Ecrire une fonction qui substitue un symbole par un autre dans une liste.

; sur une liste vide
(substitue 'a 'b '()) ; -> ()
; sur une liste quelconque, l element a substitue present dans la liste
(substitue 'a 'w '(a b c a a b c b a)) ; -> (w b c w w b c b w)
(substitue 'b 'w '(a b c a a b c b a)) ; -> (a w c a a w c w a)
(substitue 'c 'a '(a b c a a b c b a)) ; -> (a b a a a b a b a)
; sur une liste quelconque, l element a substitue absent de la liste
(substitue 'w 'z '(a b c a a b c b a)) ; -> (a b c a a b c b a)
               
;;; MEMORISATION

; Ecrire une fonction qui rend la liste des n+1 premiers nombres de la suite de Fibonacci (de un à u0)
; sans faire plusieurs fois les memes calculs.

(fibo-liste 1) ; -> (1 1)
(fibo-liste 2) ; -> (2 1 1)
(fibo-liste 3) ; -> (3 2 1 1)
(fibo-liste 4) ; -> (5 3 2 1 1)
(fibo-liste 5) ; -> (8 5 3 2 1 1)

; Utiliser la fonction fibo-liste pour ecrire une nouvelle version de la fonction écrite en TD 
; qui calcule le nieme terme de la suite de Fibonacci. 

(fibo 0) ; -> 1
(fibo 1) ; -> 1
(fibo 2) ; -> 2
(fibo 3) ; -> 3
(fibo 4) ; -> 5
(fibo 5) ; -> 8

; Ecrire une fonction qui retourne une liste de nombres entiers positifs pris au hasard. 
; Les deux parametres de cette fonction sont la longueur de la liste a construire 
; et la valeur maximale des nombres a engendrer.

; 5 nombres inferieurs a 10
(liste_random 5 10) ; -> (7 9 6 7 4) ou (7 5 10 4 6) ou ...
; 5 nombres inferieurs a 5
(liste_random 5 5) ; -> (5 3 3 2 3) ou ...
; 10 nombres inferieurs a 100
(liste_random 10 100) ; -> (3 85 13 10 86 5 13 28 43 54) ou ...
; Attention, le resultat varie... il faut juste vérifier la longeur de la liste et son contenu

; Ecrire une fonction qui retourne une liste composee d un nombre entier pris au hasard entre 0 et N
; et d un booléen indiquant si ce nombre est un multiple de trois ou de sept.

(nb_test 10) ; -> (5 #f)
(nb_test 10) ; -> (6 #t)

; Ecrire une fonction identique a la fonction liste_random, mais qui ne retourne que des nombres pairs. 

(liste_random_pairs 5 10) ; -> (4 10 6 4 6) ou (10 4 4 0 4) ou ...

; Ecrire une fonction qui etant donnee une liste, construit une liste de deux sous-listes : 
; celle contenant les atomes et celle contenant les listes.

; avec une liste mixte
(trie '(a 5 (r 2) 8 toto "az e" ("r" 7 b) t)) ; -> ((a 5 8 toto "az e" t) ((r 2) ("r" 7 b)))
; avec une liste sans atome
(trie '((r 2) ("r" 7 b) )) ; -> (() ((r 2) ("r" 7 b)))
; avec une liste sans liste
(trie '(a 5 8 toto "az e" t)) ; -> ((a 5 8 toto "az e" t) ())
; avec une liste vide
(trie '()) ; -> '(() ())