Haskell Exercices Corriges 03

Exercices Corriges en Haskell (head, taill, ++, drop)

Exercice corrige Programmation Fonctionnelle

Donner le résultat des expressions suivantes :

1-[1, 2, 3] !! ([1, 2, 3] !! 1)

2-head [1, 2, 3]

3-tail [1, 2, 3]

4-“a” : [“ac”, “b”]

5-“abc” ++ “cb”

6-tail “abc” ++ “d”

7-drop 2 “abc” ++ “d”

8-head “abc” : “d”

9-([1, 2, 3] !! 2 : []) ++ [3, 4]

10- ([3, 2, 1] ++ [1, 2, 4] !! last [0, 2] : [8]) : []

1. L'expression [1, 2, 3] !! 1 renvoie la valeur 2, car !! est l'opérateur d'indexation des listes et retourne l'élément à l'indice spécifié. Ainsi, [1, 2, 3] !! ([1, 2, 3] !! 1) devient [1, 2, 3] !! 2, qui renvoie la valeur 3 (élément à l'indice 2 de la liste [1, 2, 3]).
2. L'expression head [1, 2, 3] renvoie la valeur 1, car head est la fonction qui retourne le premier élément d'une liste.
3. L'expression tail [1, 2, 3] renvoie la liste [2, 3], car tail est la fonction qui retourne tous les éléments d'une liste à l'exception du premier.
4. L'expression "a" : ["ac", "b"] renvoie la liste ["a", "ac", "b"], car l'opérateur : ajoute l'élément spécifié en premier argument à la liste spécifiée en deuxième argument.
5. L'expression "abc" ++ "cb" renvoie la chaîne de caractères "abcccb", car l'opérateur ++ concatène les deux chaînes de caractères spécifiées.
6. L'expression tail "abc" ++ "d" renvoie la chaîne de caractères "bcd", car tail retourne la liste [b, c] qui est ensuite concaténée avec la chaîne de caractères "d".
7. L'expression drop 2 "abc" ++ "d" renvoie la chaîne de caractères "cd", car drop supprime les deux premiers caractères de la chaîne de caractères "abc", et ensuite la chaîne de caractères "d" est concaténée avec le reste "cd".
8. L'expression head "abc" : "d" renvoie la liste ['a', 'd'], car head retourne le premier caractère de la chaîne de caractères "abc", qui est ensuite ajouté à la chaîne de caractères "d" avec l'opérateur :.
9. L'expression ([1, 2, 3] !! 2 : []) ++ [3, 4] renvoie la liste [3, 3, 4], car [1, 2, 3] !! 2 renvoie la valeur 3, qui est ajoutée à une liste vide [] pour obtenir la liste [3], puis cette liste est concaténée avec la liste [3, 4].
10. L'expression ([3, 2, 1] ++ [1, 2, 4] !! last [0, 2] : [8]) : [] renvoie la liste [[3, 2, 1, 2, 8]], car last [0, 2] renvoie la valeur 2, qui est ensuite utilisée pour récupérer l'élément à l'indice 2 de la liste [1, 2, 4] (qui est 4), et cette valeur est ajoutée à la liste [3, 2, 1, 4, 8] à l'aide de l'opérateur de concaténation ++. Ensuite, la liste résultante est ajoutée à une liste vide avec l'opérateur :, ce qui crée une liste imbriquée. Le résultat final est donc [[3, 2, 1, 4, 8]].

Donnez le résultat des expressions suivantes :

1. "abcde" !! 2
2. tail [1, 2, 3, 4]
3. 3 : [4, 5, 6]
4. [1, 2, 3] ++ [4, 5]
5. drop 2 "hello"

1. L'expression "abcde" !! 2 renvoie le caractère "c", car les chaînes de caractères sont indexées à partir de 0 et l'indice 2 correspond donc au troisième caractère de la chaîne "abcde".
2. L'expression tail [1, 2, 3, 4] renvoie la liste [2, 3, 4], car la fonction tail renvoie la liste sans son premier élément.
3. L'expression 3 : [4, 5, 6] renvoie la liste [3, 4, 5, 6], car l'opérateur ':' permet d'ajouter un élément au début d'une liste.
4. L'expression [1, 2, 3] ++ [4, 5] renvoie la liste [1, 2, 3, 4, 5], car l'opérateur '++' permet de concaténer deux listes.
5. L'expression drop 2 "hello" renvoie la chaîne de caractères "llo", car la fonction drop permet de supprimer un nombre donné d'éléments au début d'une liste ou d'une chaîne de caractères. Ici, les deux premiers caractères "he" sont supprimés, laissant les caractères "llo".

Trouvez l'erreur dans chacune des expressions suivantes et expliquez pourquoi elle se produit :

1. [1, 2, 3] ++ 4
2. head []
3. tail "a"
4. "abc" !! 3
5. [1, 2, 3] !! 4

1. L'expression [1, 2, 3] ++ 4 est incorrecte car le symbole ++ est utilisé pour concaténer des listes, mais 4 est un entier et non une liste. Pour concaténer une liste avec un élément, il faut l'encapsuler dans une liste, comme [1, 2, 3] ++ [4].
2. L'expression head [] est incorrecte car head est une fonction qui prend en entrée une liste et renvoie son premier élément. Or, la liste vide [] n'a pas de premier élément, d'où l'erreur "Prelude.head: empty list".
3. L'expression tail "a" est incorrecte car tail est une fonction qui prend en entrée une liste et renvoie tous ses éléments sauf le premier. Or, "a" est une chaîne de caractères et non une liste, d'où l'erreur "Prelude.tail: empty list".
4. L'expression "abc" !! 3 est incorrecte car la numérotation des éléments dans une liste commence à 0. La chaîne "abc" contient donc les éléments "a" (indice 0), "b" (indice 1) et "c" (indice 2), mais pas d'élément à l'indice 3. D'où l'erreur "Prelude.!!: index too large".
5. L'expression [1, 2, 3] !! 4 est incorrecte car la numérotation des éléments dans une liste commence à 0. La liste [1, 2, 3] contient donc les éléments 1 (indice 0), 2 (indice 1) et 3 (indice 2), mais pas d'élément à l'indice 4. D'où l'erreur "Prelude.!!: index too large".