Exercício – Usar loops

2 minutos

Neste exercício, você criará um baralho de cartas para um jogo de cartas em desenvolvimento. Você usará constructos de looping para iterar nas cartas e imprimi-las na tela. Seus colegas também têm trabalhado bastante e incorporaram o código que você criou no primeiro exercício em uma função.

Fazer scaffold de um projeto

Comece fazendo scaffolding de um novo projeto F# no console. Execute o comando dotnet new:

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

Criar uma descrição da carta

Seus colegas pegaram o código que você escreveu no exercício anterior e o transformaram em uma função reutilizável. Veja como o código está agora:

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 criar uma descrição da carta:

Em Program.fs, substitua o conteúdo pelo seguinte código:
```
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
```
A função é nomeada como cardDescription e o parâmetro de entrada é card. Você recebeu dos seus colegas um snippet de código com o qual trabalhará. Eles querem que você implemente uma função semelhante, mas que determine qual é o naipe da carta. Eles lhe forneceram este snippet de código:
```
let suit (no:int) : string = 
    let suitNo:int = no / 13
    // add implementation here 
```
Agora, use o conhecimento que você adquiriu sobre if...else para determinar qual é o naipe de uma carta. As regras são: 0 é copas, 1 é espadas, 2 é ouros e 3 é paus.

Dica

Pare um pouco e pense em como aplicar seu conhecimento antes de continuar.

Faça as alterações a seguir ao 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"

O código em Program.fs agora deve ser semelhante a este exemplo:

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

Parabéns, você concluiu essa parte do jogo de cartas.

Imprimir o baralho

Novamente, seus colegas ajudaram você a criar um baralho de cartas. Agora, basta imprimi-lo. Aqui está o código para o baralho de cartas:

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

Para imprimir o baralho:

Adicione a definição cards ao método main():
```
 [<EntryPoint>]
 let main argv =
     let cards = [ 1; 10; 2; 34 ]
     // implement program
     0 // return an integer exit code
```
O baralho contém apenas quatro cartas. Em uma implementação mais realista, o código conteria as 52 cartas, mas essa lista é suficiente como exemplo.

Seus colegas escreveram mais uma vez um código para você. Você só precisa preencher o que está faltando. Aqui está um snippet de código:
```
// add for loop
  printfn "%s of %s" (cardDescription(card)) (suit(card))
```
O código consiste em uma linha comentada. Sua tarefa é adicionar um código para implementar um loop for...in.

Adicione o seguinte código ao método main() para implementar o loop for...in:

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

Agora, o método main() deve estar como 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

Execute o projeto chamando dotnet run:
```
dotnet run
```
Você deve ver o seguinte resultado:
```
Ace of Hearts 
10 of Hearts
2 of Hearts
8 of Diamonds 
```

Parabéns. Você trabalhou com o código que você e seus colegas implementaram e desenvolveram criando um programa mais realista.

Program.fs agora se parece com este 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

Comentários

Esta página foi útil?