Föregående

Nästa

Övning – Använda loopar

Slutförd

I den här övningen skapar du en kortlek för ett kortspel som är under utveckling. Du använder loopkonstruktioner för att iterera över korten och sedan skriva ut kortet på skärmen. Dina kollegor har också arbetat hårt och de införlivade koden som du skapade i den första övningen i en funktion.

Skapa en autogenerera ett projekt

Börja med att skapa ett nytt F#-projekt i konsolen. Kör kommandot dotnet new:

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

Skapa en kortbeskrivning

Dina kollegor har tagit koden du skrev i föregående övning och gjort den till en funktion, så den kan återanvändas. Så här ser koden ut nu:

let cardDescription (card: int) : string =
    let cardNo: int = card % 13
    if cardNo = 1 then "Ace"
    elif cardNo = 11 then "Jack"
    elif cardNo = 12 then "Queen"
    elif cardNo = 0 then "King"
    else string cardNo

Så här skapar du en kortbeskrivning:

1. I Program.fs ersätter du innehållet med följande kod:

   open System
   
   let cardDescription (card: int) : string =
       let cardNo: int = card % 13
       if cardNo = 1 then "Ace"
       elif cardNo = 11 then "Jack"
       elif cardNo = 12 then "Queen"
       elif cardNo = 0 then "King"
       else string cardNo
   
   [<EntryPoint>]
   let main argv =
       // implement the rest
       0 // return an integer exit code
   

   Funktionen heter cardDescription och indataparametern är card. Dina kollegor gav dig ett kodfragment att arbeta med. De vill att du implementerar en liknande funktion, men en funktion avgör vad som passar kortet. De gav dig det här kodfragmentet:

   let suit (no:int) : string = 
       let suitNo:int = no / 13
       // add implementation here 
   

   Använd nu den kunskap du har fått om if...else att avgöra vad som passar ett kort. Reglerna är: 0 är hjärtan, 1 är spader, 2 är diamanter och 3 är klubbar.

   Dricks

   Pausa och fundera på hur du ska tillämpa dina kunskaper innan du går vidare.

2. Gör följande ändringar i koden:

   let suit (no:int) : string = 
       let suitNo:int = no / 13
       if suitNo = 0 then "Hearts"
       elif suitNo = 1 then "Spades"
       elif suitNo = 2 then "Diamonds"
       else "Clubs" 
   

   Koden i Program.fs bör nu se ut så här:

   open System
   
   let suit (no:int) : string = 
       let suitNo:int = no / 13
       if suitNo = 0 then "Hearts"
       elif suitNo = 1 then "Spades"
       elif suitNo = 2 then "Diamonds"
       else "Clubs" 
   
   let cardDescription (card: int) : string =
       let cardNo: int = card % 13
       if cardNo = 1 then "Ace"
       elif cardNo = 11 then "Jack"
       elif cardNo = 12 then "Queen"
       elif cardNo = 0 then "King"
       else string cardNo
   
   [<EntryPoint>]
   let main argv =
       // implement program
       0 // return an integer exit code
   

Grattis, du har slutfört den delen av kortspelet.

Skriv ut däcket

Återigen har dina kollegor hjälpt dig att skapa en kortlek. Allt du behöver göra är att skriva ut det. Här är koden för kortleken:

let cards = [ 1; 10; 2; 34 ]

Så här skriver du ut däcket:

1. cards Lägg till definitionen i main() metoden:

    [<EntryPoint>]
    let main argv =
        let cards = [ 1; 10; 2; 34 ]
        // implement program
        0 // return an integer exit code
   

   Kortleken innehåller bara fyra kort. I en mer realistisk implementering skulle koden innehålla alla 52 kort, men den här listan räcker till exempel.

   Dina kollegor har återigen skrivit kod åt dig. Du måste bara fylla i det som saknas. Här är ett kodfragment:

   // add for loop
     printfn "%s of %s" (cardDescription(card)) (suit(card))
   

   Koden består av en utkommen rad. Din uppgift är att lägga till kod för att implementera en for...in loop.

2. Lägg till följande kod i main() metoden för att implementera loopen for...in :

   for card in cards do
     printfn "%s of %s" (cardDescription(card)) (suit(card))
   

   Metoden main() bör nu se ut så här:

   [<EntryPoint>]
   let main argv =
       let cards = [ 1; 10; 2; 34 ]
       for card in cards do
         printfn "%s of %s" (cardDescription(card)) (suit(card))
       0 // return an integer exit code
   

3. Kör projektet genom att anropa dotnet run:

   dotnet run
   

   Du bör se följande utdata:

   Ace of Hearts 
   10 of Hearts
   2 of Hearts
   8 of Diamonds 
   

Grattis! Du arbetade med kod som du och dina kollegor implementerade och utvecklade den till mer av ett realistiskt program.

Program.fs ser nu ut så här:

open System

let suit (no:int) : string = 
    let suitNo:int = no / 13
    if suitNo = 0 then "Hearts"
    elif suitNo = 1 then "Spades"
    elif suitNo = 2 then "Diamonds"
    else "Clubs" 

let cardDescription (card: int) : string =
    let cardNo: int = card % 13
    if cardNo = 1 then "Ace"
    elif cardNo = 11 then "Jack"
    elif cardNo = 12 then "Queen"
    elif cardNo = 0 then "King"
    else string cardNo

[<EntryPoint>]
let main argv =

    let cards = [ 1; 10; 2; 34 ]

    for card in cards do
      printfn "%s of %s" (cardDescription(card)) (suit(card))
    0 // return an integer exit code

Fortsätt