Search for a word in a matrix by reading from right to left

If you look you will see that buscar_palabra_horizontal() is not able to search from left to right. Only searches from right to left. In fact, proof of this is that you make exactly the same call for both cases. The only thing that changes is that the columns you travel in the direct sense in one case and in the opposite direction in the other ... but the call to buscar_palabra_horizontal() is exactly the same:

if(buscar_palabra_horizontal(sopa, pal, fila, columna)==1)
  printf("\nEsta en la fila %d y en la columna %d: hacia la derecha", fila, columna);

if(buscar_palabra_horizontal(sopa, pal, fila, columna)==1)
  printf("\nEsta en la fila %d y en la columna %d: hacia la izquierda", fila, columna);

One option is to add an additional parameter to that function to indicate the direction, for example an enumerated one. In this way you can direct the sense in which the algorithm tries to locate the words:

typedef enum Sentido
{
  DerechaAIzquierda,
  IzquierdaADerecha
} Sentido;

int buscar_palabra_horizontal(char sopa[N][M], char pal[M+1], int fil, int col, Sentido sentido)
{
  int sopaIndex= 0;
  int offset = 0;

  switch( sentido )
  {
    case DerechaAIzquierda:
      colIndex= col;
      offset = -1;
      break;

    case IzquierdaADerecha:
      sopaIndex= 0;
      offset = 1;
      break;
  }

  for(int i=0; pal[i]!='
int buscar_palabra_horizontal(char sopa[N][M], char pal[M+1], int fil, int col)
{
  int i, j, resul=1, resul2=2;
  char pal2[M+1], pal3[M+1];

  for(i=0; pal[i]!='
int buscar_palabra_horizontal(char sopa[N][M], char pal[M+1], int fil, int col)
{
  int resul=0; // 0 -> no se encuentra la palabra
  char pal2[M+1], pal3[M+1];

  memset(pal2,M+1,0);
  memset(pal3,M+1,0);

  for(int i=0; pal[i]!='
if(buscar_palabra_horizontal(sopa, pal, fila, columna)==1)
  printf("\nEsta en la fila %d y en la columna %d: hacia la derecha", fila, columna);

if(buscar_palabra_horizontal(sopa, pal, fila, columna)==1)
  printf("\nEsta en la fila %d y en la columna %d: hacia la izquierda", fila, columna);
'; i++)
  {
    pal2[i]=sopa[fil][col+i];
    pal3[i]=pal2[longitud_pal(pal2)-i];
  }

  // Sentido izda->dcha, si se encuentra la palabra se devuelve 1
  // cad_iguales devuelve 1 si encuentra la palabra y 0 en caso contrario
  result = cad_iguales(pal, pal2);

  if( result == 0 )
  {
    // Si cad_iguales devuelve 1 -> palabra encontrada de dcha->izda
    // 1*2==2 -> palabra encontrada dcha->izda
    // 0*2==0 -> palabra no encontrada
    result = cad_iguales(pal, pal3)*2;
  }

  return resul;
}
'; i++)
  {
    pal2[i]=sopa[fil][col+i];
    pal3[i]=pal2[longitud_pal(pal2)-i];
  }

  if(cad_iguales(pal, pal2)!=1)
    resul=0;

  if(cad_iguales(pal, pal3)!=1)
    resul=0;

  return resul;
  return resul2;
}
'; i++, sopaIndex += offset)
  {
    pal2[i]=sopa[fil][sopaIndex];
  }

  // ...
}

EDIT: On the other hand, focusing on your first solution we have:

typedef enum Sentido
{
  DerechaAIzquierda,
  IzquierdaADerecha
} Sentido;

int buscar_palabra_horizontal(char sopa[N][M], char pal[M+1], int fil, int col, Sentido sentido)
{
  int sopaIndex= 0;
  int offset = 0;

  switch( sentido )
  {
    case DerechaAIzquierda:
      colIndex= col;
      offset = -1;
      break;

    case IzquierdaADerecha:
      sopaIndex= 0;
      offset = 1;
      break;
  }

  for(int i=0; pal[i]!='
int buscar_palabra_horizontal(char sopa[N][M], char pal[M+1], int fil, int col)
{
  int i, j, resul=1, resul2=2;
  char pal2[M+1], pal3[M+1];

  for(i=0; pal[i]!='
int buscar_palabra_horizontal(char sopa[N][M], char pal[M+1], int fil, int col)
{
  int resul=0; // 0 -> no se encuentra la palabra
  char pal2[M+1], pal3[M+1];

  memset(pal2,M+1,0);
  memset(pal3,M+1,0);

  for(int i=0; pal[i]!='%pre%'; i++)
  {
    pal2[i]=sopa[fil][col+i];
    pal3[i]=pal2[longitud_pal(pal2)-i];
  }

  // Sentido izda->dcha, si se encuentra la palabra se devuelve 1
  // cad_iguales devuelve 1 si encuentra la palabra y 0 en caso contrario
  result = cad_iguales(pal, pal2);

  if( result == 0 )
  {
    // Si cad_iguales devuelve 1 -> palabra encontrada de dcha->izda
    // 1*2==2 -> palabra encontrada dcha->izda
    // 0*2==0 -> palabra no encontrada
    result = cad_iguales(pal, pal3)*2;
  }

  return resul;
}
'; i++)
  {
    pal2[i]=sopa[fil][col+i];
    pal3[i]=pal2[longitud_pal(pal2)-i];
  }

  if(cad_iguales(pal, pal2)!=1)
    resul=0;

  if(cad_iguales(pal, pal3)!=1)
    resul=0;

  return resul;
  return resul2;
}
'; i++, sopaIndex += offset)
  {
    pal2[i]=sopa[fil][sopaIndex];
  }

  // ...
}

Weird things in this function:

• It has two returns in a row, which means that only the first one will be executed.
• The variable resul2 has no real use.
• Variable j is not used.
• Whenever a word is found it will return the same result, 0, regardless of whether the word has found it right or left, which prevents you from knowing the meaning of the word from outside.
• The conditional of cad_iguales you are complicating too much. If cad_iguales is only going to return 1 or 0 the conditional can be simplified.
• You are not considering the limits of sopa . What happens if I am in column 4 and I try to read a 5-letter word in the left-hand direction? What if I try to read it in the left-hand direction?
• pal2 and pal3 are not initialized. That coupled with the way you copy the strings does not guarantee that they end with '\ 0'.

Corrected function:

It would only be necessary to check if you try to read outside the limits of sopa , but that already runs from your account.

Greetings.

This code proposal works correctly, I've checked it ...

In search_horizontal_palabra ...

1st You have to initialize pal2 and pal3 to avoid any possible unexpected failure, initializing the variables is a good programming practice.

2nd If the remainder of subtracting the column to the size of a M row, is less than the size of the word, it can not be contained in that position, so you must return 0, before continuing processing.

3rd - In order to copy pal2 invested in pal3 , you must first have completely copied soup [fil] [col + i] in pal2 [i] , so you must first complete that loop and then do the second one, since the latter must start by assigning the last char, and this it can not be copied in the first cycle of the first loop, in which pal2 only contains its first assigned element. Therefore we will use two loops.

4th To copy Pal2 invested in pal3 to the expression you put there that subtract 1 , otherwise I would try to copy the size of pal2 - i first (since i is 0 in the first cycle) and this would be outside the index range of the pal2 string. strong> (being exactly its size (chain), exceeds it by 1).

5th For the results to be processed functionally must be nested if, be allocated the expected results in resul (0: No match, 1: to right or 2: left).

In Main ...

6th To the results (rows and columns) we must add 1 to the row and 1 to the column, so that they return - rows and columns -, instead of their indexes; And when it is to the left the columns must be added the size of the word to indicate the column of the first letter of the inverted word (since it is read from right to left). / p>

· · C or d i g o - c o m p r o b a d o · ·

#include<stdio.h>
#define N 5
#define M 7

void mostrar_sopa(char sopa[N][M]);
int buscar_palabra_horizontal(char sopa[N][M], char pal[M+1], int fil, int col);
int cad_iguales (char pal1[], char pal2[]);
int longitud_pal (char pal[]);

void main()
{
    int fila, columna;
    char pal[M];

    char sopa[N][M] =
    {
        'A', 'A', 'P', 'E', 'P', 'A', 'P',
        'B', 'N', 'O', 'T', 'R', 'P', 'Y',
        'P', 'E', 'P', 'E', 'P', 'E', 'W',
        'A', 'P', 'E', 'P', 'I', 'T', 'A',
        'E', 'T', 'O', 'P', 'E', 'P', 'Y',
    };


    mostrar_sopa(sopa);

    printf("\nIntroduce una palabra, de %d caracteres como maximo: ", M);
    gets(pal);


    for(fila=0; fila<N; fila++)
    {
        for(columna=0; columna<M; columna++)
        {
            if(buscar_palabra_horizontal(sopa, pal, fila, columna)==1)
                printf("\nEsta en la fila %d y en la columna %d: hacia la derecha", fila+1, columna+1);

            else if(buscar_palabra_horizontal(sopa, pal, fila, columna)==2)
                printf("\nEsta en la fila %d y en la columna %d: hacia la izquierda", fila+1, columna+longitud_pal(pal));
        }
    }

}

//calcula la longitud de una palabra que recibe como parámetro
int longitud_pal (char pal[M])
{
    int i;

    for(i=0; pal[i] != '
#include<stdio.h>
#define N 5
#define M 7

void mostrar_sopa(char sopa[N][M]);
int buscar_palabra_horizontal(char sopa[N][M], char pal[M+1], int fil, int col);
int cad_iguales (char pal1[], char pal2[]);
int longitud_pal (char pal[]);

void main()
{
    int fila, columna;
    char pal[M];

    char sopa[N][M] =
    {
        'A', 'A', 'P', 'E', 'P', 'A', 'P',
        'B', 'N', 'O', 'T', 'R', 'P', 'Y',
        'P', 'E', 'P', 'E', 'P', 'E', 'W',
        'A', 'P', 'E', 'P', 'I', 'T', 'A',
        'E', 'T', 'O', 'P', 'E', 'P', 'Y',
    };


    mostrar_sopa(sopa);

    printf("\nIntroduce una palabra, de %d caracteres como maximo: ", M);
    gets(pal);


    for(fila=0; fila<N; fila++)
    {
        for(columna=0; columna<M; columna++)
        {
            if(buscar_palabra_horizontal(sopa, pal, fila, columna)==1)
                printf("\nEsta en la fila %d y en la columna %d: hacia la derecha", fila+1, columna+1);

            else if(buscar_palabra_horizontal(sopa, pal, fila, columna)==2)
                printf("\nEsta en la fila %d y en la columna %d: hacia la izquierda", fila+1, columna+longitud_pal(pal));
        }
    }

}

//calcula la longitud de una palabra que recibe como parámetro
int longitud_pal (char pal[M])
{
    int i;

    for(i=0; pal[i] != '%pre%'; i++);

    return i;

}

//compara dos palabras que recibe como parámetros,
// devuelve: 1 si son iguales y 0 si no lo son
int cad_iguales (char pal1[M], char pal2[M])
{
    int i, enc=1;

    for(i=0; pal1[i]!='%pre%' && pal2[i]!='%pre%' && enc; i++)
    {
        if(pal1[i]!=pal2[i])
            enc=0;
    }

    return enc;
}

//Función que permite al usuario mostrar la sopa de letras centrada
void mostrar_sopa(char sopa[N][M])
{
    int i, j;

    for(i=0; i<N; i++)
    {
        printf("                        ");

        for(j=0; j<M; j++)
            printf("%2c", sopa[i][j]);
        printf("\n");
    }
}

//Busca la palabra horizontalmente a partir de una posición de la matriz que
//recibe como parametro
//Devuelve 0 si no la ha encontrado, 1 si la encuentra de izquierda a derecha y 2 si la encuentra de derecha a izquierda
int buscar_palabra_horizontal(char sopa[N][M], char pal[M+1], int fil, int col)
{
    int i, resul=1, resul2=2;

    char pal2[M+1]="", pal3[M+1]="";

    if (M-col<longitud_pal(pal))
       return 0;

    for(i=0; pal[i]!='%pre%'; i++)
        pal2[i]=sopa[fil][col+i];

    for(i=0; pal[i]!='%pre%'; i++)
        pal3[i]=pal2[longitud_pal(pal2)-i-1];


    if(cad_iguales(pal, pal2))
        resul=1;
    else if(cad_iguales(pal, pal3))
        resul=2;
    else resul = 0;

    return resul;
}
'; i++);

    return i;

}

//compara dos palabras que recibe como parámetros,
// devuelve: 1 si son iguales y 0 si no lo son
int cad_iguales (char pal1[M], char pal2[M])
{
    int i, enc=1;

    for(i=0; pal1[i]!='%pre%' && pal2[i]!='%pre%' && enc; i++)
    {
        if(pal1[i]!=pal2[i])
            enc=0;
    }

    return enc;
}

//Función que permite al usuario mostrar la sopa de letras centrada
void mostrar_sopa(char sopa[N][M])
{
    int i, j;

    for(i=0; i<N; i++)
    {
        printf("                        ");

        for(j=0; j<M; j++)
            printf("%2c", sopa[i][j]);
        printf("\n");
    }
}

//Busca la palabra horizontalmente a partir de una posición de la matriz que
//recibe como parametro
//Devuelve 0 si no la ha encontrado, 1 si la encuentra de izquierda a derecha y 2 si la encuentra de derecha a izquierda
int buscar_palabra_horizontal(char sopa[N][M], char pal[M+1], int fil, int col)
{
    int i, resul=1, resul2=2;

    char pal2[M+1]="", pal3[M+1]="";

    if (M-col<longitud_pal(pal))
       return 0;

    for(i=0; pal[i]!='%pre%'; i++)
        pal2[i]=sopa[fil][col+i];

    for(i=0; pal[i]!='%pre%'; i++)
        pal3[i]=pal2[longitud_pal(pal2)-i-1];


    if(cad_iguales(pal, pal2))
        resul=1;
    else if(cad_iguales(pal, pal3))
        resul=2;
    else resul = 0;

    return resul;
}