Übung: Anwenden von Listeneigenschaften

Abgeschlossen

Angenommen, Sie arbeiten als Entwickler für ein Spieleunternehmen. Sie wurden gebeten, den Ausgangscode für ein Kartenspiel zu schreiben. Ihre erste Aufgabe besteht darin, einen Kartenstapel und anschließend eine Funktion zu erstellen, mit der Karten einzeln vom Stapel gezogen werden können.

Erstellen eines Kartenstapels

Ein Kartenstapel besteht aus 52 Karten. Doch um das Lesen der Konsolenausgabe zu vereinfachen, soll der Stapel hier nur aus fünf Karten bestehen. Erstellen Sie eine Zahlenreihe, indem Sie zwei von Leerzeichen umschlossene Punkte (..) zwischen das erste und das letzte Element in der Liste einfügen.

1. Erstellen Sie in der Konsole ein neues Projekt, indem Sie dotnet new ausführen:

   dotnet new console --language F# -o Cards
   cd Cards
   

2. Um eine Liste zu erstellen, die die Karten enthält, fügen Sie in der Datei "Program.fs " den folgenden Code hinzu:

   let cards = [ 0 .. 5 ]
   

   Mit diesem Code wird eine Liste der Zahlen 0 bis 5 erstellt.

Ziehen von Karten aus dem Stapel

Nachdem Sie den Kartenstapel erstellt haben, können Sie eine Methode zum Ziehen von Karten aus dem Stapel entwickeln. Verwenden Sie hierzu die integrierten Eigenschaften Head und Tail.

1. Erstellen Sie als nächstes eine Funktion drawCard():

   let drawCard (list:int list) = 
       printfn "%i" list.Head
       list.Tail 
   

   Mithilfe der Eigenschaft Head lesen Sie das erste Element in der Liste. Durch die Rückgabe von Tail simulieren Sie das Ziehen einer Karte vom Anfang der Liste und die Rückgabe der verbleibenden Karten in den Stapel.

2. Fügen Sie der main()-Methode den folgenden Code hinzu, um Ihre Implementierung zu testen:

   let result = cards |> drawCard |> drawCard // 0 1
   

3. Führen Sie das Projekt aus, indem Sie dotnet run aufrufen:

   In der Konsolenausgabe sollten nun 0 und 1 angezeigt werden.

Glückwunsch! Sie haben einen Kartenstapel implementiert, von dem Karten gezogen werden können.

Ziehen von Karten in eine Hand

Von Ihrem Kartenstapel können nun Karten gezogen werden. Doch in der Regel gibt es in einem Kartenspiel zwei oder mehr Spieler, die diese Karten ziehen und aufnehmen. Wie Sie wissen, wird die Sammlung der gezeichneten Karten jedes Spielers als Hand bezeichnet. Als Nächstes müssen Sie Code implementieren, damit jede gezogene Karte einer Hand hinzugefügt wird.

1. Fügen Sie den folgenden Code dem Code hinzu, in dem Sie die Liste cards deklariert haben:

   let hand = []
   

2. Ändern Sie als Nächstes die Methode drawCard(), damit sie ein Tupel bestehend aus zwei Listen akzeptiert, die jeweils den Kartenstapel und die Hand darstellen:

   let drawCard (tuple: int list * int list) = 
       let deck = fst tuple
       let draw = snd tuple
       let firstCard = deck.Head
       printfn "%i" firstCard
   
       let hand = 
           draw
           |> List.append [firstCard]
   
       (deck.Tail, hand)
   

   Mit der Funktion fst() greifen Sie auf die erste Eigenschaft im Tupel (also den Kartenstapel) zu. Mit der Funktion snd greifen Sie auf die Hand zu. Sie haben außerdem den Rückgabetyp so geändert, dass er ein Tupel bestehend aus dem Kartenstapel und Ihrer Hand (deck.Tail, hand) zurückgibt, jedoch mit der hinzugefügten Karte firstCard.

3. Ändern Sie den Code in der main-Methode, um Karten in die Hand zu ziehen:

   let d, h = (cards, hand) |> drawCard |> drawCard
   
   printfn "Deck: %A Hand: %A" d h // Deck: [2; 3; 4; 5] Hand: [1; 0]
   

4. Führen Sie das Projekt aus, indem Sie dotnet run aufrufen:

   dotnet run
   

   In der Konsole sollte folgende Ausgabe angezeigt werden:

   Deck: [2; 3; 4; 5] Hand: [1; 0]
   

Glückwunsch! Sie haben es geschafft, für jedes Ziehen einer Karte einen Spieler hand zu simulieren.