INF 1620 Estruturas de Dados Semestre Segundo Trabalho: Jogo de Caça-Palavras

Transcrição

1 INF 1620 Estruturas de Dados Semestre 08.2 Segundo Trabalho: Jogo de Caça-Palavras O jogo de caça-palavras é um passatempo que consiste em descobrir palavras escondidas entre um conjunto de letras espalhadas de forma aparentemente aleatória em uma tabela retangular. O objetivo do jogo é encontrar e assinalar todas essas palavras tão rapidamente quanto possível. As palavras podem estar escondidas dentro da tabela verticalmente, horizontalmente ou diagonalmente, e podem ser arranjadas somente de modo a ser lidas da esquerda para a direita ou de cima para baixo, ou --- em passatempos de maior grau de dificuldade --- também nos sentidos opostos. Algumas vezes é fornecida uma lista de palavras escondidas, entretanto os passatempos mais desafiadores exigem que o jogador descubra as palavras sem este auxílio. A maioria dos passatempos de caça-palavras tem também um tema comum ao qual todas as palavras escondidas estão relacionadas. Como exemplo, na tabela abaixo 20 nomes de fruta estão escondidos entre letras dispostas em uma matriz de 13 linhas e 39 colunas. N Q T W A C F I L O R U X C D G J M P O V Y B E H K N Q T E Z C O I L O R U X X A D G B M P S V Y B E H K E Q T W A C F I L O R U X A T G J M P A V Y B E J H K N L A R A N J A L O R U X R D L J M P S V Y B E H A N Q T W Z C M I L O A R U X A C G J M P S V Y B E H K E Q T W Z C F I L O C U X A D G A M P I V Y B B E H K A Q T W A C F I L O R M X J D G J M P I T A N G A K N Q N W Z C L I U L O R U X A D G J C P P V Y B E H K A Q T A Z C B I L O R U X A I G J M P S T V Y B E I K O Q T W E C F I L O B U O A D G J A P S V Y B E H K R Q T W Z C I F I L O R U X C D S J R P S V Y A E G K N N T W Z P F I L O R U E A D G J M C P S V Y B E H K S Q T W O C F I N O N U X A D G J E P A B A I O G K N Q T W A Z C F I L O R E X A D G J L P S A Y A R O M A Q T R Z C F I L O N U X A D G B J M P S V Y G E H K M Q T W A C N I R O R U X A D A J M A I C N A L E M N Q A T W Z C F O L O R U X A D G J M A S O Y B E H K N Q T W Z C F I T O R U X A D D G J M P S V Y B E H K D Q T W Z C M I L O R C A Q U I J M P S V Y B E H K N O objetivo deste trabalho é a implementação de um conjunto de funções para a criação e manipulação de uma matriz de dados, de forma a permitir, em uma primeira fase, a montagem de um jogo de caça-palavras que, em uma segunda fase, será solucionado por um jogador. Essa matriz é armazenada em um vetor (unidimensional) e cada elemento é do tipo de dados Item, definido a partir da estrutura item, conforme descrito a seguir: typedef int Direcao[8]; struct item { char letra; Direcao* palavra; }; typedef struct item Item; Observe que a estrutura item possui os campos letra e palavra. O primeiro armazena uma variável do tipo char representando o caractere contido naquela posição da matriz, que pode fazer parte de uma palavra escondida ou ser um caractere qualquer. O segundo

2 armazena um ponteiro para um vetor que indica em que direção existem palavras escondidas que passam por aquela posição da matriz, caso haja alguma. Ou seja, o campo palavra contém um ponteiro para um tipo de dados Direcao, definido como um vetor de inteiros com oito elementos. Cada elemento, dependendo de seu índice, representa uma direção na matriz de caça-palavras, de acordo com a tabela a seguir: Índice Direção da(s) palavra(s) escondida(s) 0 Horizontal da esquerda para a direita 1 Horizontal da direita para a esquerda 2 Vertical de cima para baixo 3 Vertical de baixo para cima 4 Diagonal da esquerda para a direita e de cima para baixo 5 Diagonal da esquerda para a direita e de baixo para cima 6 Diagonal da direita para a esquerda e de cima para baixo 7 Diagonal da direita para a esquerda e de baixo para cima Cada um desses elementos poderá armazenar o valor 1 ou 0 indicando, respectivamente, se há ou não uma palavra passando por aquela posição, escrita na direção representada pelo elemento do vetor correspondente (de acordo com a tabela apresentada). Por exemplo, considerando o jogo de caça-palavras de 13 x 39 apresentado anteriormente: o elemento de índice 0 do vetor que armazena a matriz de caçapalavras conteria uma estrutura item com o valor 'N' no campo letra e NULL no campo palavra; o elemento de índice 4 conteria uma estrutura item com o valor 'A' no campo letra, e o campo palavra com um ponteiro para uma variável do tipo Direcao cujo valor do elemento de índice 2 seria 1 e dos demais, 0, indicando que aquele caractere pertence apenas a uma palavra que passa por ali na vertical, de cima para baixo (ABACAXI); o elemento de índice 82 conteria uma estrutura item com o valor 'L' no campo letra, e o campo palavra com um ponteiro para uma variável do tipo Direcao cujo valor do elemento de índice 0 seria 1 e dos demais, 0, indicando que aquele caractere pertence apenas a uma palavra que passa por ali na horizontal, escrita da esquerda para a direita (LARANJA); o elemento de índice 83 conteria uma estrutura item com o valor 'A' no campo letra, e o campo palavra com um ponteiro para uma variável do tipo Direcao cujo valor dos elementos de índices 0 e 2 seria 1 e dos demais, 0, indicando que aquele caractere pertence tanto a uma palavra que passa por ali na horizontal, escrita da esquerda para a direita, quanto a uma palavra que passa por ali na vertical, de cima para baixo (ABACAXI e LARANJA). Na figura a seguir, apresentamos um outro exemplo em que uma matriz de caçapalavras de dimensões 5 x 3 esconde 3 nomes de frutas: uva, pêra e umbu. À esquerda pode ser visto como a matriz seria apresentada ao jogador, que identificaria as palavras

