Jogo de caça-palavras

manoel.junior · 9 de abril de 2010

E aí pessoal, blzinha? Estou elaborando um trabalho pra faculdade e tenho encontrado alguns problemas.

Tenho que montar um Jogo de caça-palavras: Dadas uma matriz de letras NxN e uma lista de M

palavras, encontrar as palavras na matriz. As palavras podem estar na

horizontal, vertical ou diagonal em qualquer direção (para um total de 8

direções).

exemplo:

dada a matriz:

L I M A

E E B I

L P N P

A N T A

e as palavras:

LIMA

ELA

MEL

AMOR

CASA

ANEL

imprimir:

LIMA – PALAVRA ENCONTRADA

ELA – PALAVRA ENCONTRADA

MEL – PALAVRA ENCONTRADA

AMOR – PALAVRA NAO ENCONTRADA

CASA – PALAVRA NAO ENCONTRADA

ANEL – PALAVRA ENCONTRADA

Já montei algumas direções, mas o programa não encontra as palavras ELA e PIA, por exemplo. já identifquei o erro, mas não sei como corrigir (compara matriz[0][0] com vetor[1][0], não encrontra. então compara matriz[1][0] com vetor[1][1] em de repetir o procedimento anterior)

outro problema é que não tenho ideia como faço pra encontrar palavras nas diagonais, como por exemplo a palvra MEL e ANEL.

taí o que já consegui fazer:



#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char *argv[])
{
    int count,count2,i=1,j=0, r,n, tam, encont=0;
    printf("BEM VINDO AO JOGO DE CACA-PALAVRAS\n");
    printf("\nDIGITE O TAMANHO DA MATRIZ NxN: ");
    scanf("%d",&tam);
    fflush(stdin);
    char matriz[tam][tam+1];
    printf ("\nDIGITE AS LETRAS DA MATRIZ:\n\n");  
    	for (count=0;count<tam;count++)
            {
            fflush(stdin);
           	gets (matriz[count]);
            }

    printf("\nDIGITE O NUMERO DE PALAVRAS DESEJADO:");
        scanf("%d", &n);
        char vetor[n][n+20]; //CRIA UMA MATRIZ COM AS PALAVRAS QUE SERÃO PROCURADAS
        int resp[n][n];
        char auxiliar[n];

    printf("\nDIGITE AS PALAVRAS:\n");
        for(count=0;count<n;count++){
                                     fflush(stdin);
                                     gets(vetor[count]);
                                     }

    ///////////DIREÇÃO HORIZONTAL 1: ESQUERDA -> DIREITA//////////////////////////////////////                               
    for(count=0;count<tam;count++){                          
       for(r=0;r<n;r++){
       encont=0;
          for(count2=0;count2<tam;count2++){
                                            if(matriz[count][count2]==vetor[r][count2]){
                                                                                        encont=encont+1;
                                                                                        }
                                            if(encont==strlen(vetor[r])){
                                                                        encont=0;
                                                                        resp[r][0] = i;
                                            }                                                                            
          }
       }
    }
    ///////////DIREÇÃO HORIZONTAL 1: ESQUERDA -> DIREITA//////////////////////[FIM]//////////
    /////////////////////////////////////////////////////////////////////////////////////////  
    //////////DIREÇÃO HORIZONTAL 2: ESQUERDA <- DIREITA/////////////////////[INICIO]/////////
    for(count=0;count<tam;count++){                          
       for(r=0;r<n;r++){
       encont=0;
          for(count2=0;count2<tam;count2++){
                                            //printf("\nTam - count2: %d", (tam-1)-count2);
                                            if(matriz[count][(tam-1)-count2]==vetor[r][count2]){
                                                                                        encont=encont+1;
                                                                                        }
                                            if(encont==strlen(vetor[r])){
                                                                        encont=0;
                                                                        resp[r][0] = i;
                                            }                                                                            
          }
       }
    }
    //////////DIREÇÃO HORIZONTAL 2: ESQUERDA <- DIREITA/////////////////////[FIM]///////////
    ////////////////////////////////////////////////////////////////////////////////////////
    //////////DIREÇÃO VERTICAL 1: CIMA -> BAIXO////////////////[INICIO]/////////////////////
    for(count=0;count<tam;count++){                          
       for(r=0;r<n;r++){
       encont=0;

          for(count2=0;count2<tam;count2++){
                                            if(matriz[count2][count]==vetor[r][count2]){
                                                                                        encont=encont+1;
                                                                                        }
                                            if(encont==strlen(vetor[r])){
                                                                        encont=0;
                                                                        resp[r][0] = i;
                                                                        break;
                                            } 
                                            }                                                                       
       }
    }

    //////////DIREÇÃO VERTICAL 1: CIMA -> BAIXO////////////////[FIM]/////////////////////
    /////////////////////////////////////////////////////////////////////////////////////
    //////////DIREÇÃO VERTICAL 2: BAIXO -> CIMA////////////////[INICIO]/////////////////////
    for(count=0;count<tam;count++){                          
       for(r=0;r<n;r++){
       encont=0;
          for(count2=0;count2<tam;count2++){
                                            //printf("\nTam - count2: %d", (tam-1)-count2);
                                            if(matriz[(tam-1)-count2][count]==vetor[r][count2]){
                                                                                        encont=encont+1;
                                                                                        }
                                            if(encont==strlen(vetor[r])){
                                                                        encont=0;
                                                                        resp[r][0] = i;
                                            }                                                                            
          }
       }
    }
    //////////DIREÇÃO VERTICAL 2: BAIXO -> CIMA////////////////[FIM]/////////////////////

    printf("\nRESULTADO:\n");
    for(count=0;count<n;count++){   
       if((resp[count][0])==1){            //SE RESPOSTA A LINHA [COUNT][0] DE RESPOSTA FOR IGUAL A 1, PALAVRA ENCONTRADA
          printf("\n%s", vetor[count]);
          printf(" - PALAVRA ENCONTRADA\n");
       }
       else{
            printf("\n%s", vetor[count]);
          printf(" - PALAVRA NAO ENCONTRADA\n");
          }
    }

  system("PAUSE");	
  return 0;
}