Tracks
/
F#
F#
/
Übungen
/
Tracks on Tracks on Tracks
Tracks on Tracks on Tracks

Tracks on Tracks on Tracks

Lernübung

Einführung

Listen

Eine list in F# ist eine unveränderliche Sammlung von null oder mehr Werten. Alle Werte in einer Liste müssen denselben Typ haben. Da Listen unveränderlich sind, kann sich der Wert einer Liste nie mehr ändern, sobald sie erstellt wurde. Alle Funktionen und Operatoren, die eine Liste zu verändern scheinen (etwa das Hinzufügen eines Elements), geben in Wirklichkeit eine neue Liste zurück.

So kannst du Listen definieren:

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

Am häufigsten fügst du ein Element über den ::-Operator (cons) zu einer Liste hinzu:

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

Eine F#-Liste hat einen Kopf (das erste Element) und einen Rest (alles nach dem ersten Element). Der Rest einer Liste ist selbst eine Liste.

Listen werden entweder mit Funktionen und Operatoren aus dem List-Modul bearbeitet oder manuell mit Pattern Matching unter Verwendung des list- und des cons-Musters:

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"

Du kannst einen Wert beim Pattern Matching auch verwerfen. Wenn du dich in einem bestimmten Fall nicht für einen Wert interessierst (das heißt, du wirst einen Wert nicht benutzen), kannst du einen Unterstrich ('_') verwenden, um das zu kennzeichnen:

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)"

Der einzelne '_' sollte beim Pattern Matching immer zuletzt kommen. Jeder Wert, der auf keinen der anderen Fälle passt, wird von diesem Fall behandelt.

Anleitung

In dieser Übung schreibst du Code, um eine Liste von Programmiersprachen zu verwalten, die du auf Exercism lernen möchtest.

Du hast sechs Aufgaben, die sich alle mit Listen befassen.

1. Erstelle eine neue Liste

Um die Sprachen, die du lernen möchtest, im Blick zu behalten, musst du eine neue Liste erstellen. Definiere die Bindung newList, die eine neue, leere Liste enthält.

newList
// => []

2. Definiere eine vorhandene Liste

Momentan hast du einen Zettel, auf dem die Sprachen stehen, die du lernen möchtest: F#, Clojure und Haskell. Definiere die Bindung existingList, um diese Liste darzustellen.

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

3. Füge einer Liste eine neue Sprache hinzu

Wenn du Exercism erkundest und weitere interessante Sprachen findest, möchtest du sie deiner Liste hinzufügen. Implementiere die Funktion addLanguage, um eine neue Sprache an den Anfang deiner Liste einzufügen.

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

4. Zähle die Sprachen in der Liste

Die Sprachen einzeln zu zählen ist umständlich. Implementiere die Funktion countLanguages, um die Anzahl der Sprachen in deiner Liste zu zählen.

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

5. Kehre die Liste um

Irgendwann stellst du fest, dass deine Liste tatsächlich rückwärts sortiert ist! Implementiere die Funktion reverseList, um deine Liste umzukehren.

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

6. Prüfe, ob die Liste spannend ist

Obwohl du alle Sprachen liebst, hat F# einen besonderen Platz in deinem Herzen. Deshalb begeistert dich eine Liste von Sprachen richtig, wenn:

  • Das erste Element in der Liste ist F#.
  • Das zweite Element in der Liste ist F# und die Liste enthält entweder zwei oder drei Sprachen.

Implementiere die Funktion excitingList, um zu prüfen, ob eine Liste von Sprachen spannend ist:

excitingList ["Nim"; "F#"]
// => true
Über GitHub bearbeiten Der Link öffnet sich in einem neuen Fenster oder Tab
F# Exercism

Bereit, mit Tracks on Tracks on Tracks zu starten?

Melde dich bei Exercism an, um F# mit 18 Konzepte148 Übungen und echtem menschlichen Mentoring zu lernen und zu meistern, alles kostenlos.