Parcours
/
F#
F#
/
Exercices
/
Parcours sur parcours sur parcours
Parcours sur parcours sur parcours

Parcours sur parcours sur parcours

Exercice d'apprentissage

Introduction

Listes

Une list en F# est une collection immuable de zéro ou plusieurs valeurs. Les valeurs d'une liste doivent toutes avoir le même type. Comme les listes sont immuables, une fois qu'une liste a été construite, sa valeur ne peut plus jamais changer. Toute fonction ou tout opérateur qui semble modifier une liste (par exemple en y ajoutant un élément) renvoie en réalité une nouvelle liste.

Une liste peut être définie comme suit :

let empty = []
let singleValue = [5]
let threeValues = ["a"; "b"; "c"]

La façon la plus courante d'ajouter un élément à une liste est d'utiliser l'opérateur :: (cons) :

let twoToFour = [2; 3; 4]
let oneToFour = 1 :: twoToFour
// => [1; 2; 3; 4]

Une liste F# a une tête (le premier élément) et une queue (tout ce qui suit le premier élément). La queue d'une liste est elle-même une liste.

Les listes se manipulent soit avec les fonctions et opérateurs définis dans le module List, soit manuellement à l'aide du filtrage par motif avec les motifs list et cons :

let describe list =
    match list with
    | [] -> "Empty list"
    | head::tail -> sprintf "Non-empty list with head: %d" head

describe []        // => "Empty list"
describe [1]       // => "Non-empty with head: 1"
describe [5; 7; 9] // => "Non-empty with head: 5"

Tu peux aussi ignorer une valeur lors du filtrage par motif ; lorsque tu ne te soucies pas d'une valeur dans un cas précis (autrement dit, tu ne vas pas l'utiliser), tu peux utiliser un tiret bas ('_') pour le signaler :

let describe list =
    match list with
    | [] -> "Empty list"
    | [x] -> "List with one item"
    | [_; y] -> "List with two items (first item ignored)"
    | _ -> "List with many items (all items ignored)"

describe []        // => "Empty list"
describe [1]       // => "List with one item"
describe [5; 7]     // => "List with two items (first item ignored)"
describe [5; 7; 9] // => "List with many items (all items ignored)"

Le '_' seul doit toujours venir en dernier lors du filtrage par motif ; toute valeur qui ne correspond à aucun des autres cas sera traitée par ce cas.

Instructions

Dans cet exercice, tu vas écrire du code pour garder la trace d'un tableau de langages de programmation que tu veux apprendre sur Exercism.

Tu as six tâches, qui consistent toutes à manipuler des tableaux.

1. Crée un nouveau tableau

Pour garder la trace des langages que tu veux apprendre, tu vas devoir créer un nouveau tableau. Définis la liaison newList qui contient un nouveau tableau vide.

newList
// => []

2. Définis un tableau existant

Pour l'instant, tu as une feuille de papier sur laquelle sont listés les langages que tu veux apprendre : F#, Clojure et Haskell. Définis la liaison existingList pour représenter ce tableau.

existingList
// => ["F#"; "Clojure"; "Haskell"]

3. Ajoute un nouveau langage à un tableau

Au fur et à mesure que tu explores Exercism et que tu découvres des langages plus intéressants, tu veux les ajouter à ton tableau. Implémente la fonction addLanguage pour ajouter un nouveau langage au début de ton tableau.

addLanguage "TypeScript" ["JavaScript"; "CoffeeScript"]
// => ["TypeScript"; "JavaScript"; "CoffeeScript"]

4. Compte les langages du tableau

Compter les langages un par un n'est pas pratique. Implémente la fonction countLanguages pour compter le nombre de langages de ton tableau.

countLanguages ["C#"; "Racket"; "Rust"; "Ruby"]
// => 4

5. Inverse le tableau

À un moment donné, tu réalises que ton tableau est en fait dans l'ordre inverse ! Implémente la fonction reverseList pour inverser ton tableau.

reverseList ["Prolog"; "C"; "Idris"; "Assembly"]
// => ["Assembly"; "Idris"; "C"; "Prolog"]

6. Vérifie si un tableau est passionnant

Même si tu aimes tous les langages, F# occupe une place particulière dans ton cœur. À ce titre, un tableau de langages te passionne vraiment si :

  • Le premier élément du tableau est F#.
  • Le deuxième élément du tableau est F# et le tableau contient soit deux, soit trois langages.

Implémente la fonction excitingList pour vérifier si un tableau de langages est passionnant :

excitingList ["Nim"; "F#"]
// => true
Modifie via GitHub Le lien s'ouvre dans une nouvelle fenêtre ou un nouvel onglet
F# Exercism

Prêt à commencer Parcours sur parcours sur parcours ?

Inscris-toi sur Exercism pour apprendre et maîtriser F# avec 18 concepts148 exercices, et un vrai mentorat humain, le tout gratuitement.