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

const int maxC = 3;
const int maxCP = 100;

void cargarMatriz(int matriz[][maxC],int dimF, int dimC);
void mostrarMatriz(int matriz[][maxC],int dimF, int dimC);
void cargarMatrizAleatoria(int matriz[][maxC],int dimF, int dimC);
int sumaMatriz(int matriz[][maxC],int dimF, int dimC);
float calcularPromedio(int suma, int cantidad);
int cantidad(int dimF, int dimC);
int determinarElemento(int matriz[][maxC],int dimF, int dimC, int buscado);
int cargarMatrizPalabras(char sopaDeLetras[][maxCP],int dimF);
void mostrarSopaDeLetras(char sopaDeLetras[][maxCP],int dimF);
int buscaPalabra(char sopaDeLetras[][maxCP],int dimF, char palabraBuscada[]);

int main()
{
    int matriz[3][maxC];
    int otraMatriz[3][maxC];

/*
    cargarMatriz(matriz,3,maxC);
    system("cls");
    mostrarMatriz(matriz,3,maxC);
    system("pause");
    */

    //cargarMatrizAleatoria(otraMatriz,3,maxC);
    //system("cls");
    //mostrarMatriz(otraMatriz,3,maxC);

    //int suma = sumaMatriz(matriz,3,maxC);

    //printf("la suma es %d\n",suma);

   // float promedio = calcularPromedio(suma, cantidad(3,maxC));

   // printf("el promedio es %f\n",promedio);

   // int encontrado = determinarElemento(matriz,3,maxC,9);

  //  if (encontrado == 1) printf("esta!\n"); else printf("no esta!\n");

    char matrizChar[3][maxCP];
    cargarMatrizPalabras(matrizChar,3);
    mostrarSopaDeLetras(matrizChar,3);
    char palabra[] = "gonzalo";
    int encontrado = buscaPalabra(matrizChar,3,palabra);
    if (encontrado == 1)
        printf("la palabra %s esta!\n",palabra);
    else
        printf("la palabra %s no esta!\n",palabra);

    return 0;
}

/*
Hacer una función que reciba como parámetro una matriz de
números enteros y permita que el usuario ingrese valores
al mismo por teclado. La función debe cargar la matriz por completo.
*/

void cargarMatriz(int matriz[][maxC],int dimF, int dimC)
{
    int fila = 0;
    int columna = 0;
    for (fila = 0; fila<dimF; fila++)
    {
        for (columna = 0; columna<dimC; columna++)
        {
            printf("ingrese un valor\n");
            scanf("%d",&matriz[fila][columna]);
        }
    }
}
/*
Hacer una función que reciba como parámetro una matriz de números enteros
y la muestre por pantalla (en formato matricial).
*/

void mostrarMatriz(int matriz[][maxC],int dimF, int dimC)
{
    int fila = 0;
    int columna = 0;
    for (fila = 0; fila<dimF; fila++)
    {
        for (columna = 0; columna<dimC; columna++)
        {
            printf("%d | ",matriz[fila][columna]);
        }
        printf("\n");
    }
}

/*
Hacer una función que reciba como parámetro
una matriz de números enteros y que cargue
la misma con números aleatorios (sin intervención del usuario).
La función debe cargar la matriz por completo.
*/
void cargarMatrizAleatoria(int matriz[][maxC],int dimF, int dimC)
{
    int fila = 0;
    int columna = 0;

    srand(time(NULL));//cambia la semilla por el tiempo actual

    for (fila = 0; fila<dimF; fila++)
    {
        for (columna = 0; columna<dimC; columna++)
        {
            matriz[fila][columna] = rand()%101;
        }
    }
}
/*
Hacer una función tipo int que sume el contenido
total de una matriz de números enteros.
*/

int sumaMatriz(int matriz[][maxC],int dimF, int dimC)
{
    int fila = 0;
    int columna = 0;
    int suma = 0;

    for (fila = 0; fila<dimF; fila++)
    {
        for (columna = 0; columna<dimC; columna++)
        {
            suma = suma + matriz[fila][columna];
        }
    }
    return suma;
}

/*
Hacer una función tipo float que calcule
el promedio de una matriz de números enteros.
*/

int cantidad(int dimF, int dimC)
{
    return dimC * dimF;
}

float calcularPromedio(int suma, int cantidad)
{
    float promedio = (float) suma / (float) cantidad;
    return promedio;
}

/*
Hacer una función que determine
si un elemento se encuentra dentro de una matriz de números enteros.
La función recibe la matriz y el dato a buscar.
*/
int determinarElemento(int matriz[][maxC],int dimF, int dimC, int buscado)
{
    int encontrado = 0;


    int fila = 0;
    int columna = 0;



    while ((encontrado==0)&&(fila<dimF))
    {
        columna = 0;
        while ((encontrado==0)&&(columna<dimC))
        {
                if (matriz[fila][columna] == buscado)
                {
                    encontrado = 1;
                    printf("encontrado!\n");
                }
                else
                {
                    printf("no encontrado!\n");
                }

                columna++;
        }
        fila++;
    }

    return encontrado;
}

/*
Hacer una función que cargue un arreglo de palabras (strings).
La función debe retornar cuantas palabras se cargaron.
*/

int cargarMatrizPalabras(char sopaDeLetras[][maxCP],int dimF)
{
  int cantidadPalabras = 0;

  char mander = 's';

  while ((mander == 's') && (cantidadPalabras<dimF))
  {
      printf("ingrese su palabra\n");
       fflush(stdin);
      gets(&sopaDeLetras[cantidadPalabras]);

      cantidadPalabras++;

      printf("desea seguir? \n");
      fflush(stdin);
      scanf("%c",&mander);
  }

  return cantidadPalabras;
}

/*
8.mostrar la matriz
*/
void mostrarSopaDeLetras(char sopaDeLetras[][maxCP],int dimF)
{
    int fila = 0;
    for (fila = 0; fila<dimF;fila++)
    {
        printf("%s\n",sopaDeLetras[fila]);
    }
}
/*
Hacer una función que determine si una palabra se
encuentra dentro de un arreglo de palabras.
La función recibe el arreglo,
la cantidad de palabras que contiene y la palabra a buscar.
*/

int buscaPalabra(char sopaDeLetras[][maxCP],int dimF, char palabraBuscada[])
{
    int fila = 0;
    int encontrado = 0;
    int comparacion = 0;

    while ((fila<dimF) && (encontrado==0))
    {
        comparacion = strcmp(palabraBuscada,sopaDeLetras[fila]);
        //if (sopaDeLetras[fila] == palabraBuscada) NO SE PUEDE
        if (comparacion == 0) //son iguales
        {
            encontrado = 1;
        }
        fila++;
    }

    return encontrado;
}