TD 2 (extra) 1 Listes

Licence 3, semestre 5, 2013–2014 Programmation Fonctionnelle
TD 2 (extra)
1 Listes
Exercice 1 (R´ecursion Terminale vs R´ecursion Non-terminale) :
´
Ecrire des fonctions suivantes sur les listes.
–length : calcule la longueur d’une liste.
Exemple : length ["let" ;"toto" ;"42"; "hello"] = 4
length [true, false, false, true, true, false] = 6.
Donner une version non-terminale, puis une version terminale.
–list sigma : calcule la somme des ´el´ements d’une liste d’entiers.
Exemple : list sigma [1 ;2 ;3] = 6.
Donner une version non-terminale, puis une version terminale.
–make n v : cr´ee une liste de taille ninitialis´ee avec la valeur v.
Exemple : make 3 "42" = ["42"; "42"; "42";]
Donner une version non-terminale, puis une version terminale.
–init n f : cr´ee une liste de taille ninitialis´ee `a l’aide de la fonction fde
telle mani`ere que la i-`eme ´el´ement de la liste est ´egal `a f i (pour i = 0 ..
(n-1)) .
Exemple : init 3 (fun i -> i) = [0; 1; 2]
Donner une version non-terminale, puis une version terminale.
–range k m : cr´ee une liste contenant des entiers de k`a mdans l’ordre
croissant. (si k>m, renvoie une liste vide)
Exemple : range 2 5 =[2 ;3; 4; 5].
Exercice 2 (Fonctions de la Biblioth`eque Standard List) :
o mem : d´etermine si une liste contient une valeur donn´ee.
Exemple : mem 27 [12 ;27 ;1] = true, mem 3 [12 ;27 ;1] = false.
o append : concat`ene deux listes.
Exemple : append [1 ;2 ;3] [4 ;5] = [1 ;2 ;3 ;4 ;5].
Donner uniquement une version non-terminale.
o flatten : aplanir d’un niveau une liste de listes.
Exemple : flat [[2] ;[] ;[3 ;4 ;5]] = [2 ;3 ;4 ;5].
o map : la fonction telle que map f [a1;... ;an] = [f(a1) ;... ;f(an)].
o exist : teste si au moins un des ´el´ements de la liste satisfait une condition
pass´ee en argument.
Exemple : exist (fun x -> if x = 0 then true else false) [1;2;0;4]
= true
1

Exercice 3 (palindromes) :
´
Ecrire des fonctions suivantes sur les listes.
–last : trouve le dernier ´el´ement d’une liste. Si la liste est vide, lever l’ex-
ception Empty list d´efinie pr´ec´edemment.
Exemple : last [12 ;27 ;14] = 14
–drop last : renvoie la liste pass´ee en argument priv´ee du dernier ´el´ement.
Exemple : drop last [12 ;27 ;14] = [12 ;27]
–palindrome : teste si la liste pass´ee en en argument est un palindrome
Exemple : palindrome [] = true, palindrome [1 ;2] = false, palindrome
[1 ;2 ;3 ;2 ;1] = true
Donner une version non-terminale (en utilisant les deux fonctions pr´ec´edentes).
Quelle est la complexit´e de la solution ?
o rev : inverse l’ordre des ´el´ements d’une liste.
Exemple : rev [1 ; 2 ; 3] = [3 ; 2 ; 1].
Donner une version non-terminale (en utilisant les deux fonctions pr´ec´edentes
last et drop last). Quelle est la complexit´e de la solution ? Donner une
version terminale. Quelle est la complexit´e maintenant ?
–palindrome : Donner une version de palindrome non-terminale, en util-
isant la fonction rev d´efinie pr´ec´edemment). Quelle est la complexit´e de
la solution ?
Exercice 4 (tri par insertion) :
Dans cet exercice, nous allons ´ecrire le tri par insertion, sous la forme d’une
fonction op´erant sur des listes d’entiers, c’est-`a-dire ayant le type int list ->
int list.
1. ´ Ecrire une fonction insertion : int -> int list -> int list qui ins`ere
un ´el´ement dans une liste d’entiers suppos´ee tri´ee en ordre croissant.
2. ´ Ecrire une fonction insertion sort : int list -> int list qui r´ealise
le tri par insertion d’une liste d’entiers. On rappelle que cela consiste `a
extraire le premier ´el´ement de la liste, `a trier r´ecursivement le reste de la
liste, puis `a ins´erer l’´el´ement isol´e (avec la fonction insertion).
3. Pour tester votre fonction de tri, ´ecrivez une fonction
is sorted : int list -> bool qui retourne true si la liste pass´ee en
argument est tri´ee dans l’ordre croissant
Exercice 5 (tri rapide) :
Dans cet exercice, nous allons ´ecrire le tri rapide (Quicksort) invent´e par le
chercheur britannique C.A.R. Hoare.
1. ´ Ecrire une fonction partition : int -> int list -> int list * int
list qui prend en argument un entier xet une liste d’entiers let renvoie
une paire de listes (l1,l2) telle que l1 (resp. l2) contient les ´el´ements
de l plus petits (resp. plus grands) que x.
2

2. ´ Ecrire une fonction quicksort : int list -> int list r´ealisant le tri
rapide (quicksort). On rappelle que le principe consiste `a isoler un ´el´ement
particulier de la liste (ici le premier), `a partionner les ´el´ements restants
en utilisant la fonction partition ci-dessus, `a trier r´ecursivement les deux
listes obtenues, et enfin `a recoller les morceaux. Pour cette derni`ere ´etape
on pourra utiliser la fonction de biblioth`eque List.append qui effectue la
concat´enation de deux listes (elle se note ´egalement @de mani`ere infixe).
2 Ordre Sup´erieur
1. ´ Ecrire une fonction forall : (int -> bool) -> int array -> bool telle
que forall p t v´erifie que p t.(i) renvoie bien true pour toutes les
cases ide t.
2. Qu’est-ce qui est affich´e dans le terminal apr`es avoir tap´e la d´eclaration
suivante dans le top-level ?
# let rec test1 x =
let f = print_string "."; fun y -> y - 1 in
if x = 0 then 1 else test1 (f x) ;;
Mˆeme question apr`es avoir tap´e l’expression suivante :
# test1 4;;
3. Comparer vos r´eponses `a la question pr´ec´edente si on consid`ere maintenant
la d´eclaration suivante :
# let rec test2 =
let f = print_string "."; fun y -> y - 1 in
fun x -> if x = 0 then 1 else test2 (f x) ;;
et l’expression suivante
# test3 4;;
4. Donner le type des fonctions suivantes :
let f = let x = ref 3 in fun () -> x
let g = fun () -> let x = ref 3 in x
5. Quelles sont les diff´erences entre ces deux fonctions ?
6. Donner les r´esultats renvoy´ees (dans le top-level) par les d´eclarations et/ou
expressions suivantes :
#leta=f();;
#letb=f();;
#a=b;;
#a==b;;
# incr a; !b ;;
3

#letc=g();;
#letd=g();;
#c=d;;
#c==d;;
# incr c; !d ;;
7. Soit la fonction plus d´efinie de la mani`ere suivante :
# let plus x y = x+y ;;
val plus : int -> int -> int = <fun>
Quelle diff´erence y-a-t’il avec la d´eclaration suivante ?
# let plus (x, y) = x+y ;;
4