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.

• Download ex1
• Enviar nova versão

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;
}

Cálculo da equação do segundo grau

clean.h - Biblioteca para limpar um determinado espaço no terminal

Dado três valores, informar o maior e menor número

Simulado

Calcular a potência de um número.

Nenhum comentário foi encontrado.