Haskell : Listes, Types et Manipulation des Tuples

Exercices en Haskell : Listes, Types et Manipulation des Tuples

Exercice 1 : Différences entre paradigmes fonctionnel et impératif

Expliquez les différences fondamentales entre les paradigmes fonctionnel et impératif.

Donnez un exemple en Haskell illustrant le paradigme fonctionnel et un exemple en pseudo-code illustrant le paradigme impératif.

Exercice 2 : Évaluation paresseuse et instanciation partielle

Expliquez ce qu'est l'évaluation paresseuse en Haskell et donnez un exemple de code.

Expliquez ce qu'est l'instanciation partielle des fonctions et donnez un exemple en Haskell.

Exercice 3 : Listes en compréhension

Écrivez deux expressions différentes pour créer une liste contenant les 10 premiers nombres entiers naturels.

Écrivez une liste en compréhension contenant les carrés des nombres pairs compris entre 1 et 10 000.

Exercice 4 : Définition d'un type Triplet

Définissez un type Triplet pour représenter des tuples (Int, Char, Bool).

Implémentez les fonctions first, second et third permettant d'extraire respectivement le premier, le second et le troisième élément d'un triplet.

Exercice 5 : Définition d'un type de liste

On définit une liste avec le type suivant :

data List t = Chaine { tete :: t, listResiduel :: List t } | Vide

Donnez le type de Chaine et listResiduel.

Donnez un exemple d'une valeur de ce type.

Implémentez la fonction map_ qui applique une fonction à chaque élément d'une List t.

Correction :

Correction des exercices en Haskell

Exercice 1 : Différences entre paradigmes fonctionnel et impératif

Différences fondamentales :

Paradigme Fonctionnel :
- Immuabilité : Les données ne sont pas modifiées après leur création.
- Fonctions de première classe : Les fonctions peuvent être passées comme arguments, retournées comme valeurs, etc.
- Évaluation paresseuse : Les expressions ne sont évaluées que lorsque leurs résultats sont nécessaires.
- Récursion : Utilisée pour les boucles et les itérations.
Paradigme Impératif :
- État mutable : Les variables peuvent changer de valeur.
- Effets secondaires : Les fonctions peuvent modifier l'état du programme.
- Séquences d'instructions : Le programme est une séquence d'instructions qui modifient l'état.
- Boucles : Utilisées pour les itérations.

Exemple en Haskell (fonctionnel) :

-- Fonction qui calcule la somme des carrés des éléments d'une liste
sumOfSquares :: [Int] -> Int
sumOfSquares xs = sum (map (^2) xs)

Exemple en pseudo-code (impératif) :

// Fonction qui calcule la somme des carrés des éléments d'une liste
function sumOfSquares(xs):
    total = 0
    for x in xs:
        total = total + (x * x)
    return total

Exercice 2 : Évaluation paresseuse et instanciation partielle

Évaluation paresseuse :

L'évaluation paresseuse signifie que les expressions ne sont évaluées que lorsque leurs résultats sont nécessaires.

Exemple en Haskell :

-- Liste infinie des nombres naturels
naturals :: [Int]
naturals = [0..]

-- Prend les 10 premiers éléments de la liste infinie
take 10 naturals

Instanciation partielle :

L'instanciation partielle consiste à appliquer une fonction à un sous-ensemble de ses arguments, ce qui retourne une nouvelle fonction qui attend les arguments restants.

Exemple en Haskell :

-- Fonction qui additionne deux nombres
add :: Int -> Int -> Int
add x y = x + y

-- Instanciation partielle : on fixe le premier argument à 5
add5 :: Int -> Int
add5 = add 5

-- Utilisation de la fonction partiellement instanciée
result = add5 3  -- Retourne 8

Exercice 3 : Listes en compréhension

Deux expressions pour créer une liste contenant les 10 premiers nombres entiers naturels :

Utilisation de la syntaxe de liste en compréhension :
```
firstTen = [x | x <- [1..10]]
```
Utilisation de la fonction take :
```
firstTen = take 10 [1..]
```

Liste en compréhension contenant les carrés des nombres pairs compris entre 1 et 10 000 :

squaresOfEvens = [x^2 | x <- [1..10000], even x]

Exercice 4 : Définition d'un type Triplet

Définition du type Triplet :

data Triplet = Triplet Int Char Bool

Implémentation des fonctions `first`, `second`, et `third` :

first :: Triplet -> Int
first (Triplet x _ _) = x

second :: Triplet -> Char
second (Triplet _ y _) = y

third :: Triplet -> Bool
third (Triplet _ _ z) = z

Exercice 5 : Définition d'un type de liste

Type de `Chaine` et `listResiduel` :

Chaine :: t -> List t -> List t
listResiduel :: List t -> List t

Exemple d'une valeur de ce type :

exampleList :: List Int
exampleList = Chaine 1 (Chaine 2 (Chaine 3 Vide))

Implémentation de la fonction `map_` :

map_ :: (t -> u) -> List t -> List u
map_ _ Vide = Vide
map_ f (Chaine x xs) = Chaine (f x) (map_ f xs)

Correction Exercice 4

Définition du type Triplet :

type Triplet = (Int, Char, Bool)

Fonctions pour extraire les éléments du triplet :

first :: Triplet -> Int first (x, _, _) = x second :: Triplet -> Char second (_, y, _) = y third :: Triplet -> Bool third (_, _, z) = z

Correction Exercice 5

Types de Chaine et listResiduel :

Chaine :: t -> List t -> List t listResiduel :: List t -> List t

Exemple d'une liste de ce type :

exempleListe = Chaine 1 (Chaine 2 (Chaine 3 Vide))

Implémentation de map_ :

map_ :: (t -> t1) -> List t -> List t1 map_ _ Vide = Vide map_ f (Chaine tete listResiduel) = Chaine (f tete) (map_ f listResiduel)

Si vous avez trouvé les exercices corrigés en Haskell de 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 652027193 | Réaliser Par Joël_Yk