Ejercicio: usar bucles

Completado

En este ejercicio, crearemos una baraja de naipes para un juego de cartas que está en desarrollo. Usaremos construcciones de bucle para iterar por los naipes y, seguidamente, imprimir el naipe que proceda en pantalla. Nuestros compañeros también han trabajado muy intensamente y ya han incluido en una función el código que creamos en el primer ejercicio.

Scaffolding de un proyecto

Empezaremos realizando el scaffolding de un nuevo proyecto de F# en la consola. Ejecute el comando dotnet new:

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

Creación de la descripción de un naipe

Nuestros compañeros han tomado el código que escribimos en el ejercicio anterior y lo han convertido en una función, de modo que se puede reutilizar. Este es el aspecto actual del código:

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

Para crear la descripción de un naipe:

1. En Program.fs, reemplace el contenido por el código siguiente:

   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 función se denomina cardDescription, y el parámetro de entrada es card. Los compañeros nos han pasado un fragmento de código con el que trabajar. Quieren que implementemos una función parecida, pero que determine a qué palo pertenece el naipe. Nos han pasado este fragmento de código:

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

   Ahora, pondremos en práctica los conocimientos adquiridos sobre if...else para determinar a qué palo pertenece el naipe. Las reglas son: 0 corresponde a corazones; 1, a picas; 2, a diamantes, y 3, a tréboles.

   Sugerencia

   Parémonos a pensar cómo queremos poner en práctica los conocimientos adquiridos antes de continuar.

2. Realice los siguientes cambios en el código:

   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" 
   

   Ahora, el código en Program.fs debería parecerse al del siguiente ejemplo:

   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
   

Enhorabuena, ha terminado esa parte del juego de naipes.

Impresión de la baraja

De nuevo, los compañeros nos han ayudado a crear una baraja de naipes, así que solo tenemos que imprimirla. Este es el código de la baraja de naipes:

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

Para imprimir la baraja:

1. Agregue la definición cards al método main():

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

   La baraja solo contiene cuatro naipes. En una implementación más realista, el código contendría los 52 naipes, pero esta lista es más que suficiente como ejemplo.

   De nuevo, los compañeros han vuelto a escribir el código que necesitamos. Solo tenemos que rellenar lo que falta. Este es un fragmento de código:

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

   El código consta de una línea de comentario. Nuestra tarea consiste en agregar código para implementar un bucle for...in.

2. Agregue el siguiente código al método main() para implementar el bucle for...in:

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

   El método main() debería ser similar a este código:

   [<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. Llame a dotnet run para ejecutar el proyecto:

   dotnet run
   

   Debería ver la siguiente salida:

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

¡Enhorabuena! Hemos trabajado con código que hemos desarrollado e implementado con nuestros compañeros para conseguir un programa con una apariencia más realista.

Ahora, Program.fs se parece al siguiente código:

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