#include <iostream.

h>
#include <fstream.h>
#include <stdlib.h>
#include<time.h> //Para el aleatorio bastante real
#define cantidad 100
using namespace std;
//declaraciones de variables globales.
int lineas_cant=0;
int i=0;
//Prototipo de funciones.
//examinar la base de datos.
int examinar_archivo(char * nombre);
//cargar las palabras
int cargar_palabras(char base[256][cantidad], char * nombre);
//Mostramos las palabras cargadas
void mostrar(char base[256][cantidad]);
//Para mostrar una sola palabra
void mostrar_palabra_vertical(char base[256][cantidad], int palabra, intaleatori
os[cantidad], int espacios);
//Para mostrar las palabras horizontales.
void mostrar_palabras_horizontales(char base[256][cantidad], int palabra);
//Para extraer el aleatorio sin repeticiones
void aleatorios_sin_repetir(int aleatorios[cantidad], int incremento);
//Para salir del programa
int salir();
//Procedimiento principal
int main ()
{
int aleatorios[cantidad];
lineas_cant = examinar_archivo("entrada.txt");
//Creamos el char con tantas lineas
char base[256][100];
//cargamos las palabras
cargar_palabras(base, "entrada.txt");
//Las mostramos
mostrar(base);
//Llamamos a la primer palabra
aleatorios_sin_repetir(aleatorios, i);
//Mostramos esa palabra
mostrar_palabra_vertical(base, aleatorios[i], aleatorios, 20);
cout << endl << "La palabra vertical es: " << endl;
for (int x = 0; base[x][aleatorios[0]] != '\0'; x++)
{
cout << base[x][aleatorios[0]];
}
//Aqu salimos.
salir();
}
/*
Funcin que evita que se repita una misma palabra
---------------------------*/
void aleatorios_sin_repetir(int aleatorios[cantidad], int incremento)
{
int mayor= lineas_cant-1;

int menor= 0;
//Para obtener el nmero aleatorio.
int numero;
srand(time(0));
//genera semilbool vertical=false, int espacios=20la
a partir de la hora del sistema
numero = rand () % (mayor-menor+1) + menor;
de_nuevo:
//Generamos el aleatorio
numero = rand () % (mayor-menor+1) + menor;
//si es el primer elemento lo asignamos directamente
if (incremento==0)
{
aleatorios[incremento]= numero;
}
//Para los restantes
else
{
//Recorremos el array de enteros aleatorios
for(int x=0; x < cantidad; x++)
{
//Si hallamos que el nmero ya se encuentra cargado
if(aleatorios[x]==numero)
{
//Pedimos otro aleatorio
goto de_nuevo;
//Rompemos este bucle secundario.
break;
}
}
//si llegamos hasta aqu lo asignamos
aleatorios[incremento]= numero;
}
}
/*
examinar la base de datos.
---------------------------*/
int examinar_archivo(char * nombre)
{
//Variable para cada linea que se lee
char buffer[256];
//El archivo esta en el mismo directorio del proyecto
ifstream examplefile (nombre);
//Si no se encuentra el archivo
if (! examplefile.is_open())
{
//informamos que no fu hallado
cout << "Error en la apertura del archivo";
//Salimos.
exit (1);
}
//De lo contrario mientras no se encuentre el final del mismo
while (! examplefile.eof() )
{
//Leemos cada linea
examplefile.getline (buffer,256);
//y contamos cuantas lineas tiene
lineas_cant++;

}
//cerramos el archivo
examplefile.close();
return lineas_cant;
}
/*
Funcin para poner las palabras del archivo de texto
en una Matriz
---------------------------*/
int cargar_palabras(char base[256][100], char * nombre)
{
//Variable para cada linea que se lee
char buffer[256];
//El archivo esta en el mismo directorio del proyecto
ifstream examplefile (nombre);
//Si no se encuentra el archivo
if (! examplefile.is_open())
{
//informamos que no fu hallado
cout << "Error en la apertura del archivo";
//Salimos.
exit (1);
}
int i = 0;
int x = 0;
while (! examplefile.eof() )
{
//Asignamos cada linea a cada elemento del array
examplefile.getline (buffer,256);
//Enviamos la informacin a la matriz
for (x = 0; buffer[x] != '\0'; x++)
{
base[x][i]= buffer[x];
}
base[x][i]='\0';
//Aumentamos el contador para el siguiente elemento del array char
i++;
}
//cerramos el archivo
examplefile.close();
}
/*
Funcin para mostrar las palabras
---------------------------*/
void mostrar(char base[256][100])
{
//Mostramos la matriz char, es decir cada linea del archivo.
int i=0;
int x=0;
for(i=0; i<lineas_cant; i++)
{
for (x = 0; base[x][i] != '\0'; x++)
{
cout << base[x][i];
}
cout << endl;

}
cout << "-------------------" << endl;
//Pausamos
getchar();
}
/*
Funcin para mostrar una palabra
---------------------------*/
void mostrar_palabra_vertical(char base[256][cantidad], int palabra, intaleatori
os[cantidad], int espacios=20)
{
int x;
int y;
int z;
int lugar=0;
bool halla_letra=false;
for (y = 0; y< espacios+15; y++)
{
cout << " ";
}
cout << "CRUCIGRAMA!"<<endl;
for (y = 0; y< espacios+15; y++)
{
cout << " ";
}
cout << "-----------"<<endl;
//Recorremos la palabra vertical
for (x = 0; base[x][palabra] != '\0'; x++)
{
//Creamos espacios para poder armar el crucigrama
for (y = 0; y< espacios; y++)
{
cout << " ";
}
//Llamamos a la primer palabra
i++;
de_nuevo:
//Buscamos un numero aleatorio que no este repetido
aleatorios_sin_repetir(aleatorios, i);
//Para hallar la letra de la palabra vertical en la
//palabra horizontal.
halla_letra=false;
//Recorremos la palabra aleatoria no repetida
for (z = 0; base[z][aleatorios[i]] != '\0'; z++)
{
//Si la letra actual vertical, se encuentra
//dentro de alguna de las letras de la palabra
//vertical
if(base[x][palabra]==base[z][aleatorios[i]])
{
//Capturamos su ubicacin numrica
lugar=z;
//Damos por hecho que fu hallada.
halla_letra=true;
//Salimos del for
break;
}
}

//Si no fu hallada reiniciamos el ciclo en

//busca de una nueva palabra
if (halla_letra==false)
{
goto de_nuevo;
}
//Si llegamos hasta aqu mostramos esa palabra
//Iniciando desde la cantidad de espacios, menos el
//lugar hallado, de esta manera se podr leer la palabra vertical
for (y = 0; y< espacios-lugar; y++)
{
cout << " ";
}
//Imprimimos la palabra horizontal.
mostrar_palabras_horizontales(base, aleatorios[i]);
}
cout << endl;
}
/*
Funcin para mostrar una palabra
---------------------------*/
void mostrar_palabras_horizontales(char base[256][cantidad], int palabra)
{
int x;
int y;
for (x = 0; base[x][palabra] != '\0'; x++)
{
cout << base[x][palabra];
}
cout << endl;
}
/*
Funcin para salir del programa
---------------------------*/
int salir()
{
//Pausamos
getchar();
//Limpiamos la pantalla
system("cls");
//fin.
system("pause");
return 0;
}

