Nom : RICM3-2013/2014 Prénom : Algorithmique et Programmation Fonctionnelle EXAMEN Durée : 2h, le seul document autorisé est une feuille A4 recto-verso manuscrite de notes personnelles Cet énoncé comporte des parties indépendantes. Le barème est indicatif, le nombre de points correspond au nombre de minutes estimé nécessaire pour faire les exercices. Le total des points est de 120 points. Exercices Exercice 1 : Typage et sens d une expression (15 points) Donner le type et expliquer en une ou deux phrases ce que fait chacun des programmes suivants (qui sont tous des programmes corrects, utiles et bien typés). Vous pourrez vous appuyer sur des exemples. 1. let rec f1 f l = match l with [] -> () h::t -> f h ; f1 f t ( a -> unit) -> a list -> unit List.iter 2. let rec f2 m n = match m, n with x::y, z::t -> x::z::(f2 y t) [], _ -> n _, _ -> m a list -> a list -> a list Alterne les éléments de deux listes (pas forcément de mêmes tailles mais de même type). 3. let rec f3 l = match l with [] -> [] h::t -> match f3 t with [] -> [h] hh::tt -> (h+hh) :: hh :: tt 1
4. let f4 f x y = f (x,y) int list -> int list Sommes cumulées décroissantes ( a * b -> c) -> a -> b -> c Curryfication Exercice 2 : λ-calcul (15 points) On rappelle que les booléens sont représentés en λ-calcul par les termes suivants : true = λxy.x et false = λxy.y. 1. Vérifier que λbuv.buv représente bien la fonction if thenelse, c est-à-dire que pour tous termes M et N : (λbuv.buv) true M N se β-réduit en M. (λbuv.buv) false M N se β-réduit en N. (λbuv.buv)true M N (λuv.true u v)m N (λv.true M v)n (λxy.x) M N (λy.m)n M (λbuv.buv)false M N (λuv.false u v)m N (λv.false M v)n (λxy.y) M N (λy.y)n N 2. Donner un terme not représentant la négation booléenne et vérifier que not true se β-réduit en false. not = λx.ifthenelsex false true = λx.x false true not true = (λx.x false true) true true false true (λy.false) true false 3. Donner un terme eq représentant l opérateur booléen d équivalence. eq = λxy.ifthenelsex y (not y) λxy.x y (not y) = λxy.x y (y false true) 2
Exercice 3 : Module (15 points) On donne la signature d un module Urne permettant de faire un vote à bulletin secret : Il y a deux candidats A et B. Chaque électeur est doté d un numéro entier, ce qui permet de s assurer qu un même électeur ne peut pas comptabiliser deux votes En cours de scrutin, un électeur peut changer d avis et re-voter (l ancien vote est alors détruit). On peut dépouiller l urne pour connaître les scores de chaque candidat et déterminer le vainqueur. Le type t est celui de l urne proprement dite. module type URNE = sig type electeur = int type candidat = A B type t ( type de l urne ) val vide : t val voter : electeur candidat t t val depouiller : t int int val vainqueur : t candidat end Dire pourquoi à l extérieur du module il n est possible à aucun moment de savoir qui a déjà voté, ni quel est le vote de quelqu un. Le type t est abstrait et les seules fonctions dans l interface qui fournissent une information lisible à partir de t sont dépouiller et vainqueur (le résultat de voter reste dans t) ; ces fonctions sont supposées n extraire qu une vue information globale, insuffisante pour analyser complètement un élément de t. Implémenter ce module. 3
module Urne : URNE = struct type electeur = int type candidat = A B type t = (electeur candidat) list let vide = [ ] let rec voter e c l = match l with [ ] [(e, c)] (eh, ch) :: t if eh = e then (eh, c) :: t else (eh, ch) :: (voter e c t) let rec depouiller l = match l with [ ] (0, 0) (eh, ch) :: t let (n, m) = depouiller t in match ch with A (n + 1, m) B (n, m + 1) let vainqueur l = let (n, m) = depouiller l in if n > m then A else B end Exercice 4 : Impératif (15 points) 1. Définir une fonction arraymap : ( a -> b) -> a array -> b array telle que arraymap f a construit un tableau dont les éléments sont ceux obtenus en appliquant la fonction f à chaque élément de a. let arraymap f a = let l = Array.length a in if l = 0 then [ ] else let b = Array.make l (f a.(0)) in for i = 0 to l 1 do b.(i) f (a.(i)) done ; b 2. Donner le type puis définir une fonction arrayexists telle que arrayexists p a détermine s il existe ou non un élément dans le tableau a qui vérifie le prédicat p. Une fonction qui ne parcourt pas tout le tableau si ce n est pas nécessaire rapportera un (petit) bonus de points. 4
arrayexists : ( a -> bool) -> a array -> bool let arrayexists p a = let i = ref 0 and e = ref false in while!i < Array.length a!e do e := p a.(!i); i :=!i + 1 done ;!e Problème (60 points) Dans ce problème on cherche à représenter de façon efficace un ensemble d intervalles d entiers disjoints deux à deux. On pourra ainsi représenter par exemple l affectation de tâches à un processeur, chaque intervalle représentant les cycles durant lesquels le processeur sera occupé par une tâche donnée. Le cycle d horloge étant la plus petite unité de temps, deux tâches ne pourront avoir un cycle en commun, même aux bornes des intervalles qui les décrivent. De même que pour les entiers, on imagine bien qu une liste triée d intervalles n est pas la structure la plus efficace, surtout dans la mesure où on voudra rechercher, insérer ou supprimer des intervalles. On considère donc des arbres binaires de recherche d intervalles (en abrégé ABRI), dont les nœuds sont étiquetés non plus par un entier mais par un intervalle d entiers (en pratique, ses bornes). On définit pour cela les types OCaml suivants : type intervalle = int * int type abri = F N of abri * intervalle * abri Dans tout l énoncé, on pourra supposer que les bornes des intervalles donnés en argument d une fonction sont en ordre croissant et qu il n y a donc pas à le vérifier. Les propriétés d un tel arbre sont très similaires à ceux des arbres binaires de recherche usuels. Pour tout nœud N(g, (i, s), d) de l arbre, on a : g et d sont des ABRI ; i s ; tous les intervalles de g ont des bornes strictement inférieures à i ; tous les intervalles de d ont des bornes strictement supérieures à s. On note qu un intervalle peut avoir des bornes égales (cas d un processus qui ne prend qu un seul cycle pour s exécuter). Ainsi l arbre suivant est un ABRI. [10; 13] [5; 5] [17; 28] [2; 4] [8; 9] 5
Exercice 5 : Manipulations simples (5 points) 1. Dans l ABRI ci-dessus, peut-on insérer les intervalles suivants? Si oui placez-les sur la figure, sinon expliquez rapidement pourquoi. [7; 8] [14; 15] [7; 8] n a pas sa place car il n est pas disjoint avec [8; 9] [14; 15] doit être inséré à gauche de [17; 28]. 2. Construisez graphiquement l ABRI obtenu en insérant successivement dans un arbre vide les intervalles [16; 18], [25; 30], [32; 36], [11; 11], [13; 14], [19; 22]. [16; 18] [11; 11] [25; 30] [13; 14] [19; 22] [32; 36] Exercice 6 : Accesseurs (10 points) 1. Définir une fonction inserable déterminant si un intervalle donné est insérable dans un ABRI. let rec inserable (i, s) a = match a with F true N (g, (inf, sup), d) if s < inf then inserable (i, s) g else if i > sup then inserable (i, s) d else false 2. Définir une fonction localiser : int -> abri -> intervalle option déterminant si un entier appartient à un intervalle de l arbre, et si oui lequel. 6
let rec localiser t a = match a with F None N (g, (inf, sup), d) if t < inf then localiser t g else if t > sup then localiser t d else Some (inf, sup) Exercice 7 : Insertion (15 points) 1. Définir une fonction insere permettant d insérer un intervalle dans un ABRI, si cela est possible. Dans le cas où l intervalle ne peut pas être inséré, on renverra l arbre passé en argument sans modification. let rec insere (i, s) a = match a with F N (F, (i, s), F) N (g, (inf, sup), d) if s < inf then N (insere (i, s) g, (inf, sup), d) else if i > sup then N (g, (inf, sup), insere (i, s) d) else N (g, (inf, sup), d) 2. On note nb noeuds(a) le nombre de nœuds d un arbre a. Démontrer que pour tout intervalle (i, s) et pour tout arbre a nb noeuds(a) nb noeuds(insere (i,s) a) nb noeuds(a) + 1 Par récurrence structurelle sur a : Si a = F alors insere (i,s) a possède 1 nœud et a en possède 0 : 0 1 0+1. Si a = N(g, (inf, sup), d) alors trois cas sont possibles : s < inf alors par HR l appel récursif insere (i,s) g produit un arbre dont le nombre de nœuds n est compris entre nb noeuds(g) et nb noeuds(g) + 1. L arbre que l on renvoie possède n + nb noeuds(d) + 1 nœuds, ce qui est donc bien compris entre nb noeuds(a) et nb noeuds(a) + 1. sup < i est similaire. inf s i sup d où il résulte que (i, s) n est pas insérable dans a. On renvoie alors a, la propriété est triviale dans ce cas. 7
Exercice 8 : Optimisation (20 points) 1. Écrire deux fonctions min et max déterminant la plus petite (respectivement la plus grande) borne de tous les intervalles présents dans un ABRI. let rec min a = match a with F failwith "Arbre vide" N (F, (inf, ), ) inf N (g, (, ), ) min g let rec max a = match a with F failwith "Arbre vide" N (, (, sup), F) sup N (, (, ), d) max d 2. Définir une fonction déterminant si un arbre d intervalles donné vérifie les propriétés des ABRI. Commenter l efficacité de votre solution. let rec verif a = match a with F true N (g, (inf, sup), d) verif g verif d (g = F max g < inf ) inf sup (d = F sup < min d) Les appels à min et max sont redondants, on calcule plusieurs fois la même chose : il faudrait les calculer à la volée. 3. Dans le cas où les tâches à effectuer sont indépendantes d autres tâches, on peut vouloir les effectuer le plus tôt possible. Définir une fonction calculant l ABRI obtenu en tassant les intervalles à gauche : l intervalle ayant les bornes les plus petites ne doit pas être modifié ; l intervalle suivant doit être décalé vers la gauche pour venir se juxtaposer au premier ; et ainsi de suite. Ainsi, avec l arbre donné en exemple en début de problème, les intervalles [2; 4] et [5; 5] sont inchangés, puis les suivants deviennent [6; 7], [8; 11] et [12; 23]. 8
let tasser a = let rec tasser min a m = match a with F F N (g, (inf, sup), d) let gg = tasser min g m in let mm = if gg = F then m 1 else max gg in N (gg, (mm + 1, sup inf + mm + 1), tasser min d (sup inf + mm + 2)) in tasser min a (min a) Exercice 9 : Analyse Syntaxique (10 points) On définit la grammaire suivante pour représenter des ABRI sous forme de flots de caractères (sans espaces) : S ::= () (S[int; int]s) La chaîne de caractères () représente l arbre vide ; dans le second cas, le non-terminal S situé entre la parenthèse et le crochet ouvrants représente le sous-arbre gauche et celui situé entre la parenthèse et le crochet fermants représente le sous-arbre droit. En pratique, on utilisera plutôt la grammaire suivante, équivalente mais non ambiguë : S ::= (S S ::= ) S[int; int]s) Écrire une fonction qui lit un flot de caractères respectant cette grammaire et l interprète comme un ABRI. Votre fonction ne réalisera que la construction de l arbre et ne s occupera pas de vérifier qu il respecte les propriétés d ABRI. On rappelle deux fonctions vues en TD/TP que vous êtes autorisés à utiliser : let int of digit c = int of char c int of char 0 let rec horner i = parser [ 0.. 9 as c ; n = horner (10 i + int of digit c) ] n [ ] i let rec abri parser = parser [ ( ; s ] apaux s and apaux = parser [ ) ] F [ g = abri parser ; [ ; inf = horner 0 ; ; ; sup = horner 0 ; ] ; d = abri parser ; ) ] N (g, (inf, sup), d) 9