Ejercicio: Aplicación de propiedades de lista

  • 3 minutos

Supongamos que trabaja desarrollando juegos casuales en una empresa. Se le ha pedido que escriba código inicial que se pueda usar para un juego de cartas. Su primera tarea consiste en crear una baraja de cartas y, a continuación, una función que pueda tomar cartas de la baraja, una a la vez.

Creación de una baraja de cartas

Una baraja tiene 52 cartas, pero, para facilitar la lectura de la impresión de la consola, vamos a reducir la baraja a cinco cartas. Puede crear una serie de números insertando dos puntos (..), rodeados de espacios, entre el primer y el último número de la lista.

  1. En la consola, ejecute dotnet new para crear un proyecto:

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

  2. Para crear una lista que contenga las tarjetas, agregue el código siguiente en el archivo Program.fs:

    let cards = [ 0 .. 5 ]

    Este código crea una lista de números del 0 al 5.

Toma de cartas de la baraja

Ahora que ha creado la baraja, puede diseñar un método para tomar cartas. Para ello, puede usar las propiedades integradas Head y Tail.

  1. Luego, cree una función drawCard():

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

    Con la propiedad Head, lee el primer elemento de la lista y, al devolver Tail, simula tomar una carta de la parte superior de la lista y devuelve las demás a la baraja.

  2. Para probar la implementación, agregue el código siguiente al método main():

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

  3. Llame a dotnet run para ejecutar el proyecto:

    Ahora debería ver que 0 y 1 se imprimen en la consola.

¡Enhorabuena! Ha implementado una baraja de la que puede sacar cartas.

Reparto de cartas para una mano

La capacidad de sacar cartas de la baraja es un buen comienzo, pero normalmente los juegos de cartas necesitan dos o más jugadores para sacarlas. Como sabe, el conjunto de cartas que ha sacado cada jugador se denomina mano. A continuación, deberá implementar código para agregar cada tarjeta tomada a una mano.

  1. Agregue el código siguiente en el código en el que ha declarado la lista cards:

    let hand = []

  2. A continuación, modifique el método drawCard() para aceptar una tupla que conste de dos listas, una que represente la baraja y la otra, la mano:

    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)

    La función fst() se usa para acceder a la primera propiedad de la tupla (es decir, la baraja). La función snd se usa para acceder a la mano. También ha modificado el tipo de valor devuelto para que devuelva una tupla que conste de la baraja y la mano (deck.Tail, hand), pero con la carta firstCard agregada.

  3. Modifique el código del método principal para repartir cartas en la mano:

    let d, h = (cards, hand) |> drawCard |> drawCard

printfn "Deck: %A Hand: %A" d h // Deck: [2; 3; 4; 5] Hand: [1; 0]

  4. Llame a dotnet run para ejecutar el proyecto:

    dotnet run

    Debería ver el resultado siguiente impreso en la consola:

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

¡Enhorabuena! Ha conseguido simular tener un jugador, hand, para cada vez que reparte una carta.