#include <iostream>
using namespace std;
int main ()
{
const int max = 10;
char A[max][max] = {'A',
'A',
'B',
'P',
'S',
'E',
'B',
'F',
'A',
'N',

'S',
'B',
'D',
'B',
'D',
'I',
'O',
'S',
'R',
'E',

'B',
'C',
'I',
'C',
'C',
'C',
'A',
'B',
'I',
'X',

'E',
'D',
'O',
'D',
'D',
'S',
'L',
'B',
'A',
'I',

'D',
'E',
'S',
'E',
'E',
'U',
'O',
'A',
'N',
'S',

'A',
'F',
'F',
'F',
'F',
'S',
'B',
'I',
'A',
'T',

'O',
'H',
'G',
'G',
'G',
'A',
'B',
'A',
'R',
'E',

'H',
'I',
'H',
'H',
'H',
'N',
'B',
'R',
'I',
'S',

char B[max];
char punto = '.';
int long_palabra = 0;
int dim_palabra;
int horizontal = 0;
int vertical = 0;
int inicio=0;
int contador = 0;
// muestra la sopa de letras, solo para verificar.
for (int i=0; i<max; i++)
{
for (int j=0; j<max; j++)
{
cout << A[j] << " ";
}
cout << endl;
}
cout << endl;
// ingreso los valores de B, y termina cuando sea mayor a 10,
// o cuando se ingresa un punto.
cout << "Ingrese B: " << endl;
for(int i=0; i<max; i++)
{
cin>>B;
long_palabra++;
if(B==punto)

'I',
'J',
'I',
'I',
'I',
'A',
'B',
'B',
'A',
'O',

'J',
'O',
'J',
'J',
'J',
'J',
'B',
'B',
'N',
'O'};

break;
if(i==9)
{
B[i+1]=punto;
break;
}
}
// crea nuevo vector con la palabra, sin el punto.
dim_palabra=long_palabra-1;
char P[dim_palabra];
for(int i=0; i<dim_palabra; i++)
P=B;
// muestra palabra escrita, solo para verificar.
for (int k=0; k<dim_palabra; k++)
cout << P[k];
// busca horizontal
int pos = 0;
for(int k=0; k<max; k++)
{
for (int n=0; n<max; n++)
{
if (A[k][n] == P[pos])
{
if (pos == 0)
{
inicio = n;
horizontal++;
pos++;
}
else if (n = inicio+1)
{
horizontal++;
pos++;
}
else
pos = 0;
}
if (horizontal == dim_palabra)
{
contador++;
}
}
}
cout << endl << endl << horizontal << endl << endl;
if (horizontal == dim_palabra)
{
cout << endl << 1;
}
else
{
cout << endl << 0;
}
cin.get();
cin.get();

return 0;
}