Sopa de Letras

Publicado por Sergio 17/04/2005

[ Hits: 7.994 ]

Download ex1




Este script e baseado no tradicional jogo sopa de letras muito utilizado em revistas e jornais. E um exemplo tipico de manipulacao de strings e matrizes.

  



Esconder código-fonte

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#define NUM 100

int e_prefixo (char s1[], char s2[])
{
   int i, a;
   for (i=0, a=1; i<strlen (s1); i++)
   {
      a=a && (s1[i]==s2[i]);
   }
   return a;
}

int contem (char s1[], char s2[])
{
   int k;
   for (k=0; k<strlen (s2); k++)
   {
      if (e_prefixo (s1, s2+k))
         return k+1;
   }
   return 0;
}

char *strlwr (char *s)
{
   int i;
   for (i=0;s[i]!='{FONTE}';i++)
   {
      s[i]=tolower (s[i]);
   }
   return s;
}


int main ()
{
   char matriz [NUM] [NUM];

   int colunas, linhas, i, j, k, s, l, m, n_palavras, ac,w ;

   char array_aux [NUM];
   char array_aux2 [NUM];
   char matrizdois [NUM] [NUM];
   char matrizdoisaux [NUM];
    char matrizlesi [NUM] [NUM];     
        system ("clear");
        printf ("Introduza o numero de colunas da sopa:\n");
   scanf (" %d", &colunas);
   printf ("Introduza o numero de linhas da sopa:\n");
        scanf (" %d", &linhas);
        printf ("Introduza a sopa linha por linha em forma de matriz\n"); 
   // recebe a matriz e mete tudo dentro de um array
   for (i=0; i<linhas; i++) 
   {
      scanf (" %s", array_aux);
      for (j=0; j<colunas; j++) 
           {
         strlwr (array_aux);
         matriz [i][j] = array_aux [j];
      }
   }
        printf ("Introduza o numero de palavras a procurar\n");
   scanf (" %d", &n_palavras);
        printf ("Introduza as palavras a procurar linha por linha\n");
   for (i=0; i<n_palavras; i++)
   {
      scanf (" %s", matrizdoisaux);
           for (j=0;matrizdoisaux [j]!= '{FONTE}';j++)
      {
         matrizlesi [i][j] = matrizdoisaux [j];
      }


      for (j=0; matrizdoisaux [j]!= '{FONTE}'; j++)
      {
      
         strlwr (matrizdoisaux);
         matrizdois [i][j] = matrizdoisaux [j];
         
      }
      matrizdois [i][j] = '{FONTE}';
   }

   for (i=0; i<n_palavras; i++)
   {
      ac=0;
      for (j=0; matrizdois [i][j]!='{FONTE}';j++)
      {
         array_aux [j] = matrizdois [i][j];
      }
      array_aux [j] = '{FONTE}';
        puts ("\n\n");
        puts ("--RESULTADO--");
        puts ("");  
      // Procura posicoes E=Este=Horizontal (da esquerda para a direita)
      for (k=0; k<linhas; k++)
      {
         for (j=0; j<colunas; j++)
         {
            array_aux2 [j] = matriz [k][j];
         }
         array_aux2 [j] = '{FONTE}';
      
             
              for (w=0;contem (array_aux,array_aux2+w);w++)
         

         if (e_prefixo (array_aux, array_aux2+w))
         {
            printf ("%s E %d %d\n", matrizlesi [i], k+1,w+1);
            ac=1;
            
         }
           
                 }

      //procura posicoes O=Oeste=Horizontal invertida (da direita para a esquerda)
      for (k=0; k<linhas; k++)
      {
         for (l=0, j=colunas-1; j>=0; j--, l++)
         {
            array_aux2 [l] = matriz [k][j];
         }
         array_aux2 [l] = '{FONTE}';

         for (w=0;contem (array_aux,array_aux2+w);w++)
         {         

         if (e_prefixo (array_aux, array_aux2+w))
         {
            printf ("%s O %d %d\n", matrizlesi [i], k+1, strlen (array_aux2)-w);
            ac=1;
         }
         }
      }

      // procura posicoes S=Sul=Vertical (de cima para baixo)
      for (k=0; k<colunas; k++)
      {
         for (j=0; j<linhas; j++)
         {
            array_aux2 [j] = matriz [j][k];
         }
         array_aux [j] = '{FONTE}';

         for (w=0;contem (array_aux,array_aux2+w);w++)
         {

         if (e_prefixo (array_aux, array_aux2+w))
         {
            printf ("%s S %d %d\n", matrizlesi [i], w+1 , k+1);
            ac=1;

         }
          }
      }

      // procura posicoes N=Norte=Vertical invertida (de baixo para cima)
      for (k=0; k<colunas; k++)
      {
         for (l=0, j=linhas-1; j>=0; j--, l++)
         {
            array_aux2 [l] = matriz[j][k];
         }
         array_aux2 [l] = '{FONTE}';

         for (w=0; contem (array_aux,array_aux2+w);w++)
         {

         if (e_prefixo (array_aux, array_aux2+w))
         {
            printf ("%s N %d %d\n", matrizlesi [i], strlen(array_aux2)-w, k+1);
            ac=1;
         }
          }
      }

      // procura posicoes SE
      for (s=0; s<colunas; s++)
      {
         for (l=0, k=0+s; l<linhas && k<colunas; l++, k++)
         {
            array_aux2 [l] = matriz [l][k];
         }
         array_aux2 [l] = '{FONTE}';
         
         if (strlen (array_aux2) >= strlen (array_aux))
         {
            if (contem (array_aux,array_aux2))
            {
               printf ("%s SE %d %d\n", matrizlesi [i], contem (array_aux, array_aux2), contem (array_aux, array_aux2)+s);
               ac=1;
            }
         }
      }

      for (s=1; s<linhas; s++)
      {
         for (l=0+s, k=0; l<linhas && k<colunas; l++, k++)
         {
            array_aux2 [k] = matriz [l][k];
         }
         array_aux2 [k] = '{FONTE}';

         if (strlen (array_aux2) >= strlen (array_aux))
         {
            if (contem (array_aux, array_aux2)) 
            {
            printf ("%s SE %d %d\n", matrizlesi [i], contem (array_aux,array_aux2)+s, contem (array_aux,array_aux2));
            ac=1;
            }
         }
      }

      // procura posicoes NO
      for (s=0; s<colunas; s++)
      {
         for (m=0,l=linhas-1,k=colunas-1-s; l>=0 && k>=0 ; l--, k--, m++)
         {
            array_aux2 [m] = matriz [l][k];
         }
         array_aux2 [m] = '{FONTE}';
         
         if (strlen (array_aux2) >= strlen (array_aux))
         {
            if (contem (array_aux,array_aux2))
            {
               printf ("%s NO %d %d\n", matrizlesi[i], linhas-contem (array_aux, array_aux2)+1, colunas-contem (array_aux, array_aux2)-s+1);
               ac=1;
            }
         }
      }

      for (s=1; s<linhas; s++)
      {
         for (m=0,l=linhas-1-s, k=colunas-1; l>=0 && k>=0; l--, k--, m++)
         {
            array_aux2 [m] = matriz [l][k];
         }

         array_aux2 [m] = '{FONTE}';

         if (strlen (array_aux2) >= strlen (array_aux))
         {
            if (contem (array_aux, array_aux2)) 
            {
            printf ("%s NO %d %d\n", matrizlesi [i], linhas-contem (array_aux,array_aux2)+1-s, colunas-contem (array_aux,array_aux2)+1);
            ac=1;
            }
         }
      }

      // Procura posicoes SO
                for (s=0; s<colunas; s++)
      {
         for (l=0,k=colunas-1-s; l<linhas && k>=0 ; l++, k--)
         {
            array_aux2 [l] = matriz [l][k];
         }
         array_aux2 [l] = '{FONTE}';
         
         if (strlen (array_aux2) >= strlen (array_aux))
         {
            if (contem (array_aux,array_aux2))
            {
               printf ("%s SO %d %d\n", matrizlesi [i], contem (array_aux, array_aux2), colunas-contem (array_aux, array_aux2)-s+1);
               ac=1;
            }
         }
      }

      for (s=1; s<linhas; s++)
      {
         for (m=0,l=0+s, k=colunas-1; l<linhas && k>=0; l++, k--, m++)
         {
            array_aux2 [m] = matriz [l][k];
         }
         array_aux2 [m] = '{FONTE}';

         if (strlen (array_aux2) >= strlen (array_aux))
         {
            if (contem (array_aux, array_aux2)) 
            {
            printf ("%s SO %d %d\n", matrizlesi [i], contem (array_aux,array_aux2)+s, colunas-contem (array_aux,array_aux2)+1);
            ac=1;
            }
         }
      }

      // Procura posicoes NE
                for (s=0; s<colunas; s++)
      {
         for (m=0,l=linhas-1,k=0+s; l>=0 && k<colunas ; l--, k++, m++)
         {
            array_aux2 [m] = matriz [l][k];
         }
         array_aux2 [m] = '{FONTE}';
         
         if (strlen (array_aux2) >= strlen (array_aux))
         {
            if (contem (array_aux,array_aux2))
            {
               printf ("%s NE %d %d\n", matrizlesi [i], linhas-contem (array_aux, array_aux2)+1, contem (array_aux, array_aux2)+s);
               ac=1;
            }
         }
      }

      for (s=1; s<linhas; s++)
      {
         for (l=linhas-1-s, k=0; l>=0 && k<colunas; l--, k++)
         {
            array_aux2 [k] = matriz [l][k];
         }
         array_aux2 [k] = '{FONTE}';

         if (strlen (array_aux2) >= strlen (array_aux))
         {
            if (contem (array_aux, array_aux2)) 
            {
            printf ("%s NE %d %d\n", matrizlesi [i], linhas-contem (array_aux,array_aux2)+1-s, contem (array_aux,array_aux2));
            ac=1;
            }
         }
      }

      // se nao encontrar a palavra em nenhuma posicao escreve so a palavra
      if (ac==0)
         printf ("%s\n", matrizlesi [i]);
   }

   return 0;
}

Scripts recomendados

Multiplicação de Matrizes com ponteiros

Biblioteca do Calculo do Retangulo em C++

primeirafuncao.c - Criando uma função

Utilização de Ponteiros

Problema de Equação do Primeiro Grau


  

Comentários

Nenhum comentário foi encontrado.


Contribuir com comentário




Patrocínio

Site hospedado pelo provedor HostGator.
Linux banner
Linux banner
Linux banner

Destaques

Artigos

Dicas

Viva o Android

Tópicos

Top 10 do mês

Scripts