Percursos
/
Common Lisp
Common Lisp
/
Exercícios
/
O verificador vencedor do Larry
O verificador vencedor do Larry

O verificador vencedor do Larry

Exercício de aprendizagem

Introdução

Arrays

Em Common Lisp, tal como noutras linguagens, um array, ou vetor, é um conjunto de elementos a que se acede através de índices inteiros. Os tipos dos elementos podem ser heterogéneos. O array pode ser multidimensional (não apenas unidimensional).

Criação

make-array permite criar arrays. Tem muitas opções, mas as formas mais simples permitem criar arrays de N dimensões com todos os elementos inicializados com um único valor, ou inicializar o array com os valores de outra sequência (como uma lista). O seu primeiro argumento é uma lista com o tamanho de cada dimensão.

(make-array '(4) :initial-element 3)    ; => #(3 3 3 3)
(make-array '(2 2) :initial-element 'x) ; => #2A((X X) (X X))

(Repara como os arrays N-dimensionais são impressos com o número de dimensões.)

Também é possível criar arrays com o mesmo formato em que são impressos:

#(x y z)         ; => #(X Y Z)
#2A((1 2) (3 4)) ; => #2A((1 2) (3 4))

Acesso aos elementos

Para aceder aos elementos de um vetor usa aref; os índices começam em zero. O número de índices fornecidos tem de corresponder ao número de dimensões do array.

(aref #2A((1 2 3) (3 4 5)) 
       1 0)           ; => 3
(aref #3A(((a b) (c d)) 
           ((e f) (g h)) 
           ((t u) (v w))) 
       2 0 1)         ; => U
(aref #2A((1) (2)) 0) ; => ERROR (because not enough indexes provided)

Instruções

O Larry é um Lisp Alien que gosta de escrever código para jogar. Hoje quer escrever algumas funções para o ajudar num jogo muito parecido com o jogo do galo.

Tal como o jogo do galo, este jogo é jogado num tabuleiro que é uma grelha 3x3.

1. Começar do zero

Primeiro, o Larry precisa de uma função para criar um tabuleiro vazio, make-empty-board. Todas as células do tabuleiro devem ser NIL.

(make-empty-board) ; => #2A((NIL NIL NIL) (NIL NIL NIL) (NIL NIL NIL))

2. Começar a partir de um tabuleiro existente

De seguida, o Larry precisa de uma função para criar um tabuleiro a partir de uma lista de linhas. Por exemplo:

(make-board-from-list '((A B C) (D E F) (G H I))) ; => #2A((A B C) (D E F) (G H I))

3. Condição de vitória

Se houver um caso em que há 3 símbolos iguais numa linha, então esse jogador ganhou. O Larry vai precisar de uma função, all-the-same-p, que, dado um array de 3 itens, avalia para T se todos os itens forem o mesmo símbolo. (Podes usar eq para determinar se dois símbolos são iguais.)

(all-the-same-p #(A A A)) ; => T
(all-the-same-p #(A B C)) ; => NIL

4. Numa linha

Agora o Larry precisa de uma forma de obter os elementos de uma linha. A função row recebe um tabuleiro e um número de linha e deve devolver um array com os elementos dessa linha.

(row #2A((1 2 3) (4 5 6) (7 8 9)) 1) ; => #(4 5 6)

5. Numa coluna

Por fim, o Larry precisa de uma forma de obter os elementos de uma coluna. A função column recebe um tabuleiro e um número de coluna e deve devolver um array com os elementos dessa coluna.

(column #2A((1 2 3) (4 5 6) (7 8 9)) 1) ; => #(2 5 8)
Editar via GitHub A ligação abre numa nova janela ou separador
Common Lisp Exercism

Estás pronto para começar O verificador vencedor do Larry?

Inscreve-te no Exercism para aprenderes e dominares Common Lisp com 27 conceitos92 exercícios, e mentoria humana real, tudo grátis.