3 conforme estão assinaladas. A palavra UMBU aparece escrita verticalmente, de cima para baixo, a palavra PERA aparece escrita verticalmente, de baixo para cima e a palavra UVA aparece escrita diagonalmente, da esquerda para a direita e de baixo para cima. A parte da direita da figura mostra como seria o conteúdo de cada elemento da matriz de caça-palavras, que é constituída pelo tipo de dados Item. As funções que devem ser implementadas são descritas na interface da biblioteca cacapalavras.h, apresentada a seguir.

4 /* cacapalavras.h */ /* Função Preenche Cria dinamicamente a matriz que representa */ /* o passatempo de caça-palavras. Ou seja, como esta matriz é */ /* armazenada como um vetor do tipo /Item/, este deve ser alocado */ /* dinamicamente e inicializado. Cada campo /palavra/ deve ser */ /* inicializado com NULL, enquanto cada campo /letra/ deve ser */ /* inicializado com caracteres (LETRAS MAIÚSCULAS) escolhidos */ /* de acordo com os parâmetros de entrada. */ /* m número de linhas; */ /* n número de colunas; */ /* ini caractere que deve ocupar a posição inicial da matriz, */ /* ou seja, o campo /letra/ do primeiro elemento do vetor; */ /* incrv valor que deve ser adicionado a um caractere para */ /* calcular o caractere que ocupa a mesma coluna, mas na */ /* linha abaixo deste; */ /* incrh valor que deve ser adicionado a um caractere para */ /* calcular o caractere que ocupa a mesma linha, mas na */ /* coluna a direita deste. */ /* Obs.: Para os cálculos descritos acima, o intervalo */ /* de caracteres valido de 'A'...'Z' deve ser tratado */ /* como uma lista circular, ou seja, considerando */ /* que depois do 'Z' a contagem retorna ao 'A'. Por */ /* exemplo, 'Y'+3='B' e 'V'+10='F'. */ /* Saída: Ponteiro para o novo vetor alocado (que contem a matriz */ /* de caça-palavras), ou NULL se não for possível */ /* realizar a alocação do vetor. */ Item* preenche(int m, int n, char ini, int incrv, int incrh); /* Função Esconde Responsável pelo armazenamento de uma palavra */ /* em uma dada posição da matriz caça-palavras. Ou seja, deve */ /* atualizar o valor de cada elemento da matriz que armazena */ /* informações sobre a palavra escondida, ou seja, aqueles */ /* elementos que correspondem as posições onde sera colocado cada */ /* caractere da palavra escondida. Dessa forma, a função devera */ /* atribuir o valor correto do caractere ao campo /letra/ e os */ /* elementos do vetor indicado por /palavra/, de acordo com o */ /* sentido indicado para a palavra escondida. Se não havia uma */ /* palavra passando por essa posição e portanto o campo */ /* /palavra/ tinha valor NULL, uma nova variável /Direção/ deve */ /* ser alocada dinamicamente. */ /* m número de linhas da matriz caça-palavras; */ /* n número de colunas da matriz caça-palavras; */ /* mat ponteiro para o vetor que contem a matriz de */ /* caça-palavras; */ /* x linha da matriz onde deve ser colocado o primeiro */ /* caractere da palavra a ser escondida; */

