Exercice – Utiliser des boucles

  • 2 minutes

Dans cet exercice, vous allez créer un paquet de cartes pour un jeu de cartes en cours de développement. Vous allez utiliser des constructions de boucle pour itérer sur les cartes et imprimer une carte sur l’écran. Vos collègues ont eux aussi travaillé dur, incorporant le code que vous avez créé lors du premier exercice dans une fonction.

Structurer un projet

Commencez par générer automatiquement des modèles pour un nouveau projet F# dans la console. Exécutez la commande suivante dotnet new :

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

Créer une description de carte

Vos collègues ont pris le code que vous avez écrit dans le dernier exercice et l’ont transformé en fonction de façon à pouvoir le réutiliser. Voici à quoi ressemble le code maintenant :

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

Pour créer une description de carte :

  1. Dans Program.fs, remplacez le contenu par le code suivant :

    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

    La fonction est nommée cardDescription et le paramètre d’entrée est card. Vos collègues vous ont fourni un extrait de code à utiliser. Ils souhaitent que vous implémentiez une fonction similaire, mais une fonction qui détermine la couleur de la carte. Ils vous ont fourni cet extrait de code :

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

    À présent, servez-vous des connaissances que vous avez acquises sur if...else pour déterminer la couleur d’une carte. Voici les règles : 0 pour le cœur, 1 pour le pique, 2 pour le carreau et 3 pour le trèfle.

    Conseil

    Avant de poursuivre, prenez le temps de réfléchir à la façon de mettre à pratique vos connaissances.

  2. Apportez les modifications suivantes au code :

    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"

    Le code dans Program.fs doit maintenant ressembler à cet exemple :

    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

Félicitations, vous avez terminé cette partie du jeu de cartes.

Là encore, vos collègues vous ont aidé à créer un paquet de cartes. Tout ce que vous avez à faire est de l’imprimer. Voici le code pour le paquet de cartes :

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

Pour imprimer le paquet :

  1. Ajoutez la définition cards à la méthode main() :

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

    Le paquet ne contient que quatre cartes. Dans une implémentation plus réaliste, le code contiendrait les 52 cartes, mais cette liste suffit pour un exemple.

    Encore une fois, vos collègues ont écrit du code pour vous. Vous avez simplement à compléter les éléments manquants. Voici un extrait de code :

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

    Le code se compose d’une ligne commentée. Votre tâche consiste à ajouter du code pour implémenter une boucle for...in.

  2. Ajoutez le code suivant à la méthode main() pour implémenter la boucle for...in :

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

    La méthode main() doit désormais ressembler à ce code :

    [<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. Exécutez le projet en appelant dotnet run :

    dotnet run

    Vous devez normalement voir la sortie suivante :

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

Félicitations ! Vous avez utilisé du code que vous et vos collègues avez implémenté et développé pour en faire un programme plus réaliste.

Program.fs ressemble maintenant à ce code :

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