Examen Haskell Sujet 02

EXAMEN PROGRAMMATION FONCTIONNELLE : HASKELL | SUJET 02/XX

Examen Haskell

Examinateur : Mr JoëlYk, durée 02 heures

 

Exercice 20 pts :

1 - Donnez la différence entre paradigme fonction et paradigme impératif. (1pt)
2 - Définir un type synonyme polymorphe TripletPoly permettant de manipuler des tuples de la forme (x::a, y::b, z::c) ; écrire des fonctions first, second et third permettant de retourner respectivement la première, la seconde et la troisième composante
d’un triplet ; peut-on préciser explicitement le type de ces fonctions en utilisant TripletPoly ? (1,5pts)
3 - Définir les expressions suivantes avec des exemples d’application direct de votre choix: évaluation paresseuse, instanciation partielle des fonctions . (1+1=2pts)
4 - Donnez les signatures des fonction suivantes : drop, take const, foldr et foldl. (0,5+0,5+0,5+0,5+0,5=2,5pts)
5 - Donnez le résultat des expressions suivantes les justifications ne sont pas necessaires: (0,5+0,5+0,5+0,5=3pts)
(a) map (\(x,y )→ x+x) [(1,’4’), (2,’9’),(3,’8’)]
(b) zipWith const (drop 2 (reverse (take 6 [1,2,3,4,5,6,7]))) [‘M’,’a’,’e’,’s’,’t’,’r’,’o’,’s’]
(c) foldl const [1,2,3] [[50, 40], [30, 10]]
(d) foldr const [1,2,3] [[50, 40], [30, 10]]
6- Écrire une fonction qui retire les éléments négatifs d’une lite donnée de trois façon : les gardes, la récursivité et la définition en compréhension. (3pts)
7 - On se propose d’écrire un module Haskell pour la manipulation des listes. On définit une liste par le type : data List a = Nil | Build {head_::a, tail_::List a} deriving (Eq, Show). (1+1+1,5+1,5+0,5+0,5+1,5=8pts)
(a) Donnez le type des constructeurs de données.
(b) Donnez le type ds fonctions de projections de ce type.
(c) Proposer des fonction toList qui permettent de convertir une liste du prélude en une List.
(d) Proposer des fonction fromList qui permettent de convertir une List en une liste du prélude.
(e) Quel est le type des fonctions aList et applyMap suivantes ?
aList = let l = toList [4, 5.3, 2]
t = Cons 8 (Cons 2 Nil)
in toList [t, l]
applyMap xs = [map_ (/2) elt | elt <- xs]
(f) Ecrire une fonction map_ qui applique une fonction sur une liste de notre type List a.

 

Découvrez plus d'exercice corriges sur : www.PandaCodeur.com

Correction :

1 - Le paradigme fonctionnel repose sur la composition de fonctions pures, où l'accent est mis sur le traitement de données immuables, tandis que le paradigme impératif se concentre sur la séquence d'instructions modifiant l'état d'un programme en vue de produire un résultat.

2- Type Synonyme :

type TripletPoly a b c = (a, b, c)

first :: TripletPoly a b c -> a
first (x, _, _) = x

second :: TripletPoly a b c -> b
second (_, y, _) = y

third :: TripletPoly a b c -> c
third (_, _, z) = z

On ne peut pas préciser explicitement le type des fonctions en utilisant TripletPoly, car il s'agit d'un type synonyme et non d'un nouveau type.

3 -

L'évaluation paresseuse consiste à ne pas évaluer une expression tant que cela n'est pas nécessaire. Par exemple, si on a if True then 1 else 2, seule l'expression 1 sera évaluée car c'est la seule qui sera nécessaire.

L'instanciation partielle d'une fonction consiste à appliquer partiellement la fonction en lui fournissant certains arguments, pour obtenir une nouvelle fonction qui attend les arguments restants. Par exemple, si on a la fonction f x y z = x + y + z, on peut faire g = f 1, ce qui crée une nouvelle fonction g qui attend deux arguments au lieu de trois.

4-

drop :: Int -> [a] -> [a]
take :: Int -> [a] -> [a]
const :: a -> b -> a
foldr :: (a -> b -> b) -> b -> [a] -> b
foldl :: (b -> a -> b) -> b -> [a] -> b

5-

(a) [2, 4, 6]

(b) ['o', 'e', 'l', 'y', 'k']

(c) 1

(d) 1

6 -

Avec des gardes:

removeNegatives :: [Int] -> [Int]
removeNegatives [] = []
removeNegatives (x:xs)
  | x >= 0    = x : removeNegatives xs
  | otherwise = removeNegatives xs

Avec la récursivité:

removeNegatives :: [Int] -> [Int]
removeNegatives [] = []
removeNegatives (x:xs)
  | x >= 0    = x : removeNegatives xs
  | otherwise = removeNegatives xs

Avec la définition en compréhension:

removeNegatives :: [Int] -> [Int]
removeNegatives xs = [x | x <- xs, x >= 0]

7 -

(a) Les constructeurs de données ont le type a -> List a.

(b) Les fonctions de projections ont les types List a -> a et List a -> List a.

(c)

toList :: [a] -> List a
toList [] = Nil
toList (x:xs) = Build x (toList xs)

(d)

fromList :: List a -> [a]
fromList Nil = []
fromList (Build x xs) = x : fromList xs

(e) aList a le type [List a].

applyMap a le type Fractional b => List b -> [List b].

(f) Voici l'implémentation de la fonction map_ :

map_ :: (a -> b) -> List a -> List b
map_ f Nil = Nil
map_ f (Cons x xs) = Cons (f x) (map_ f xs)

Si vous avez trouvé les examens corrigés en Haskell de Mr JoëlYk intéressants et utiles, pourquoi ne pas les partager avec d'autres personnes qui pourraient également en bénéficier ? Partagez ce lien sur les réseaux sociaux ou envoyez-le à vos amis et collègues. Vous pourriez aider quelqu'un à améliorer ses compétences en programmation ou à trouver des solutions à des problèmes complexes. N'oubliez pas que la connaissance doit être partagée pour grandir. Merci pour votre soutien et votre partage !

Contact WhatsApp : +237 658395978 | Réaliser Par Joël_Yk

  • Aucune note. Soyez le premier à attribuer une note !

Ajouter un commentaire

Anti-spam