5 /* y coluna da matriz onde deve ser colocado o primeiro */ /* caractere da palavra a ser escondida; */ /* p palavra a ser escondida; */ /* s inteiro indicando o sentido em que os caracteres da */ /* palavra devem ser distribuídos: */ /* 0 - horizontalmente, para a direita */ /* 1 - horizontalmente, para a esquerda */ /* 2 - verticalmente, para baixo */ /* 3 - verticalmente, para cima */ /* 4 - diagonalmente, para direita e para baixo */ /* 5 - diagonalmente, para direita e para cima */ /* 6 - diagonalmente, para a esquerda e para baixo */ /* 7 - diagonalmente, para a esquerda e para cima */ /* Saída: Inteiro indicando se a operação de esconder foi bem */ /* sucedida, de acordo com os seguintes valores: */ /* 0 - operação bem sucedida; */ /* 1 - operação falhou porque a palavra contem caracteres */ /* inválidos (fora dos intervalos 'a'...'z' ou */ /* 'A'...'Z'; */ /* 2 - operação falhou porque a palavra ultrapassa os */ /* limites da matriz caça-palavras; */ /* 3 - operação falhou porque esta interceptaria outra */ /* palavra, sobrepondo-a com um caractere diferente */ /* de outro previamente armazenado; */ /* 4 - operação falhou porque não foi possível alocar */ /* dinamicamente a variável do tipo /Direcao/. */ /* Obs: No caso de ocorrer alguma das falhas mencionadas, */ /* o vetor fornecido como parâmetro não deve ser alterado */ /* e qualquer variável dinâmica que tenha sido alocada */ /* desnecessariamente deve ser liberada */ int esconde(int m, int n, Item* mat, int x, int y, char* p, int s); /* Função Mostra Imprime na tela a matriz caça-palavras */ /* fornecida como parâmetro. */ /* m número de linhas da matriz caça-palavras; */ /* n número de colunas da matriz caça-palavras; */ /* mat ponteiro para o vetor que contem a matriz de */ /* caça-palavras. */ void mostra(int m, int n, Item* mat); /* Função Libera Libera as variáveis alocadas dinamicamente */ /* para armazenar a matriz caça-palavras e informações sobre */ /* as palavras escondidas. */ /* m número de linhas da matriz de caça-palavras; */ /* n número de colunas da matriz de caça-palavras; */

6 /* mat ponteiro para o vetor que contem a matriz de */ /* caça-palavras. */ /* Saída: Inteiro indicando se a operação de liberar foi bem */ /* sucedida, de acordo com os seguintes valores: */ /* 0 - operação bem sucedida; */ /* 1 - operação falhou. */ int libera(int m, int n, Item* mat); /* Função Descobre Verifica se uma dada palavra esta armazenada */ /* em uma matriz de caça-palavras, entre as posições fornecidas */ /* como parâmetros. */ /* m número de linhas da matriz caça-palavras; */ /* n número de colunas da matriz caça-palavras; */ /* mat ponteiro para o vetor que contem a matriz de */ /* caça-palavras; */ /* x1 linha da matriz onde estaria o primeiro caractere da */ /* y1 coluna da matriz onde estaria o primeiro caractere da */ /* x2 linha da matriz onde estaria o ultimo caractere da */ /* y2 coluna da matriz onde estaria o ultimo caractere da */ /* p palavra a ser verificada; */ /* Saída: Inteiro indicando se a palavra foi encontrada conforme */ /* descrito, de acordo com os seguintes valores: */ /* 0 - se não foi encontrada, conforme descrita; */ /* 1 - se foi encontrada; */ int descobre(int m, int n, Item* mat, int x1, int y1, int x2, int y2, char* p);

7 OBSERVAÇÕES: 1 - A especificação dos tipos de dados e funções que devem ser implementadas estão no arquivo cacapalavras.h, que está disponível no site do enunciado do trabalho e cujo conteúdo não pode ser alterado. 2 O código completo da função esconde está sendo fornecido no arquivo cacapalavras.c para ser utilizada pelos alunos. 3 Além da função esconde (que foi fornecida), os alunos deverão implementar e incluir em cacapalavras.c todas as demais funções descritas no arquivo cacapalavras.h. 4 A função main, fornecida no arquivo Testa_Jogo.c, tem somente a finalidade de demonstrar a utilização das funções implementadas, executando algumas das ações descritas no enunciado. Além disso, pode servir também como modelo para a implementação de testes mais completos. 5 O arquivo cacapalavras.c deve ser enviado contendo apenas as funções implementadas. Ou seja, o seu arquivo submetido NÃO deve possuir a função main. A correção do trabalho será realizada pelo corretor automático, que terá um programa que chamará as funções conforme declaradas na interface cacapalavras.h. 6 Programas que não compilarem receberão nota zero. O programa não pode ser escrito usando a sintaxe própria de C++ ou funções que não são do padrão de C. Programas que compilarem serão executados e avaliados numa seqüência de testes. 7- Certamente cada aluno pode discutir com seus colegas (e com seus professores) a forma de implementação que empregará. Observamos, entretanto, que os trabalhos são individuais. Trabalhos similares poderão ter suas notas reduzidas, podendo receber nota zero se o grau de similaridade for muito acentuado. 8 Data de entrega: 21 de Outubro.