Programmation fonctionnelle Langage Caml Licence 1 année

Programmation fonctionnelle
Langage Caml
Licence 1ère année
année 2016 - 2017
Annales
Pr. Nicole VINCENT
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
Table des matières
annales 2010-2011 ................................................................................... 3
CC1 ................................................................................................. 4
CC2 ................................................................................................. 6
CC4 ................................................................................................. 7
Session 2.......................................................................................... 9
annales 2011-2012 ................................................................................... 10
CC1 ................................................................................................. 11
CC2 ................................................................................................. 13
CC4 ................................................................................................. 15
Session 2.......................................................................................... 16
annales 2012-2013 ................................................................................... 17
CC1 ................................................................................................. 18
CC2 ................................................................................................. 19
CC4 ................................................................................................. 21
Examen de rattrapage ................................................................... 23
annales 2013-2014 ................................................................................... 24
CC1 ................................................................................................. 25
CC2 ................................................................................................. 27
CC4 ................................................................................................. 28
Examen de rattrapage ................................................................... 30
annales 2014-2015 ................................................................................... 32
CC1 ................................................................................................. 33
CC2 ................................................................................................. 35
CC4 ................................................................................................. 37
Examen de rattrapage ................................................................... 39
annales 2015-2016 ................................................................................... 41
CC1 ................................................................................................. 42
CC2 ................................................................................................. 44
CC4 ................................................................................................. 46
Examen de rattrapage ................................................................... 48
2
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
ANNALES
2010 - 2011
3
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
CC 1 (2010-2011)
Exercice 1
Expliquer l'interprétation faite pour les expressions suivantes :
a/
# let f x y = ( x+y , x > y ) ;;
val f : int -> int -> int * bool = <fun>
b/
# let tr x = match x mod 3 with
| 0 -> x
| 1 -> x-1
| 2 -> x+1 ;;
Warning 8: this pattern-matching is not exhaustive.
Here is an example of a value that is not matched:
3
val tr : int -> int = <fun>
c/
Calculer f 3 2
et tr 79
indiquer si les expressions suivantes sont syntaxiquement exactes ou non. On justifiera les
réponses.
d/
# let g x y = x+y x>y ;;
e/
# let h y = [x+y ; x > y] ;;
f/
# let fr x = if x > 50 then x - 3 else fr (x-3) ;;
Exercice 2
Ecrire une fonction booléenne qui permet de vérifier qu'un point connu par un couple de
coordonnées dans un repère (O;i,j), appartient à une droite d'équation ax+by+c=0. La droite
est connue par les trois valeurs a b et c.
On précisera le nombre d'arguments de la fonction.
On écrira l'appel à la fonction pour le point de coordonnées (0,5 ; 2) et la droite d'équation
x+y=0
Exercice 3
1°/ Ecrire une fonction maxi, avec deux arguments x et y, qui indique la variable la plus
grande.
2°/ Ecrire une fonction deliste qui à partir de deux listes, rend une liste dont les termes sont
les valeurs maximum des termes de même rang des deux listes. Les listes sont alignées par la
gauche.
3°/ Ecrire une fonction troiliste qui à partir de trois listes, rend une liste dont les termes sont
les valeurs maximum des termes de même rang dans les trois listes.
Exercice 4
Ecrire la fonction qui permet de calculer la somme des éléments d'une liste d'entiers, quand
les entiers sont pairs.
4
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
Exercice 5
Ecrire la fonction récursive qui permet, pour un entier n positif ou nul, de calculer en fonction
de n, les termes un d'une suite définie par une relation de récurrence :
Les valeurs des deux premiers termes u0 et u1 seront des paramètres de la fonction.
On veillera à ce que la fonction ne provoque pas un stack overflow pour une valeur négative
de n.
5
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
CC 2 (2010-2011)
Exercice 1
On considère la fonction suivante :
# let rec f x n = match n with | 0 -> 1
| n -> x*x*(f x (n-1)) ;;
1°/ Quel est son effet pour la valeur 2 5 ?
2°/ Ecrire une version terminale de cette fonction.
Exercice 2
Ecrire une fonction sous forme récursive terminale qui construit la liste des entiers compris
entre deux entiers donnés. La fonction nommée entiers admet deux arguments.
Exercice 3
1°/ Ecrire une fonction maxi0 qui calcule le maximum des éléments d'une liste d'entiers
positifs.
On donnera de cette fonction, deux versions différentes (maxi0 une version non terminale et
maxi1 une version terminale).
2°/ Ecrire une fonction maxi2 qui calcule le maximum des éléments d'une liste d'entiers
positifs ou négatifs.
3°/ En intégrant l'une des fonctions précédentes écrire une fonction nbmax, sous forme
terminale, qui a pour résultat le nombre d'éléments atteignant le maximum dans la liste des
entiers en argument de la fonction.
Exercice 4
1°/ En utilisant un filtrage (match) écrire une fonction milieu qui permet d'extraire le
deuxième élément d'un triplet x.
On considère maintenant des listes dont les éléments sont des couples. Chaque couple est
constitué d'une chaîne et d'un entier. Un exemple la de liste : [ (‟aa” , 105) ; (‟caml” , 18) ]
On considèrera que sont définies les fonctions c1 et c2 qui renvoient respectivement le
premier et le second argument d'un couple. Ces deux fonctions pourront être utilisées dans la
suite de l'exercice.
2°/ Ecrire une fonction premier qui à partir d'une liste de couples, crée la liste des premiers
termes des couples.
Avec l'exemple, pour la liste la, le résultat est [ ‟aa” ; ‟caml” ]
Ecrire une fonction second qui, à partir d'une liste de couples, crée la liste des seconds termes
des couples.
Avec l'exemple, pour la liste la, le résultat est [ 105 ; 18 ]
3°/ Ecrire une fonction construit, qui constitue une liste de couples à partir de deux listes de
même longueur, une liste de chaînes et une liste d'entiers.
4°/ On considère deux listes de même nature que la liste la et on suppose que les éléments
sont classés en suivant l'ordre alphabétique du premier terme du couple, comme cela est le cas
dans la. Ecrire une fonction mixte qui réunit les deux listes en respectant cet ordre.
Soit une seconde liste lb : [ (‟av” , 15) ; (‟bb” , 184) ]
le résultat de la réunion avec la est : [ (‟aa” , 105) ; (‟av” , 15) ; (‟bb” , 184) ; (‟caml” , 18) ]
6
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
CC 4 (2010-2011)
Dans une bibliothèque il est nécessaire de gérer les livres et les lecteurs inscrits.
Les livres sont indexés par un code qui est une chaîne de caractères, le nom de l'auteur, le
titre, le type du livre, la date d'acquisition et le statut (un booléen qui indique si le livre est
emprunté ou non : vrai ou faux).
Le genre du livre peut être : roman, policier, historique, jeunesse ou documentaire.
La date sera écrite sous la forme d'un triplet d'entiers (16,5,2011)
En ce qui concerne les lecteurs, il est nécessaire de connaître, leur numéro de lecteur, leur
age, la liste des codes des livres (leur code) empruntés avec la date d'emprunt associée.
1°/
a/ Ecrire la définition d'un type énuméré nommé t_genre qui modélise les différentes
possibilités pour le genre des livres.
b/ Ecrire la définition d'un type d'enregistrement nommé t_livre qui permet d'indexer un
livre.
Exemple :
ANV24
ANVALIN
un jour nouveau
Jeunesse
9,4,2005
True
c/ Ecrire la définition d'un type d'enregistrement nommé t_lecteur qui permet de regrouper
les informations propres au lecteur.
Exemple :
4653
21
ANV24 (25,2,2011) RIN1 (4,3,2011)
2°/
a/ Ecrire une fonction nbliv1 qui calcule le nombre total des livres empruntés, l'argument de
la fonction étant une liste dont les éléments sont de type t_livre.
b/ Ecrire une fonction nbliv2 qui calcule le nombre des livres empruntés par les lecteurs
enregistrés dans une liste dont les éléments sont de type t_lecteur. Cette liste sera donnée en
argument de la fonction.
3°/ Ecrire une fonction auteur dont l'argument est une liste dont les éléments sont de type
t_livre et dont le résultat est la liste des auteurs dont au moins un livre est emprunté. La liste
résultat ne doit comporter qu'une seule fois le nom d'un auteur.
On donnera deux versions de cette fonction, dont une version auteur2 récursive terminale.
4°/ Ecrire une fonction booléenne teste dont l'argument est un numéro de lecteur et qui
indique si la personne a un livre en emprunt.
T.S.V.P.
7
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
On suppose connue la fonction date qui transforme une date écrite sous forme de triplet en un
entier qui indique le numéro du jour depuis le 1er janvier de l'année en cours.
Exemple le résultat de la fonction appliquée au triplet (16,5,2011) est 136.
5°/ Ecrire une fonction emprunt7 qui construit la liste des codes des livres empruntés
pendant les 7 jours précédents. La fonction devra avoir deux paramètres, une liste dont les
éléments sont de type t_livre et une date sous forme d'un triplet. On supposera que la date
n'est pas comprise entre le 1er et le 8 janvier.
6°/ Ecrire une fonction nblect qui calcule le nombre de lecteurs dont l'age est supérieur à un
entier donné en argument de la fonction qui n'ont pas de livre emprunté.
7°/ On dispose de deux listes la et lb dont les éléments sont de type t_livre. Ecrire une
fonction doubleli qui construit la liste des livres communs aux deux listes, un livre est
commun s'il y a le même auteur, le même titre et la même date d'acquisition.
Puis une fonction simple qui permet de réunir les deux listes en supprimant les livres
communs seulement si le statut est le même dans les deux listes.
8°/ Ecrire une fonction memeauteur qui construit une liste de couples (auteur, titre) des
livres du même auteur que les livres empruntés par un lecteur dont le numéro de lecteur est
l'argument de la fonction.
8
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
Examen (2010-2011)
Session 2
Exercice 1
1° Ecrire une fonction booléenne grand qui indique si le maximum d’une liste est supérieur à
une valeur. La fonction aura donc deux arguments, la liste et la valeur.
2° Ecrire une fonction maxi2 qui calcule le maximum des valeurs obtenues en faisant la
somme de deux termes consécutifs dans une liste d’entiers qui par hypothèse comporte au
moins deux éléments.
On donnera deux versions dont l’une récursive terminale.
3°/ Ecrire une fonction double qui, à partir de deux listes d’entiers, renvoie une nouvelle liste
dont les éléments sont définis comme la somme des éléments de même rang dans les deux
listes, rang compté à partir de la gauche.
Exemple : pour deux listes l1 :
25 8
l2 :
3 8 15 17
le résultat est la liste contenant
5 13 23 17
Exercice 2
On considère le type défini par le code suivant :
# type t_exo = {num1 : int ; num2 : int ; liste : (string * (int * int * int) ) list } ;;
1°/ Indiquer parmi les expressions suivantes celles qui sont valides pour une variable x de
type t_exo. Si l’expression n’est pas valide, expliquer pourquoi. Si l’expression est valide,
indiquer son type.
a.
(x.num1 , x.num2)
b.
x. liste
c.
(x.liste ; x.num1)
d.
x.liste(c,d)
2°/ Ecrire une instruction qui initialise une variable element de type t_exo avec les valeurs
suivantes :
4653
21
ANV24 (25,2,2011) RIN1 (4,3,2011)
3°/ Ecrire une fonction nombre dont l’argument est de type t_exo et dont le résultat est le
nombre de chaînes de la liste qu’il contient.
4°/ Ecrire une fonction chaine dont l’argument est de type t_exo et dont le résultat est la
chaîne vide si le résultat de la fonction précédente sur l’argument est vrai et il est la chaîne
contenue dans le premier élément de la liste dans le cas contraire.
Exemple : le résultat de chaine element est la chaîne ANV24
5°/ On considère maintenant une liste d’éléments de type t_exo. Ecrire une fonction qui
compte le nombre de chaînes contenues dans cette liste d’éléments de type t_exo.
6°/ Etant donné deux listes dont les éléments sont de type t_exo, écrire une fonction
booléenne qui vérifie que tous les éléments de la première liste sont présents dans la seconde
et réciproquement.
9
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
ANNALES
2011 - 2012
10
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
CC 1 (2011-2012)
Exercice 1
Expliquer l'interprétation faite pour les expressions suivantes :
a/
# let f (x,y) (u,v) z = x+y+z ;;
val f : int * int -> 'a * 'b -> int -> int = <fun>
b/
# let tr x = match x mod 3 with
| 0 -> x
| 1 -> x-1
| 2 -> x-2 ;;
Warning 8: this pattern-matching is not exhaustive.
Here is an example of a value that is not matched:
3
val tr : int -> int = <fun>
On proposera une version qui a le même effet mais sans l’affichage du warning.
indiquer si les expressions suivantes sont syntaxiquement exactes ou non. On justifiera les
réponses, soit par un commentaire et une version syntaxiquement exacte, soit par une
indication d’une interprétation dans le cas où la syntaxe est exacte.
c/
# let g x y = (x = 0. , y < 0 , x + y) ;;
d/
# let h y = [y + 2 ; 2 > y] ;;
e/
# let fr x y = match x y with | 3 2 -> x+y
| 5 6 -> x+5
| _ -> x - y ;;
Exercice 2
1°/ On considère des triplets contenant une chaîne et deux réels. Ecrire une fonction
trans3to2 admettant x pour argument, qui transforme un tel triplet en un couple qui contient
la chaîne et la somme des deux réels.
Ainsi ( ‟caml‟, 2.4 , 5.1) est transformé en ( ‟caml‟, 7.5 )
2°/ Un couple contient une chaîne et un réel. Ecrire une fonction trans2to3 admettant c pour
argument, qui transforme un tel couple en un triplet qui contient la chaîne, le réel et un second
réel égal à la somme du premier réel et de la longueur de la chaîne.
Ainsi ( ‟caml‟, 2.4 ) est transformé en ( ‟caml‟, 6.4 )
Tournez S.V.P.
11
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
Exercice 3
1°/ Ecrire une fonction compte qui détermine le nombre d’occurrences d’une valeur donnée
en paramètre dans une liste second argument de la fonction.
2°/ En utilisant la fonction compte écrire une fonction membre qui a le même effet que la
fonction appartient.
3°/ Sans utiliser la fonction List.mem, écrire une fonction booléenne appartient admettant
deux arguments qui teste si une valeur x appartient à la liste second argument de la fonction.
Exercice 4
On veut étudier l'équation, être capable de vérifier que des valeurs sont solutions de (1)
ax2 + by2 + cxy + d=0.
(1)
Cette équation est caractérisée par les quatre valeurs a b c et d.
1°/ Ecrire une fonction qui calcule le premier membre de l’équation (1). On écriera deux
solutions equa1 et equa2 ayant respectivement 6 et 2 arguments. Dans le cas de deux
arguments, le premier caractérisera les valeurs x et y, le second caractérisera l’équation par
ses 4 coefficients.
2°/ Ecrire une fonction booléenne solution dont les 2 arguments sont d’une part les valeurs
de x et y et d’autre part une fonction f d’un argument. La fonction solution indique si les
valeurs x et y vérifient f(x,y)=0
l’appel de la fonction prend la forme solution cc f
3°/ En utilisant la fonction solution
- vérifier si x=3 et y = 2 est solution de l’équation 2 x2 - y2 + xy - 5 = 0
- vérifier si x=2 et y = 2 est solution de l’équation x2 - y2 + xy - 4 = 0.
12
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
CC 2 (2011-2012)
Exercice 1
Indiquer si les expressions suivantes sont syntaxiquement exactes ou non. On justifiera les
réponses, soit par un commentaire et une version syntaxiquement exacte, soit par une
indication d’une interprétation dans le cas où la syntaxe est exacte.
a/
let f x = match x with
| (a,b) -> a
| _ -> x ;;
b/
let rec g l = match l with
| [ ] -> 0
| h1 ::h2 ::t -> h1 + g t ;;
c/
let d h x = h x - h (x+1) ;;
Exercice 2
On considère la fonction suivante :
# let rec f x n = match n with | 0 -> ""
| _ -> x^(f x (n-1)) ;;
1°/ Quel est son effet pour la valeur "B" 7 ?
2°/ Ecrire une version terminale de cette fonction.
Exercice 3
Ecrire une fonction inverse ayant en argument une liste et dont le résultat est la liste
contenant les mêmes éléments dans le sens inverse.
On donnera deux versions dont une sous forme récursive terminale.
Exercice 4
On considère des triplets qui contiennent dans cet ordre un entier, un booléen et un réel, par
exemple (4 , true , 2.6).
1°/ Ecrire une fonction second dont l’argument est un tel triplet noté tr, et dont le résultat est
la valeur du booléen du triplet.
Appliquée à l’exemple précédent le résultat est true.
2°/ Ecrire une fonction somme dont l’argument est une liste de tels triplets et dont le résultat
est la somme des réels des triplets dont le deuxième élément est vrai. On donnera une version
récursive terminale de cette fonction.
Exemple : si l = [(62 , true , 2.1) ; (13 , false , 3.4) ; (2 , true , 5.2) ] l’application de somme
donnera 7.3.
Tournez S.V.P.
13
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
3°/ Ecrire une fonction reduit dont l’argument est une liste de triplets et dont le résultat est
une liste réduite aux triplets ayant un premier élément pair. On demande ici une solution
récursive terminale.
Exemple : avec la même liste l, le résultat est : = [(62 , true , 2.1) ; (2 , true , 5.2) ]
4°/ Ecrire une fonction fusion qui admet en argument deux listes de triplets et dont le résultat
est la liste de triplets obtenue en additionnant les troisièmes termes des triplets, s’ils ont même
premier terme et en effectuant un ou logique entre les deuxièmes termes. Les termes de la liste
n’ayant pas de correspondant dans l’autre liste seront recopiés dans la liste résultat.
On pourra commencer par ordonner les listes suivant la valeur du premier terme des triplets.
Exemple : si les arguments sont l et ll égale à [(1 , false , 12.1) ; (13 , false , 31.4) ; (2 , false ,
7.2) ], le résultat est : [(1 , false , 12.1) ; (2 , true , 12.4) ; (13 , false , 34.8) ; (62 , true , 2.1) ]
14
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
CC 4 (2011-2012)
Dans tout les cas, une solution récursive devra être sous forme terminale.
Exercice 1
On définit les types
t_info3 = (string * int *float) list
t_exo = {info1 : int ; info2 : int ; info3 : t_info3} ;;
1°/ Indiquer parmi les expressions suivantes celles qui sont valides pour une variable x de
type t_exo. On justifiera les réponses, soit par un commentaire et une version syntaxiquement
exacte, soit par une indication d’une interprétation dans le cas où la syntaxe est exacte.
a.
(x.info1 , x.info2)
b.
x. list
c.
(x.info3 ; "university")
d.
let f a y z = if a y then match (z.info3,y.info3) with (c,i,r),(cc,ii,rr) -> r +. rr ;;
2°/ Ecrire une fonction qui permet de concaténer toutes les chaînes contenues dans un
argument de type t_info3.
3°/ Même question en considérant que l’argument est de type t_exo.
Exercice 2
Une culture est caractérisée par son nom, la date de plantation, la superficie cultivée, la date
de récolte, les dépenses de culture, le prix de vente. On suppose qu’a été défini le type t_date.
type t_date = {jour : int ; mois : int ; annee : int}
1°/ Définir un type enregistrement t_culture à 6 champs qui traduit cette information.
2°/ Ecrire une fonction anterieur booléenne qui vérifie que deux dates sont dans l’ordre
chronologique.
Ecrire une fonction coherent booléenne qui vérifie, pour une culture donnée de type
t_culture, que la date de récolte est postérieure à la date de plantation.
3°/ Ecrire une fonction rendement qui indique, pour une culture donnée de type t_culture, le
bénéfice relativement à la superficie cultivée.
Une ferme est caractérisée par une liste d’enregistrements de type t_culture.
4°/ Ecrire une fonction culture qui établit, pour une ferme donnée, la liste des noms des
cultures de bénéfice positif.
5°/ Ecrire une fonction benefice qui établit le bénéfice cumulé d’une ferme.
6°/ Ecrire une fonction present qui vérifie qu’une culture indiquée par son nom est présente
dans une ferme. Un appel pourrait être : present "carotte" x
7°/ Ecrire une fonction fusion qui permet d’établir la liste des cultures présentes dans deux
fermes. La liste résultat, liste de chaînes, ne devra pas comporter de doublon.
Généraliser la fonction à la fusion d’une liste de fermes. On écrira la fonction union.
15
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
Examen – Session 2 (2011-2012)
Dans tous les cas, une solution récursive devra être sous forme terminale.
Exercice 1
On considère la fonction f définie récursivement par :
let rec f x = if x = 0 then 2 else 3 * f (x-1) - 1
Ecrire une nouvelle version ft de cette fonction sous forme récursive terminale.
Exercice 2
Des notes sont données sous forme d’une des 5 valeurs symboliques traduisant qu’un travail
est très bien, bien, passable, insuffisant, très insuffisant.
1°/ Définir un type enuméré t_symbol qui traduit cette information.
2°/ Ecrire une fonction reel_of_symbol qui traduit une valeur symbolique en note numérique
réelle. On associera 18 à très bien, 14 à bien, 10 à passable, 6 à insuffisant, 2 à très insuffisant.
Ecrire une fonction superieure booléenne qui vérifie, pour une note donnée de type
t_symbol, qu’elle correspond à une note supérieure ou égale à une valeur réelle x donnée.
3°/ Ecrire une fonction symbol_of_reel qui indique, pour une note numérique réelle, la valeur
symbolique correspondante. Chaque valeur symbolique est associée à un segment
d’amplitude 4 dont la valeur représentative est le centre. [20 , 16] ; ]16 , 12] ; ]12 , 8] ; ]8 , 4] ;
]4 , 0] . On utilisera la division de la note par 4.
Un étudiant est caractérisé par un enregistrement à deux champs, l’un indique le nom de
l’étudiant, l’autre indique sa note de type t_symbol.
Un groupe est caractérisé par une liste d’étudiants.
Une promotion est caractérisée par une liste de groupes
4°/ Définir un type enregistrement t_etudiant qui traduit l’information associée à un étudiant.
5°/ Ecrire une fonction present booléenne qui teste si un étudiant donné par son nom est dans
un groupe.
6°/ Ecrire une fonction admis_gr dont le résultat est le nombre d’étudiants d’un groupe donné
qui ont obtenu une note symbolique très bien, bien ou passable.
7°/ Ecrire une fonction moyenne qui établit, pour un groupe donné, la moyenne numérique
réelle associée à ce groupe.
8°/ On suppose que la liste des étudiants dans un groupe est classée par ordre alphabétique des
noms. Ecrire une fonction liste_admis dont l’argument est un groupe et dont le résultat est la
liste des noms des étudiants ayant obtenu très bien, bien ou passable, la liste devra respecter
l’ordre alphabétique initial.
9°/ Ecrire une fonction meilleure dont l’argument est une promotion et qui a pour résultat la
meilleure moyenne numérique obtenue par un groupe.
10°/ Ecrire une fonction admis_promo qui indique, pour une promotion donnée, le nombre
d’étudiants ayant obtenu une note symbolique très bien, bien ou passable.
16
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
ANNALES
2012 - 2013
17
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
CC 1(2012-2013)
Exercice 1
Expliquer l'interprétation faite pour les expressions suivantes, on précisera dans les deux cas
le nombre d’arguments et le type du résultat de toutes les fonctions rencontrées.
a/
# let fa (x,y,z) = x > y && x < z ;;
val fa : 'a * 'a * 'a -> bool = <fun>
b/
# let fb a (x , y ) = if a y then x else match x with | b,c -> (b+y , c+y) ;;
val fb : (int -> bool) -> (int * int) * int -> int * int = <fun>
indiquer si les expressions suivantes sont syntaxiquement exactes ou non. On justifiera les
réponses, soit par un commentaire et une version syntaxiquement exacte, soit par une
indication d’une interprétation dans le cas où la syntaxe est exacte.
c/
# let fc x y = if (x < 0) && (y > sqrt(2.)) then y else x ;;
d/
# let fd a b c d = a c + if d = (0,0) then 1 else b d ;;
e/
# let fe x y = match x y with | 3 2 -> x+y
| 5 6 -> x+5
| _ -> x - y ;;
Exercice 2
La fonction implique est une fonction dont les arguments sont deux booléens et dont le
résultat est vrai dans tous les cas sauf si le premier argument est vrai et le second faux. Ecrire
la fonction implique.
Exercice 3
1°/ Ecrire une fonction test dont le résultat est l’entier 0 , 1 ou 2 selon que l’argument entier
de la fonction est négatif ou nul, compris entre 0 et 10, ou supérieur ou égal à 10.
2°/ Ecrire une fonction somme avec deux arguments qui permet de faire la somme termes à
termes de deux triplets d’entiers. On nommera les 2 arguments de la fonction x, y.
somme (1,2,3) (4,0,7) = (5,2,10)
3°/ En utilisant un filtre et sans utiliser de conditionnelle (if…then…else) écrire une fonction
add qui calcule
- la somme des deux triplets si la somme des éléments du premier triplet est négative ou
nulle,
- la somme du premier et de deux fois le second si la somme des éléments du premier
triplet est supérieure ou égale à 10,
- la somme du premier et de trois fois le second si la somme des éléments du premier
triplet est comprise entre 0 et 10.
On utilisera les fonctions somme et test.
Exemple :
add (1,1,-10) (1,1,1) = (2,2,-9)
add (1,1,10) (1,1,1) = (3,3,12)
add (1,1,5) (1,1,1) = (4,4,8)
18
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
CC 2 (2012-2013)
Exercice 1
Indiquer si les expressions suivantes sont exactes ou non. On justifiera les réponses, soit par
un commentaire et une version exacte, soit par une indication d’une interprétation dans le cas
où la syntaxe est exacte.
a/
let rec g l = match l with
| [ ] -> 0
| (a,0) :: t -> a + g t
| (0,b) :: t -> b + g t
| _ :: t -> b + g t ;;
b/
let h a b c = let (x , y) = a in if b c then x + y else c+y ;;
Exercice 2
On considère la fonction suivante :
# let rec f l = match l with | [ ] -> 0
| [h] -> h
| h1 :: h2 :: t -> h1 + f t ;;
1°/ Quel est son effet pour la valeur [ 3 ; 2 ; 8 ; 51 ; 1 ; 21 ] ?
2°/ Ecrire une version terminale de cette fonction.
Exercice 3
1°/ Ecrire une fonction somparite dont l’argument est une liste d’entiers et dont le résultat est
un couple dont le premier élément est la somme des éléments pairs de la liste et le second est
la somme des éléments impairs de la liste.
On donnera deux versions récursives dont une sous forme récursive terminale.
Exemple somparite [5 ; 8 ; 5 ; 5 ; 3 ; 2] = (18,10)
Exercice 4
Dans cet exercice, les couples, arguments des fonctions, ne seront pas décomposés.
1°/ Ecrire deux fonctions premier et second dont l’argument est un couple noté x, et dont le
résultat est la valeur respectivement du premier ou du second élément du couple.
Dans la question 2 les couples sont des couples d’entiers
2°/ Ecrire une fonction addcouple dont l’argument est une liste de couples d’entiers et dont le
résultat est un couple dont les éléments sont les sommes respectives des premiers et seconds
éléments des couples.
On donnera deux versions dont une utilisant la fonction List.map et l’autre sous forme
récursive de votre choix.
Exemple addcouple [(5,8) ; (5,5) ; (3,2)] = (13,15)
Tournez S.V.P.
19
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
Dans les questions 3 et 4 les couples ont un premier élément entier et un second élément
booléen
3°/ Ecrire une fonction reduit dont l’argument est une liste de couples et dont le résultat est
une liste réduite aux entiers des couples dont le second argument est vrai. On demande ici une
solution récursive terminale.
Exemple : avec la liste l= [(62 , true ) ; (13 , false ) ; (2 , true ) ], le résultat est : [62 ; 2 ]
4°/ Ecrire une fonction cohérent qui admet en argument une liste de couples et qui vérifie
qu’aucun entier ne figure plusieurs fois avec des éléments booléens différents.
Il est possible d’utiliser des fonctions du module List.
Exemple :
pour [(1 , true) ; (1 , false) ; (2 , false ) ], le résultat est faux ;
pour [(1 , false ) ; (2 , true ) ; (1 , false ) ; (62 , true ) ], le résultat est vrai.
20
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
CC 4 (2012-2013)
Dans tous les exercices l’utilisation des fonctions présentes dans le module List est autorisé.
Exercice 1
On considère la fonction suivante :
# let f liste x = let rec ff acc ll xx = match ll with | [ ] -> acc
| h :: t -> ff (acc && (h.nom = xx || (h.off = h.on))) t xx
in ff true liste x ;;
1°/ Quand l est défini par la valeur [ {nom= "a" ; off = 25 ; on = 25 ; res = (true,3)} ;
{nom="aa" ; off = 25 ; on = 32 ; res = (false,54)} ; {nom="aaa" ; off= 32 ; on = 32 ; res =
(true,-21)} ], quel est l’effet de l’expression
a/ f l "aa"
b/ f l "aaa"
2°/ Ecrire un type nommé t_donnee qui corresponde à celui des éléments de la liste
considérée dans la fonction f.
Exercice 2
De manière à travailler avec des températures exprimées selon le cas en degrés Celsius ou en
degrés Fahrenheit on considère une structure de couple dont le premier élément est un
élément de type énuméré comportant deux valeurs associées à Celsius et à Fahrenheit
respectivement et le second élément est un réel, la valeur de la température exprimée dans
l’échelle mentionnée par le premier élément.
1°/ Ecrire une définition du type énuméré appelé t_degre.
2°/ Le lien entre la valeur C d’une température exprimée en degrés Celsius et la valeur F de la
même température exprimée en degrés Fahrenheit est donné par les relations :
9
5
! = 32 + ! !" ! = ! − 17,78
5
9
Ecrire une fonction conversion transformant une température exprimée par un couple en un
couple relevant de l’autre système.
Ecrire l’appel de fonction qui permet de connaître en degrés Celsius l’équivalent de 100
degrés Fahrenheit.
3°/ Ecrire une fonction booléenne superieur qui permet de comparer deux températures
exprimées par un couple.
Tournez S.V.P.
21
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
Exercice 3
Dans cet exercice on considère le type t_individu défini par :
type t_individu = {indent : string ; age : int ; resultat : int list}
1°/
a/ Ecrire une fonction complet dont l’argument ind est de type t_individu et qui aura pour
résultat un couple. Le premier élément du couple sera égal à la moyenne des éléments
contenus dans le champ resultat de l’argument et le second élément du couple aura pour
valeur la liste du champ résultat.
b/ Ecrire une fonction creer dont l’argument li est une liste d’éléments de type t_individu et
dont le résultat est la liste des moyennes associées à chaque élément de la liste li.
2°/ Ecrire une fonction maximum qui permet de trouver le maximum d’une liste de réels,
ceux-ci pouvant être positifs ou négatifs.
On donnera deux solutions dont une sous forme récursive terminale.
3°/ Ecrire une fonction moyenne qui calcule, étant donnée une liste d’éléments de type
t_individu, la meilleure moyenne. (On pourra utiliser les fonctions écrites précédemment)
4°/ Ecrire une fonction meilleur dont l’argument li est une liste d’éléments de type t_individu
et qui aura pour résultat la liste résultat associée à un individu qui a la meilleure moyenne
dans la liste li.
22
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
Session de rattrapage (2012-2013)
Dans tous les exercices l’utilisation des fonctions présentes dans le module List est autorisé.
Exercice 1
On considère la fonction f suivante :
let rec f l = match l with | [ ] -> [ ]
| h :: t -> (if (h mod 2) = 0 then (5 + (h / 2)) else (2 * h)) :: (f t) ;;
1°/ Quel est son effet pour la valeur [ 3 ; 2 ; 8 ; 1 ; 21 ] ?
2°/ En créant une fonction intermédiaire finter à définir, simplifier l’écriture de la fonction f.
3°/ Ecrire une fonction fterm sous forme terminale dont l’effet est le même que celui de la
fonction f.
4°/ Ecrire une fonction fmap dont l’effet est le même que celui de la fonction f et utilisant la
fonction List.map
Exercice 2
1°/ Ecrire une fonction supprime dont les deux arguments sont des listes l1 et l2 et qui
supprime de la liste l2 les éléments contenus dans la liste l1. (On ne conservera donc de la
liste l2 que les éléments qui ne sont pas dans l1)
si la liste l1 est égale à [3; 5; 2; 1] et la liste l2 à [4; 2; 9], le résultat sera [4; 9]
2°/ On considère le type t_donnee défini par
type t_donnee = {info1: string ; info2 : int ; info3 : float}
écrire une fonction booléenne appartient qui vérifie qu’un élément de type t_donnee dont le
champ info1 est égal à la valeur a, appartient à une liste liste d’éléments de type t_donnee. a
et liste sont les deux arguments de la fonction appartient.
On donnera deux versions dont une version récursive terminale.
3°/ Ecrire une fonction simplifie qui supprime des éléments dans une liste dont les éléments
sont de type t_donnee de manière à ce que tous les éléments aient des valeurs de champ info1
toutes différentes.
4°/Ecrire une fonction fusion dont les deux arguments sont des listes d’éléments de type
t_donnee et dont le résultat est une liste de même type qui fait la fusion des deux listes mais
dont les éléments ont des valeurs de champ info1 toutes différentes.
23
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
ANNALES
2013 - 2014
24
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
CC 1 (2013-2014)
Exercice 1
1°/ Indiquez l'interprétation des expressions suivantes :
# let x = 4;;
# let g x = x + 3;;
# let f x y =
match x > y with
| true -> x
| false -> y;;
Indiquer les valeurs de :
f "cc" "exam" ;;
f (g x) 1;;
2°/ Donner les interprétations correspondant aux expressions suivantes.
a/
# let fa x y = ( 3 * x , x = y , 5 * y) ;;
b/
# let fb g x (y,z) = ( g x , x = (y > z) );;
c/
# let fc a b c d = a b c + if d = (0,0) then b c else c;;
Exercice 2
1°/ Ecrire une fonction ttc qui calcule un prix TTC en fonction de deux arguments, le prix HT
de l’objet et sa catégorie 1, 2 ou 3 . Les pourcentages de TVA s'appliquent en fonction de la
catégorie et ont respectivement pour valeur 5% , 7% et 20%.
2°/ Ecrire l’appel à la fonction ttc pour un objet appartenant à la catégorie 3 dont le prix HT
est égal à cinquante euros.
25
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
Exercice 3
1°/ Ecrire la définition d’une fonction qui commence par let f (x,y) =
où x et y sont des triplets d’entiers et dont le résultat est le triplet des produits termes à termes
des deux triplets en arguments.
f (3 , 2, 5) (5 , 2 , 1) donne le résultat (15 , 4 , 5)
2°/ Ecrire la définition d’une fonction fpro, similaire à la précédente, qui comporte un
argument de plus permettant de remplacer le produit par une autre fonction, par exemple la
somme de 2 réels.
En utilisant les fonctions produit_int et somme_float suivantes indiquer deux appels à cette
fonction fpro.
# let produit_int x y = x * y ;;
val produit_int : int -> int -> int = <fun>
# let somme_float x y = x +. y ;;
val somme_float : float -> float -> float = <fun>
Exercice 4
Les résultats d’un pays aux jeux olympiques sont représentés par un couple dont le premier
terme est le nom du pays dans une chaîne, le second est un triplet qui contient pour le pays le
nombre de médailles respectivement d’or, d’argent et de bronze.
1°/ Ecrire une fonction competent à 2 arguments qui indique le meilleur de deux pays, en
classant les pays suivant le nombre total de médailles. Le résultat de la fonction sera une
chaîne. En cas d’égalité on concatènera les chaînes des deux pays en les séparant par et
2°/ Ecrire une fonction meilleur à 2 arguments qui indique le meilleur de deux pays, en
classant suivant le nombre de médailles d’or, puis le nombre de médailles d’argent, puis le
nombre de médailles de bronze. Le résultat de la fonction sera une chaîne. En cas d’égalité on
concatènera les chaînes des deux pays en les séparant par et
26
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
CC 2 (2013-2014)
Exercice 1
Indiquez l'interprétation de l’expression suivante :
# let fc a b c d = a b c + if d = (0,0) then b c else c;;
Exercice 2
Ecrire une fonction compte qui calcule le nombre d’éléments égaux à une valeur donnée dans
une liste.
On donnera deux versions dont une récursive terminale
Exercice 3
On considère déjà définie la fonction plus définie par
# let add (x1,x2) (y1,y2) = (x1+y1),(x2+y2) ;;
val add : int * int -> int * int -> int * int = <fun>
Elle calcule la somme terme à terme de deux couples d’entiers
1°/ On a défini la fonction som suivante :
# let rec som l = match l with | [ h] -> if ((h mod 2) = 0 ) then (h,0) else (0,h)
| h :: t -> if ((h mod 2) = 0 ) then add (h,0) (som t) else add (0,h) (som t) ;;
Quel est l’effet de cette fonction sur la valeur de l’argument [ -5 ; 7 ; 3 ; 10 ; 4] ;;
2°/ Ecrire une version terminale de cette fonction.
Exercice 4
1°/ Ecrire une fonction add_debut ayant deux arguments une liste et un élément et qui permet
d’ajouter cet élément en tête de la liste
2°/ Ecrire une fonction add_fin ayant deux arguments une liste et un élément et qui permet
d’ajouter cet élément en tête de la liste
3°/ Ecrire une fonction fusion ayant deux arguments liste que l’on supposera de même type et
qui permet d’insérer les éléments de la première alternativement au début et en fin de la
seconde liste.
a = [5 ; 8 ; 2 ; 1] ;;
b = [ -5 ; 7 ; 3 ; 10 ; 4] ;;
fusion a b donne [2; 5; -5; 7; 3; 10; 4; 8; 1]
4°/ Ecrire une fonction maximum ayant un argument liste et dont le résultat est le maximum
des éléments de la liste.
On donnera deux versions de cette fonction dont une sous forme récursive terminale.
27
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
CC 4 (2013-2014)
Exercice 1
On considère la fonction suivante :
# let rec f liste x1 x2 = let rec ff acc ll xx = match ll with | [ ] -> acc
| [h] -> if h > xx then acc + h else acc
| h1::h2 :: t -> ff (if h1 > xx then acc+h1 else acc) t xx
in match liste with | [ ] -> 0
| h:: t -> if h.nom = x2 then ff 0 h.valeur x1 else f t x1 x2 ;;
1°/ Soit l la liste définie par la valeur :
[ {nom= "a" ; hauteur = 25 ; valeur = [25 ; 4 ; 1 ; 7 ; 8 ; 22 ; 7 ] ; res = (true,3)} ; {nom="aa" ;
hauteur = 2 ; valeur = [2 ; 4 ; 12 ; 17 ; 83 ; 22 ] ; res = (false,54)} ; {nom="aaa" ; hauteur
= 25 ; valeur = [5 ; 14 ; 10 ; 7 ; 18 ; 22 ; 7 ; 1 ; 3 ]; res = (true,-21)} ].
Quel est l’effet de l’expression f l 5 "aa" ;;
2°/ Ecrire un type nommé t_donnee qui corresponde à celui des éléments de la liste nommée
liste dans les arguments de la fonction f.
Tournez S.V.P.
28
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
Exercice 2
Les recettes de cuisine peuvent exprimer les masses en grammes mais pour certains
ingrédients la quantité peut être exprimée en cuillerées. De manière à unifier les programmes
relatifs à une recette on définit un type masse par :
type t_masse = Gram of int | Cuiller of int ;;
Une recette est donnée avec la quantité d’ingrédients nécessaires pour 6 personnes. Le type
associé est défini par :
type t_recette = {farine : t_masse ; sucre : t_masse ; beurre : t_masse ; oeuf : int ; sel :
t_masse ; arome : string * int}
1°/ Le lien entre la valeur gr d’une masse exprimée en gramme et la valeur cuil de la même
quantité exprimée en nombre de cuillerées est donné par la relation :
15 !" = !"#$
Ecrire une fonction conversion dont l’argument est noté x, transformant une masse exprimée
en grammes en masse exprimée en nombre de cuillères et réciproquement transformant une
masse exprimée en nombre de cuillerées en masse exprimée en grammes.
On arrondira le nombre de cuillerées à l’entier le plus proche.
Ecrire l’appel de fonction qui permet de connaître en nombre de cuillerées l’équivalent de 100
grammes.
2°/ Ecrire deux fonctions prod et divi qui permettent respectivement de multiplier ou de
diviser une valeur de type t_masse par un entier donné en argument.
Ecrire une fonction add, calculant la somme de deux éléments de type t_masse, le résultat
sera de type t_masse exprimé en grammes
3°/ Ecrire une fonction pour_n qui transforme une recette de type t_recette donnée pour 6
personnes en recette pour un nombre de personnes précisé en argument. Cette fonction
comportera 2 arguments, la recette concernée et le nombre de personnes.
4°/ On dispose d’une liste de recettes. Ecrire une fonction sansb qui établit la liste des recettes
ne nécessitant pas de beurre.
5°/ Ecrire une fonction moyen considérant une liste de recettes et dont le résultat est un
quadruplé indiquant en gramme la masse moyenne de farine, sucre, beurre et le nombre
moyen d’œufs par recette. Ces valeurs seront des réels.
29
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
Session de rattrapage (2013-2014)
Les exercices sont indépendants mais les fonctions définies dans les différents exercices
peuvent être utilisées dans les exercices suivants.
Exercice 1
Ecrire une fonction moyenne permettant de calculer la moyenne des éléments réels d’une liste
présente comme argument de la fonction. Le résultat de la fonction est un réel. On traitera le
cas d’une liste vide à l’aide d’une exception.
Exercice 2
Ecrire une fonction maximum permettant de calculer le maximum des éléments d’une liste
présente comme argument de la fonction. On traitera le cas d’une liste vide à l’aide d’une
exception.
On donnera une version de cette fonction sous forme récursive terminale, dans laquelle la
fonction List.sort ne sera pas utilisée.
Exercice 3
Ecrire une fonction produit qui effectue terme à terme le produit de deux listes de réels de
même longueur.
Exercice 4
Ecrire une fonction permut qui comporte deux arguments c et x, c est un couple d’entiers et x
un entier. Le résultat de la fonction, pour deux arguments (c1,c2) et x est le couple (x,c1).
TOURNEZ S.V. P.
30
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
Exercice 5
Le stock d’un magasin est géré en fonction des informations mises à jour régulièrement. A
chaque produit est associé un enregistrement dont le type est défini par :
type t_produit = { numero : int ; prix_achat : float ; prix_vente : float ; stock: int * int}
On ne conserve que les deux dernières valeurs de stock, la valeur de gauche du couple étant
celle enregistrée en dernier.
L’ensemble des produits du magasin est contenu dans une liste dont les éléments sont de type
t_produit.
Lors des mises à jour, les prix sont remplacés par les nouveaux prix alors que la nouvelle
valeur x du stock est placée à gauche du couple du champ stock. Ainsi (a , b) devient (x , a)
1°/ Ecrire une fonction benefice qui, pour un produit, indique le bénéfice de la vente d’une
unité en fonction des informations contenues dans l’enregistrement associé au produit.
2°/ Ecrire une fonction vente qui, pour un produit indique le nombre de produits vendus, en
fonction des informations contenues dans l’enregistrement associé au produit.
3°/Ecrire une fonction benefice_moyen qui calcule le bénéfice moyen des ventes de
l’ensemble des produits contenus dans une liste dont les éléments sont de type t_produit.
Il est suggéré d’employer la fonction List.map
4°/ Le commerçant doit faire une commande d’un produit quand son stock actuel est trop
faible ou s’il a beaucoup vendu du produit.
a. Ecrire une fonction stockfaible qui construit une liste contenant les numéros des
produits dont la dernière valeur de stock est inférieure à une valeur passée en
paramètre.
b. Ecrire une fonction venteimportante qui construit une liste contenant les numéros
des produits dont le stock antérieur est plus de deux fois supérieur au stock actuel.
c. Si vous ne l’avez déjà fait, présentez la solution sous la forme d’une fonction
commande permettant de sélectionner une liste de produits vérifiant une propriété
donnée. La propriété, en argument de la fonction commande, est une fonction
critere qui sera définie dans chacun des deux cas.
On écrira les appels de la fonction commande ayant mêmes effets respectifs que
les fonctions stockfaible et venteimportante.
5°/ Ecrire une fonction miseajour avec trois arguments. L’un concerne la liste des produit, le
second le numéro du produit qui doit être mis à jour, le troisième est un triplet contenant les
prix d’achat et de vente et la nouvelle valeur du stock de ce produit. Dans le triplet, une valeur
négative de ces arguments indique que le champ correspondant n’est pas à mettre à jour.
Un appel serait donc de la forme : miseajour mag 1264 (-1., -1., 40) pour
mettre à jour à 40 la dernière valeur du stock du produit numéro 1264.
31
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
ANNALES
2014 - 2015
32
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
CC 1 (2014-2015)
Exercice 1
1°/ Soit l’expression
# let f a b = match b with
| (true , y) -> a = y
| (false , y) -> y mod 2 = 0 ;;
val f : int -> bool * int -> bool = <fun>
Justifier les 3 interprétations associées aux différents termes
int ->
bool*int ->
bool =
2°/ Indiquer si les expressions suivantes sont syntaxiquement exactes ou non. On justifiera les
réponses, soit par un commentaire et une version syntaxiquement exacte, soit par une
indication d’une interprétation dans le cas où la syntaxe est exacte.
a/
# let fa x y = [ (3 * x , x = y , 5 * y) ] ;;
b/
# let fb a b = ( a b , match b with (x,y) -> y + a b) ;;
c/ En considérant que ces deux expressions sont exécutées séquentiellement
c1/
# let f a b x y = a x + b y ;;
c2/
# f a b ;;
Exercice 2
1°/ Ecrire une fonction test ayant 3 arguments entiers m1, m2 et x, dont le résultat est un
entier, 0, 1 ou 2 selon que l’argument entier x de la fonction est strictement inférieur au plus
petit des deux entiers m1 et m2, compris entre m1 et m2, ou strictement supérieur au plus
grand des deux entiers m1 et m2.
2°/ Ecrire une fonction normalisation100 ayant 3 arguments entiers, p1, p2 et x, dont l’effet
est de faire correspondre l’intervalle d’extrémités p1 et p2 à l’intervalle [0 , 100]
La valeur résultat est donnée par la formule :
!""(!!!! )
!! !!!
Tournez S.V.P.
33
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
Exercice 3
On considère des couples dont le premier terme a pour type une chaîne de caractères et le
second terme a pour type un entier.
1°/ Ecrire une fonction vide, dont le résultat est un booléen, qui teste pour un couple donné si
la chaîne est vide. La définition de la fonction commencera par let vide x =
2°/ Ecrire une fonction booléenne pluspetit ayant deux arguments qui sont des couples décrits
au début de l’exercice. La définition de la fonction commence par let pluspetit x y = . La
fonction indique si le second terme de x est plus petit que le second terme de y.
3°/ Ecrire une fonction temps ayant 4 arguments, x un couple décrit précédemment, nr, no,
nv, trois arguments de type réel. Le résultat de la fonction est un triplet de réels dont les
valeurs sont déduites respectivement des valeurs de nr, no, nv. Les valeurs sont modifiées
uniquement dans certains cas. La valeur nr est augmentée du second terme de x si le premier
est égal à " rouge", la valeur no est augmentée du second terme de x si le premier est égal à
"orange", la valeur nv est augmentée du second terme de x si le premier est égal à "vert".
Par exemple temps ("vert", 3.5) 5.3 2.1 4.2 prend la valeur (5.3 , 2.1 , 7.7 )
34
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
CC 2 (2014-2015)
Exercice 1
Indiquer l'interprétation de l’expression suivante :
# let fc a b c d = a b c + if d = (0,0) then b c else c;;
Exercice 2
1°/ Ecrire une fonction compte qui calcule le nombre d’éléments égaux à une valeur donnée
dans une liste. On donnera deux versions dont une sous forme récursive terminale.
2°/ Ecrire une fonction maximum ayant pour argument une liste et dont le résultat est le
maximum des éléments de la liste. On prendra soin de vérifier que la liste fournie en
argument est non vide. On donnera deux versions dont une sous forme récursive terminale.
3°/ Calculer le nombre de fois où le maximum est présent dans la liste [3;5;9;5;9;0;5]
Exercice 3
On a défini la fonction add suivante :
# let add (x1,x2) (y1,y2) = ((x1+y1),(x2+y2)) ;;
val add : int * int -> int * int -> int * int = <fun>
Elle calcule la somme terme à terme de deux couples d’entiers
On a défini la fonction som suivante :
# let rec som l =
match l with
| [h] -> if ((h mod 2) = 0 ) then (h,0) else (0,h)
| h :: t -> if ((h mod 2) = 0 ) then add (h,0) (som t) else add (0,h) (som t) ;;
Warning 8: this pattern-matching is not exhaustive.
Here is an example of a value that is not matched:[]
val som : int list -> int * int = <fun>
1°/ Proposer une modification pour supprimer le warning.
2°/ Quel est l’effet de la fonction som sur la valeur de l’argument [ -5; 7; 3; 10; 4].
3°/ Ecrire une version terminale de cette fonction.
Exercice 4
1°/ Ecrire une fonction separation ayant pour argument une liste de couples et pour résultat
deux listes, celle des premiers éléments des couples et celle des seconds éléments des couples.
Exemple : la séparation de la liste [ (-5, ‘a’) ; (7 , ‘v’) ; (3 , ‘r’) ; (10 , ‘e’) ; (4 , ‘l’)] donne les
listes [ -5; 7; 3; 10; 4] et listes [ ‘a’; ‘v’; ‘r’; ‘e’; ‘l’ ].
2°/ Ecrire une fonction fusion ayant pour argument deux listes de même types et qui crée la
liste des éléments alternativement de la première et de la seconde tant que des éléments
existent dans la liste, ensuite une des listes est recopiée. Vous utiliserez une récursivité
terminale.
Exemple : la fusion des listes [ -5; 7; 3; 10; 4] et [ 2; 3; 6 ] est [ -5; 2 ; 7; 3 ; 3; 6 ; 10; 4]
35
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
2°/ Ecrire une fonction rang_pair ayant pour argument une liste et qui crée la liste des
éléments de rang pair issus de la liste. On prendra soin de conserver l'ordre initial des
éléments. On donnera deux versions dont une sous forme récursive terminale.
Exemple : rang_pair [ -5; 7; 3; 10; 4];; → - : int list = [7; 10]
3°/ Ecrire une fonction fusion ayant pour argument deux listes, que l’on supposera de même
type, et qui permet d’insérer les éléments de la première liste alternativement au début et en
fin de la seconde liste.
Exemple : let a = [5; 8; 2; 1; 9];; let b = [ -5; 7; 3; 10; 4];;
fusion a b;; → int list = [5; 2; 9; -5; 7; 3; 10; 4; 8; 1]
36
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
CC 4 (2014-2015)
La gestion de l’organisation des équipes de football de la Ligue1 masculine en France nécessite un
certain nombre de fonctionnalités et la création d’une structuration des données.
Une rencontre est un couple de noms d’équipes caractérisées par une chaîne de caractères, le premier
terme du couple indique l’équipe qui reçoit.
Le type associé est nommé t_rencontre.
Exemple :
Le club du PSG qui reçoit le club du LOSC correspond au couple : ("PSG" , "LOSC")
Un joueur est caractérisé par son nom, le nombre de buts marqués dans chacune des rencontres
jouées, ces valeurs sont regroupées dans une liste. Le type t_joueur est défini par :
type t_joueur = {nom : string ; buts : (int * t_rencontre) list }
Exemple de joueurs qui ont participé à trois rencontres :
let j1 = { nom = "mavuba"; buts =[(2 , ("LOSC" , "PSG")); (1 , ("PSG" , "LOSC")); (0 , ("LOSC" , "OM"))] };;
let j2 = { nom = "origi"; buts =[(2 , ("LOSC" , "PSG")); (0 , ("PSG" , "LOSC")); (3 , ("LOSC" , "OM"))] };;
let j3 = { nom = "matuidi"; buts =[(0 , ("LOSC" , "PSG")); (1 , ("PSG" , "LOSC")); (3 , ("PSG" , "OL"))] };;
let j4 = { nom = "cavani"; buts =[(1 , ("LOSC" , "PSG")); (2 , ("PSG" , "LOSC")); (3 , ("PSG" , "OL"))] };;
let j5 = { nom = "lucas"; buts =[(0 , ("LOSC" , "PSG")); (3 , ("PSG" , "LOSC")); (3 , ("PSG" , "OL"))] };;
let j6 = { nom = "gignac"; buts =[(2 , ("CAEN" , "OM")); (0 , ("OM" , "CAEN")); (2 , ("LOSC" , "OM"))] };;
Une équipe est caractérisée par le nom du club, le nombre de rencontres disputées nrencontres, un
nombre de victoires, un nombre de défaites et la liste de ses joueurs.
type t_equipe = {club : string; nrencontres : int; victoires : int; defaites : int; joueurs : t_joueur list }
Exemple d’équipes ne contenant que deux joueurs pour l’exemple :
let e1 = {club ="LOSC"; nrencontres=3; victoires=1; defaites=0; joueurs = [j1; j2] };;
let e2 = {club ="PSG" ; nrencontres=3; victoires=2; defaites=1; joueurs = [j3; j4;j5] };;
let e3 = {club ="OM" ; nrencontres=3; victoires=2; defaites=1; joueurs = [j6] };;
Dans l’exercice, on considère une liste d’éléments de type t_equipe qui constitue la liste des équipes
participant à la Ligue 1.
Exemple :
let ligue1 = [e1;e2;e3];;
Vous pourrez utiliser les fonctions prédéfinies du langage Caml.
Ne recopiez pas dans votre copie les types et les exemples fournis.
1°/ Ecrire la définition du type t_rencontre.
2°/ Ecrire une fonction nbjoueurs qui calcule le nombre de joueurs dans une équipe.
L’argument de la fonction est de type t_equipe.
3°/ Ecrire une fonction participants qui calcule le nombre de joueurs participant à la Ligue 1.
L'argument de la fonction est une liste d’équipes.
4°/ a/ Ecrire une fonction booléenne presence qui vérifie si le nom d'un joueur est présent dans une
liste de joueurs.
La fonction comporte deux arguments, une chaîne de caractères et une liste de joueurs.
b/ Ecrire une fonction nom_du_club qui, pour un joueur d'un nom donné, détermine le nom
de l’équipe à laquelle il appartient.
La fonction comporte deux arguments, une chaîne de caractères et une liste d’équipes.
Exemple d’appel à la fonction :
nom_du_club "mavuba" ligue1;;
: string = "LOSC"
Tournez SVP
37
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
5°/
a/ Un resultat est un nombre de buts marqués lors d'une rencontre, il s'agit d'un couple dont le
deuxième élément est une rencontre de type t_rencontre. Ecrire une fonction booléenne
rencontre_a_domicile qui vérifie si le résultat correspond à une rencontre à domicile pour un club donné.
La fonction aura pour premier argument le nom d'un club et pour deuxième argument un résultat de type
int*t_rencontre.
Exemple : rencontre_a_domicile "OM" (2,("PSG","OM")) ;;
-: bool = false
b/ Ecrire une fonction domicile qui calcule, pour un joueur donné, le nombre de rencontres faites à
domicile. L’argument est de type t_joueur.
Exemple d’appel à la fonction : domicile j1;;
: int 2
6°/ On s’intéresse dans cette question au nombre de buts marqués.
a/ Ecrire une fonction nbut, ayant pour argument resultat de type int*t_rencontre, qui retourne la
valeur de l'entier présent dans le couple.
Exemple : nbut (4,("OL","PSG");;
-: int = 4
b/ Ecrire une fonction liste_des_buts ayant pour argument liste de type int*t_rencontre list qui à
partir de la liste initiale retourne une liste d'entiers qui correspond aux nombres de buts marqués par un
joueur.
Exemple : liste_des_buts [(2 , ("LOSC" , "PSG")); (1 , ("PSG" , "LOSC")); (0 , ("LOSC" , "OM"))];;
-: int list = [2;1;0]
c/ Ecrire une fonction somme ayant pour argument liste de type int list qui calcule la somme des
entiers de la liste.
d/ Ecrire une fonction nbutpersototal ayant pour argument un joueur de type t_joueur qui
détermine le nombre de buts marqués par un joueur.
Exemple :nbutpersototal j1;;
-: int = 3
e/ Ecrire une fonction nbutequipe qui détermine le nombre de buts marqués par une équipe, c’est à
dire par l’ensemble des joueurs qui la compose. La fonction aura pour argument equipe de type t_equipe.
Exemple : nbutequipe e1;;
-: int = 8
7°/ Une victoire donne 3 points, une rencontre nulle donne 1 point et une rencontre perdue donne 0 point.
Ecrire une fonction points qui calcule, pour une équipe, le nombre de points acquis. L’argument de la
fonction est equipe de type t_equipe.
8°/ Ecrire une fonction tri qui établit le classement par ordre décroissant d'une liste d'équipes en fonction
du nombre de points obtenus.
9°/Ecrire une fonction vainqueur dont le résultat est la liste des équipes qui ont obtenu le plus de points
parmi les équipes de la ligue. Les équipes seront indiquées par la chaîne de caractères de leur nom.
L’argument de la fonction est une liste d’équipes de ligue 1.
Vous pourrez procéder par étapes :
Etablir le classement
Définir le plus grand nombre de points obtenus
Construire la liste des noms des équipes qui ont obtenu ce nombre
38
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
Epreuve de rattrapage (2014-2015)
I. On considère la définition de la fonction suivante :
let rec f g x = match x with [] -> 0
| h ::t -> (g h) + (f t)
Ecrire une version récursive terminale de cette fonction.
Exprimer l’objectif de cette fonction.
;;
II.
La gestion de l’organisation des équipes de football de la Ligue1 masculine en France nécessite un certain
nombre de fonctionnalités et la création d’une structuration des données.
Une rencontre est un couple de noms d’équipes caractérisées par une chaîne de caractères, le premier terme du
couple indique l’équipe qui reçoit. Le type t_rencontre est défini par : type t_rencontre = string * string ;;
Exemple :
Le club du PSG qui reçoit le club du LOSC correspond au couple : ("PSG" , "LOSC")
Un joueur est caractérisé par son nom, le nombre de buts marqués dans chacune des rencontres jouées, ces
valeurs sont regroupées dans une liste. Le type t_joueur est défini par :
type t_joueur = {nom : string ; buts : (int * t_rencontre) list }
Exemple de joueurs qui ont participé à trois rencontres :
let j1 = { nom = "mavuba"; buts =[(2 , ("LOSC" , "PSG")); (1 , ("PSG" , "LOSC")); (0 , ("LOSC" , "OM"))] };;
let j2 = { nom = "origi"; buts =[(2 , ("LOSC" , "PSG")); (0 , ("PSG" , "LOSC")); (3 , ("LOSC" , "OM"))] };;
let j3 = { nom = "matuidi"; buts =[(0 , ("LOSC" , "PSG")); (1 , ("PSG" , "LOSC")); (3 , ("PSG" , "OL"))] };;
let j4 = { nom = "cavani"; buts =[(1 , ("LOSC" , "PSG")); (2 , ("PSG" , "LOSC")); (3 , ("PSG" , "OL"))] };;
let j5 = { nom = "lucas"; buts =[(0 , ("LOSC" , "PSG")); (3 , ("PSG" , "LOSC")); (3 , ("PSG" , "OL"))] };;
let j6 = { nom = "gignac"; buts =[(2 , ("CAEN" , "OM")); (0 , ("OM" , "CAEN")); (2 , ("LOSC" , "OM"))] };;
Une équipe est caractérisée par le nom du club, le nombre de rencontres disputées nrencontres, un nombre de
victoires, un nombre de défaites et la liste de ses joueurs.
type t_equipe = {club : string; nrencontres : int; victoires : int; defaites : int; joueurs : t_joueur list }
Exemple d’équipes ne contenant que deux joueurs pour l’exemple :
let e1 = {club ="LOSC"; nrencontres=2; victoires=1; defaites=0; joueurs = [j1; j2] };;
let e2 = {club ="PSG" ; nrencontres=2; victoires=2; defaites=0; joueurs = [j3; j4; j5] };;
let e3 = {club ="OM" ; nrencontres=2; victoires=0; defaites=0; joueurs = [j6] };;
Dans l’exercice, on considère une liste d’éléments de type t_equipe qui constitue la liste des équipes participant
à la Ligue 1.
Exemple :
let ligue1 = [e1;e2;e3];;
Vous pourrez utiliser les fonctions prédéfinies du langage Caml.
Ne recopiez pas dans votre copie les types et les exemples fournis.
1° La première question a pour objectif de définir des fonctions de manipulation de couples qui pourrons être
utilisées dans les questions suivantes.
a/ Ecrire les fonctions c1 et c2 à un argument x qui permettent d’extraire respectivement le premier et le second
élément d’un couple. La fonction doit accepter comme argument un couple d’éléments de types quelconques.
b/ Ecrire les fonctions inc1 et inc2 à un argument x qui permettent d’incrémenter respectivement le premier et le
second élément d’un couple d’entiers.
c/ Ecrire la fonction somme calculant la somme terme à terme de deux couples d’entiers x et y.
Exemple :
# somme (3,4) (1 , 8) ;;
- : int * int = (4, 12)
Tournez S.V.P.
39
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
2°/ Ecrire une fonction nbrencontres qui calcule le nombre de rencontres qui ont été jouées par les équipes d’un
ensemble d’équipes.
L’argument de la fonction est de type t_equipe list.
Exemple d’appel de la fonction :
# nbrencontre ligue1 ;;
: int = 3
3°/
a/ Ecrire une fonction nbjoueurs qui calcule le nombre de joueurs dans une équipe donnée.
L’argument de la fonction est de type t_equipe.
b/ Ecrire une fonction nbjoueurs_ligue qui calcule le nombre de joueurs participant à la Ligue 1 et
appartenant à une équipe donnée par son nom.
La fonction comporte deux arguments, une chaîne de caractères et une liste d’équipes.
4°/
a/ Ecrire une fonction nomeq qui associe à une variable de type t_equipe le nom de l’équipe, une chaîne
de caractères.
b/ Ecrire une fonction nomliste qui associe à une liste d’équipes, la liste des noms des équipes.
c/ Ecrire une fonction booléenne presence qui vérifie si le nom d'une équipe est présent dans une liste
d’équipes.
La fonction comporte deux arguments, une chaîne de caractères et une liste d’équipes.
Exemple d’appel de la fonction :
# presence ligue1 "PSG" ;;
- : bool = true
5°/ Ecrire une fonction booléenne appartient qui vérifie qu’un joueur défini par son nom est dans une équipe.
Exemple d’appel de la fonction :
# appartient e1 "matuidi" ;;
- : bool = false
6°/ Ecrire une fonction feq qui associe à un nom d’équipe exprimé par une chaîne de caractères, la variable de
type t_equipe associée dans la liste des équipes. La fonction aura deux arguments equipe et nom_eq.
7°/ A l’issue d’une rencontre entre deux équipes, les différentes informations doivent être mises à jour.
L’objectif de cette fonction est de réaliser la fonction ajour avec 4 arguments : la liste des équipes d’une ligue,
les noms des deux équipes, la première étant l’équipe visiteuse, la liste des noms des joueurs ayant marqué.
ligue, nom1, nom2, jliste.
a/ Ecrire une fonction nbut avec les 4 arguments qui calcule le couple des nombres de buts marqués par
chacune des équipes.
Exemple d’appel de la fonction :
# nbut ligue1 "PSG" "LOSC" ["matuidi" ; "matuidi" ; "mavuba"] ;;
- : int * int = (2, 1)
b/ Ecrire une fonction ajour_ligue qui met à jour les enregistrements associés à chacune des équipes de la
rencontre.
Un appel pourrait être : let ligue2 = ajour_ligue ligue1 "PSG" "LOSC" ["matuidi" ; "matuidi" ; "mavuba"] ;;
40
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
ANNALES
2015 - 2016
41
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
CC 1 (2015-2016)
Exercice 1
Indiquer l’interprétation des expressions suivantes ou si elles ne sont pas exactes, corriger la
syntaxe avant de donner l’interprétation :
a/
# let f a , b = a + b ;;
b/
# let f x = match x with | (true , y) -> if y > "caml" then "L1" else "L2"
| (false , y) -> y ;;
c1/
c2/
c3/
c4/
# let f a b x y = a x && b y ;;
# f a b ;;
# let a x = x mod 2 = 0 ;;
# f a a ;;
d/
# let f a b c = (c , a b c) ;;
Exercice 2
1°/ Lors des soldes, un magasin propose une remise exprimée en pourcentage sur les achats.
a/ Ecrire une fonction depense ayant deux arguments un réel représentant le prix de vente et
un entier représentant le pourcentage de remise, la fonction applique à ce prix la remise
exprimée en pourcentage.
Ex : la fonction depense appliquée à 100,00 et 30 donnera 70,00
b/ A l’aide de la fonction depense, définir une fonction depense30 calculant le prix d’achat
d’un article en prenant en compte une remise fixée à 30%.
Rq : Il est recommandé de bien choisir l’ordre des arguments.
2°/ Lorsque le client fait deux achats, la remise sur le plus cher est de 30% et la remise sur le
moins cher est de 50%. Ecrire une fonction depense2 ayant deux arguments réels a1 et a2
représentant les prix de deux achats avant la remise et qui calcule le prix total à payer en
appliquant les remises.
T.S.V.P.
42
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
3°/ Ecrire une fonction ordo dont l’unique argument est un triplet de réels et dont le résultat
est le triplet de ces mêmes réels, ordonnés dans l’ordre croissant.
4°/ Lorsque le client fait trois achats, la remise appliquée au moins cher est de 70%, celle
appliquée à celui de prix intermédiaire est de 50% et au dernier est appliquée une remise de
30%.
a/ Ecrire une fonction depense4 ayant deux arguments, un triplet de réels représentant les prix
non ordonnés de trois produits et une fonction permettant d’ordonner les éléments d’un triplet
de réels. La fonction calcule le prix à payer pour les trois achats en appliquant les remises.
La définition commencera par let depense4 f x =
b/ Ecrire une fonction depense5 ayant 4 arguments, un triplet indiquant les prix des achats, un
triplet indiquant les pourcentages des remises par ordre croissant, une fonction f qui permet
d’ordonner les prix des achats, une fonction g qui calcule le prix d’un achat avec remise
comme le fait la fonction depense
un appel serait depense5 depense ordo (10,20,40) (50. , 28. 100.)
c/ Les taux de réduction étant fixés à respectivement 30, 50 et 70, en utilisant la fonction
depense5 écrire une fonction avecremise qui calcule le montant avec remise de 3 achats dont
les prix sont dans un triplet.
43
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
CC 2 (2015-2016)
Les questions sont largement indépendantes ou peuvent être résolues en admettant les
questions précédentes
Exercice 1
On considère la fonction suivante :
let rec f l = match l with [] -> 0
| [h] -> 2 * h
| a ::b ::t -> 2 * a + (f t) ;;
1°/ Quel est le résultat de l’application de f sur l’argument : [1 ; 10 ; 4 ; 1 ; 5 ; 3] ?
2°/ Donner une version terminale de cette fonction f.
Exercice 2
1°/ Ecrire une fonction somme qui calcule la somme des éléments d’une liste d’entiers.
2°/ Ecrire une fonction somtrans qui calcule la somme des éléments d’une liste d’entiers
transformés par une fonction. Cette fonction somtrans comprend 2 arguments, une fonction
et une liste d’entiers.
Vous donnerez deux versions de cette fonction, dont une sous forme récursive terminale.
Si carre est une fonction qui calcule le carré d’un entier, écrire l’appel à cette fonction qui
calcule la somme des carrés des éléments de la liste.
3°/ Ecrire une fonction decompose qui, à partir d’une liste d’entiers, construit deux listes,
l’une contenant les éléments pairs et l’autre les éléments impairs. On donnera une version
terminale.
4°/ Ecrire une fonction coupleparite qui admet deux arguments, une fonction transformant un
entier et une liste d’entiers. Cette fonction calcule un couple contenant d’une part la somme
des éléments pairs transformés par la fonction et d’autre part celle des éléments impairs
transformés de la même façon.
Si la liste est [1; 10; 3; 8; 3], et la transformation est la fonction carré, le résultat est (164, 19).
Ecrire l’appel correspondant.
T.S.V.P.
44
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
Exercice 3
1°/ Ecrire une fonction miroir qui construit la liste miroir d’une liste donnée.
Appliquée à la liste [1 ; 10 ; 4 ; 1 ; 5 ; 3] le résultat de la fonction est [3 ; 5 ; 1 ; 4 ; 10 ; 1]
2°/ Ecrire une fonction n2liste qui construit la liste des chiffres d’un entier donné.
On donnera deux versions de la fonction dont une version récursive terminale.
Appliquée à l’entier 125, le résultat de la fonction est [1 ; 2 ; 5 ]
3°/ Ecrire une fonction liste2n qui traduit les éléments d’une liste d’entiers positifs ou nuls
inférieurs strictement à 10 en un entier. On testera au préalable que la liste vérifie bien la
condition ‘entiers positifs ou nuls inférieurs strictement à 10’
Appliquée à [1; 2; 5] le résultat de la fonction est 125
4°/ En considérant des bases comprises entre 2 et 10, généraliser la fonction précédente et
écrire une fonction convert qui interprète les éléments d’une liste d’entiers positifs inférieurs
strictement à une valeur a en l’écriture d’un nombre en base a et indique la valeur entière
correspondante. La fonction aura donc deux arguments, la base et la liste.
Appliquée aux arguments : [1 ; 0 ; 0 ; 1 ; 1] et 2, le résultat de la fonction est 19
45
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
CC 4 (2015-2016)
Exercice 1
La gestion d’un parc de voitures est liée aux préférences des utilisateurs. Les données
d’utilisation stockées sont : l’identifiant d’un utilisateur, les kilométrages de ses différentes
utilisations de voiture dans une liste d’entiers, la nature de l’utilisation de la voiture (de jour
ou de nuit), la nature du carburant utilisé.
Chaque utilisation est modélisée par un enregistrement à trois champs, un entier, une liste de
couples d’un entier et d’un énuméré indiquant la nature de l’utilisation (jour ou nuit) et un
énuméré.
1°/ Ecrire un type énuméré nommé t_carbur comportant au moins 3 valeurs correspondant à
de l’essence, du diesel et du biocarburant.
2°/ Ecrire un type enregistrement nommé t_utilisation qui permet de décrire une utilisation.
Les champs utilisés auront respectivement pour nom : ident, kilo et carbur.
Un exemple de valeur de type t_utilisation est
{ident = 314 ; kilo = [( 343 , Jour) ; ( 19 , Jour) ; ( 520 , Nuit) ] ; carbur = Essence}
3°/ Ecrire une fonction booléenne fcarbur qui teste si une variable de type t_utilisation
correspond à un utilisateur utilisant un carburant de type donné.
4°/ On considère une liste d’éléments de type t_utilisation. Ecrire une fonction fnbcarbur qui
calcule le nombre d’utilisateurs dans la liste utilisant une voiture fonctionnant avec un
carburant donné.
5°/ Ecrire une fonction fkilo qui calcule le nombre de kilomètres parcourus relatifs à une
variable de type t_utilisation.
6°/ Ecrire une fonction fnbkilo qui calcule le nombre de kilomètres parcourus par les
utilisateurs dans une liste d’éléments de type t_utilisation.
Tournez S.V.P.
46
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
Exercice 2
Une liste contient une série temporelle de mesures qui sont soit des mesures de température,
soit des mesures de hauteur. Ses éléments sont de type t_mesure défini par :
type t_mesure = |Temp of int |Haut of int ;;
1°/ Ecrire une fonction add qui calcule terme à terme la somme de deux couples d’entiers.
Par exemple la somme de (4,6) et (2,8) est (6,14)
2°/ Ecrire une fonction fcompte qui à partir d’une liste de mesures de type t_mesure fournie
en argument, calcule un couple contenant respectivement le nombre de mesures de
température comme premier argument du couple et le nombre de hauteurs comme deuxième
élément du couple.
3°/ Ecrire une fonction fmoy qui à partir d’une liste de mesures de type t_mesure, calcule un
couple contenant respectivement les moyennes des températures et des hauteurs contenues
dans la liste de mesures.
4°/ Ecrire une fonction fmax qui à partir d’une liste de mesures de type t_mesure, calcule un
couple d’entiers contenant respectivement les valeurs maximum des températures et des
hauteurs contenues dans la liste de mesures. On vérifiera que la liste comporte au moins une
mesure de hauteur et une mesure de température, sinon une exception indiquera ce cas.
Exercice 3
On définit le type t_arbre = | Feuille of int | Noeud of int * t_arbre list ;;
1°/ Donner une représentation graphique du graphe associé à la valeur :
Noeud (3 , [ Feuille 6 ; Noeud (2 , [Feuille 5 ; Feuille 4] ) ] )
2°/ Ecrire la définition d’une variable nommée gr de type t_arbre et modélisant l’arbre
représenté dans le schéma suivant :
5
2
8
2
1
4
1
2
5
4
3°/ Ecrire une fonction fval qui calcule la somme des valeurs des feuilles d’un graphe.
47
Licence 1
UE Informatique
Programmation fonctionnelle
Année 2016 - 2017
Epreuve de rattrapage (2015-2016)
L’utilisation des fonctions du module List est autorisée dans toutes les questions.
La gestion d’un parc de voitures est liée aux préférences des utilisateurs. Les données
d’utilisation stockées sont : l’identifiant d’un utilisateur, les kilométrages de ses différentes
utilisations de voiture, la nature de l’utilisation de la voiture (de jour ou de nuit).
Chaque utilisateur est modélisé par un enregistrement à deux champs, un entier (l’identifiant
de l’utilisateur), une liste de couples d’un entier et d’un énuméré indiquant la nature de
l’utilisation (jour ou nuit), chaque couple représente une utilisation.
Les types utilisés sont définis par :
type t_cond = | Jour | Nuit ;;
type t_utilisateur = {ident : int ; kilo : (int*t_cond) list} ;;
Un exemple de valeur de type t_utilisateur est
{ident = 314 ; kilo = [( 343 , Jour) ; ( 19 , Jour) ; ( 520 , Nuit) ] }
1°/ Ecrire une fonction fcompte dont les arguments sont une liste d’éléments l et une fonction
booléenne p dont l’argument est de même type que les éléments de l, le résultat de la fonction
est le nombre des éléments de l qui vérifient la propriété p. La fonction récursive sera
exprimée sous forme terminale.
2°/ Ecrire une fonction fnb qui calcule le nombre d’utilisations d’un client dont les données
sont dans une variable de type t_utilisateur.
3°/ Ecrire une fonction booléenne fnb1 qui teste si une variable de type
correspond à un utilisateur n’ayant été client qu’une seule fois.
t_utilisateur
4°/ Ecrire une fonction booléenne fnature qui teste si une variable de type t_utilisateur
correspond à un utilisateur n’ayant que des utilisations de nature donnée en argument.
5°/ Ecrire une fonction fkilos qui pour une variable de type t_utilisateur a pour résultat un
couple indiquant respectivement le nombre de kilomètres parcourus le jour et la nuit.
6°/ On considère une liste d’éléments de type t_utilisateur. Ecrire une fonction fnbsingle qui
calcule le nombre d’utilisateurs dans la liste n’ayant été client qu’une seule fois.
7°/ On considère une liste d’éléments de type t_utilisateur. Ecrire une fonction fnbjour qui
calcule le nombre d’utilisateurs dans la liste n’ayant utilisé une voiture que le jour.
8°/ On considère une liste d’éléments de type t_utilisateur. Ecrire une fonction fkilototal qui
calcule le nombre de kilomètres parcourus par l’ensemble des utilisateurs.
9°/ On considère une liste d’éléments de type t_utilisateur. Ecrire une fonction fmkilo qui
calcule la moyenne parcourue dans l’ensemble des utilisateurs. On s’assurera que la liste est
non vide.
10°/ On considère une liste d’éléments de type t_utilisateur. Ecrire une fonction flnature qui
extrait la liste des utilisateurs dont la nature des utilisations est uniquement celle donnée en
argument (de type t_cond).
11°/ Ecrire une fonction frkilo qui calcule le rapport entre le nombre des kilomètres parcourus
par les utilisateurs qui n’ont circulé que le jour et le nombre des kilomètres parcourus par les
utilisateurs qui n’ont circulé que la nuit.
12°/ Ecrire une fonction fnbjour_nuit qui calcule le nombre d’utilisateurs ayant utilisé la
voiture au moins une fois le jour et au moins une fois la nuit.
48