Mensajes

Comprueba los datos cuando te los introduzca el usuario, después es más lioso:

- Si día es < 1 devuelves un error
- Si mes es < 1 devuelves un error
- Si anyo es < 0 devuelves un error
- Si mes > 12 devuelves un error
- Si dia > dias_del_mes devuelves un error (febrero tendrá 29 días).
- Si anyo != bisiesto, es febrero y es el día 29 devuelves un error-

Esta línea:

Código (cpp) [Seleccionar] Expandir

printf("%d/%d/%d", f.dia, f.mes, f.año);

Cámbiala por:

Código (cpp) [Seleccionar] Expandir

printf("%02d/%02d/%04d", f.dia, f.mes, f.año);

[UNA SOLA VEZ]

Código (cpp) [Seleccionar] Expandir

int rand4 (){
srand(time(NULL));
int n = (0 + rand() % 4);
return n;
}
El srand debe usarse UNA SOLA VEZ preferentemente al principio. De lo contrario obtendrás siempre los mismos números (ya que no ha pasado el suficiente tiempo como para que cambie la semilla).

Como diga que no anda os grabo un video jajaj
Otra cosa que tengo problemas es con la declaracion de las tablas.
No se por que demonios tengo que poner un numero mayor que lo que voy usar.

El problema es el uso de comillas, si pones comillas el compilador te añade automáticamente un caracter nulo al final. Para que no te lo añadiera tendrías que ponerlos letra a letra con las comillas simples ' '.

Aumenta en uno el tamaño y listo. Eso es lo que he hecho en mi código.

Tampoco es a colores como lo de leo y el tuyo.

Los colores los he copiado totalmente del código de Leo, es un artista.

Y por último, me falta añadir una función que te busca una ruta aleatoria (sin repetir casillas):

Código (c) [Seleccionar] Expandir

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

#define INIX 1
#define INIY 1
#define FINX 22
#define FINY 25
#define MAX_X 24
#define MAX_Y 28

void mostrar(char a[][MAX_Y],char *msg);
void color (int n);

typedef struct cord
{
   int x,y;
} Cord;

typedef struct nodo
{
   int Distancia;
   Cord Posicion;
   char Calculado;
   struct nodo* anterior;
  // struct nodo* siguiente;
} Nodo;

char buscarSolucion(char mapa[][MAX_Y],Cord Ini,Cord Fin);
char buscarSolucionAleatoria(char mapa[][MAX_Y],Cord Ini,Cord Fin);
void MarcarNodo(Nodo* Actual,Nodo* Otro);

int main ()
{

   char a[MAX_X][MAX_Y]=
   {
       "000000000000000000000000000",
       "012222222222222222222222220",
       "022020200020002000000000020",
       "022202022020202000000000020",
       "020000000020202000000000020",
       "020222220020220200022222220",
       "022000000000000200020000020",
       "022222222222200200020000020",
       "022200000000200222222222000",
       "022222222200200000020002020",
       "022200000020222222222222220",
       "022222222200200000000000020",
       "020000000000222222222222220",
       "022000022200200000000000020",
       "020000000000200222222222220",
       "022222222222222200000000020",
       "020000000000000222222202020",
       "020000000000000200000202020",
       "022222222222222200000202020",
       "000002000000000200002222220",
       "020222222222222222222200000",
       "020000000000000000000222220",
       "022222222222222222222220010",
       "000000000000000000000000000"
   };
   mostrar(a,"LABERINTO");
  srand(time(0));
   Cord Inicio;
   Inicio.x = INIX;
   Inicio.y = INIY;

   Cord Final;
   Final.x = FINX;
   Final.y = FINY;

   buscarSolucion(a,Inicio,Final);

  while(1) buscarSolucionAleatoria(a,Inicio,Final);

   return 0;
}

void mostrar(char a[][MAX_Y],char *msg)
{
   system ("cls");
   int i,j;
   for( i=0; i<MAX_X; i++)
   {
       for( j=0; j<MAX_Y-1; j++)
       {
           if ((i==FINX && j==FINY) ||(i==INIX && j==INIY))
               color(215);
           else if (a[i][j]=='X')
               color(125);
           else if (a[i][j]=='0')
               color(175);
           else
               color(7);
           printf("%c ",a[i][j]);
           fflush(stdout);
       }
       putchar('\n');
   }
   color(7);
   printf ("\n\t\t%s\n\n",msg);
   system ("pause");
}

void color (int n)
{
   SetConsoleTextAttribute(GetStdHandle (STD_OUTPUT_HANDLE), n );
}

char buscarSolucionAleatoria(char Mapa[][MAX_Y],Cord Ini,Cord Fin)
{
       char mapa[MAX_X][MAX_Y];
   if (Ini.x == Fin.x && Ini.y == Fin.y)
   {
       return 1;
   }
   Cord Actual;
   Actual.x = Ini.x;
   Actual.y = Ini.y;

   Nodo* Totales[MAX_X][MAX_Y];
   int i = 0;
   int j = 0;

   for (; i < MAX_X; i++)
   {
       for (j = 0; j < MAX_Y; j++)
       {
           mapa[i][j] = Mapa[i][j];
           if (mapa[i][j] != '0')
           {
               Totales[i][j] = (Nodo*) malloc(sizeof(Nodo));
               Totales[i][j]->anterior = 0;
               Totales[i][j]->Calculado = 0;
               Totales[i][j]->Distancia = -1;
               Totales[i][j]->Posicion.x = i;
               Totales[i][j]->Posicion.y = j;
           }
           else Totales[i][j] = 0;
       }
   }

   Cord Min;

   int Posibilidades = 0;
   Nodo* Aux[4];

   while ((Actual.x != Fin.x || Actual.y != Fin.y))
   {

       // Izquierda

       Posibilidades = 0;

       if (Totales[Actual.x-1][Actual.y] && Totales[Actual.x-1][Actual.y]->Calculado == 0)
       {
           Aux[0] = Totales[Actual.x-1][Actual.y];
           Posibilidades++;
       }

       // Derecha

       if (Totales[Actual.x+1][Actual.y] && Totales[Actual.x+1][Actual.y]->Calculado == 0)
       {
           Aux[Posibilidades] = Totales[Actual.x+1][Actual.y];
           Posibilidades++;
       }

       // Abajo

       if (Totales[Actual.x][Actual.y-1] && Totales[Actual.x][Actual.y-1]->Calculado == 0)
       {
           Aux[Posibilidades] = Totales[Actual.x][Actual.y-1];
           Posibilidades++;
       }

       // Arriba

       if (Totales[Actual.x][Actual.y+1] && Totales[Actual.x][Actual.y+1]->Calculado == 0)
       {
          Aux[Posibilidades] = Totales[Actual.x][Actual.y+1];
          Posibilidades++;
       }

      Totales[Actual.x][Actual.y]->Calculado = 1; //Marcado!

       if (Posibilidades == 0)
       {
           if (!Totales[Actual.x][Actual.y]->anterior) return 0;

           int aux_x = Actual.x;
           Actual.x = Totales[Actual.x][Actual.y]->anterior->Posicion.x;
           Actual.y = Totales[aux_x][Actual.y]->anterior->Posicion.y;
       }
       else if (Posibilidades == 1)
       {
               char mapa[MAX_X][MAX_Y];Aux[0]->anterior = Totales[Actual.x][Actual.y];
           Actual.x = Aux[0]->Posicion.x;
           Actual.y = Aux[0]->Posicion.y;
       }
       else
       {
           int n = rand()%Posibilidades;
           Aux[n]->anterior = Totales[Actual.x][Actual.y];
           Actual.x = Aux[n]->Posicion.x;
           Actual.y = Aux[n]->Posicion.y;
       }
   }
   Nodo* Cosa = Totales[Actual.x][Actual.y];

   while (Cosa)
   {
       Actual.x = Cosa->Posicion.x;
       Actual.y = Cosa->Posicion.y;
       mapa[Actual.x][Actual.y] = 'X';
       Cosa = Cosa->anterior;
   }
//&mostrar(mapa,"Ruta aleatoria");
   // borrar

   for (i = 0; i < 24; i++)
   {
       for (j = 0; j < 28; j++)
       {
           free(Totales[i][j]);
       }
   }

   mostrar(mapa,"Ruta aleatoria");

   return 1;
}

char buscarSolucion(char Mapa[][MAX_Y],Cord Ini,Cord Fin)
{
   char mapa[MAX_X][MAX_Y];
   if (Ini.x == Fin.x && Ini.y == Fin.y)
   {
       return 1;
   }
   Cord Actual;
   Actual.x = Ini.x;
   Actual.y = Ini.y;

   Nodo* Totales[MAX_X][MAX_Y];

   int Nodos = 0;
   int i = 0;
   int j = 0;

   for (; i < MAX_X; i++)
   {
       for (j = 0; j < MAX_Y; j++)
       {
           mapa[i][j] = Mapa[i][j];
           if (mapa[i][j] != '0')
           {
               Totales[i][j] = (Nodo*) malloc(sizeof(Nodo));
               Totales[i][j]->anterior = 0;
               Totales[i][j]->Calculado = 0;
               Totales[i][j]->Distancia = -1;
               Totales[i][j]->Posicion.x = i;
               Totales[i][j]->Posicion.y = j;
               Nodos++;
           }
           else Totales[i][j] = 0;
       }
   }

   Totales[Ini.x][Ini.y]->Distancia = 0;

   Cord Min;

  //mapa[Actual.x][Actual.y] = 'X';

   while ((Actual.x != Fin.x || Actual.y != Fin.y) && Nodos != 0)
   {
       // Izquierda

       if (Totales[Actual.x-1][Actual.y] && Totales[Actual.x-1][Actual.y]->Calculado == 0)
       {
           MarcarNodo(Totales[Actual.x][Actual.y],Totales[Actual.x-1][Actual.y]);
       }

       // Derecha

       if (Totales[Actual.x+1][Actual.y] && Totales[Actual.x+1][Actual.y]->Calculado == 0)
       {
           MarcarNodo(Totales[Actual.x][Actual.y],Totales[Actual.x+1][Actual.y]);
       }

       // Abajo

       if (Totales[Actual.x][Actual.y-1] && Totales[Actual.x][Actual.y-1]->Calculado == 0)
       {
           MarcarNodo(Totales[Actual.x][Actual.y],Totales[Actual.x][Actual.y-1]);
       }

       // Arriba

       if (Totales[Actual.x][Actual.y+1] && Totales[Actual.x][Actual.y+1]->Calculado == 0)
       {
          MarcarNodo(Totales[Actual.x][Actual.y],Totales[Actual.x][Actual.y+1]);
       }

       Totales[Actual.x][Actual.y]->Calculado = 1; //Marcado!

       // Buscando un valor de referencia al minimo

       for (i = 0; i < MAX_X; i++)
       {
           for (j = 0; j < MAX_Y; j++)
           {
               if (Totales[i][j] && Totales[i][j]->Calculado == 0 && Totales[i][j]->Distancia != -1)
               {
                   Min.x = i;
                   Min.y = j;
                   i = 25;
                   j = 29;
               }
           }
       }

       // Buscando la distancia minima

       for (; i < MAX_X; i++)
       {
           for (j = 0; j < MAX_Y; j++)
           {
               if (Totales[i][j] && Totales[i][j]->Distancia < Totales[Min.x][Min.y]->Distancia
                   && Totales[i][j]->Distancia != -1 && Totales[i][j]->Calculado == 0)
               {
                   Min.x = i;
                   Min.y = j;
               }
           }
       }
       Actual.x = Min.x;
       Actual.y = Min.y;
       Nodos--;
   }

   Nodo* Cosa = Totales[Actual.x][Actual.y];

   while (Cosa)
   {
       Actual.x = Cosa->Posicion.x;
       Actual.y = Cosa->Posicion.y;
       mapa[Actual.x][Actual.y] = 'X';
       Cosa = Cosa->anterior;
   }

   // borrar

   for (i = 0; i < 24; i++)
   {
       for (j = 0; j < 28; j++)
       {
           free(Totales[i][j]);
       }
   }

   mostrar(mapa,"Ruta mas corta");

   return (Nodos != 0);
}

void MarcarNodo(Nodo* Actual,Nodo* Otro)
{
   if (Otro->Distancia == -1)
   {
       Otro->Distancia = Actual->Distancia+1;
       Otro->anterior = Actual;
   }
   else if (Actual->Distancia+1 < Otro->Distancia)
   {
       Otro->Distancia = Actual->Distancia+1;
       Otro->anterior = Actual;
   }
}

El código está chapurreado en pocos tiempo y no es ni bonito ni elegante. Pero funciona perfecto que es lo que importa.

Las dos funciones hacen cosas parecidas:

- Modelan el laberinto en un grafo (sin aristas, puesto que sabemos que todos los nodos tienen siempre 4 conexiones (izquierda,derecha,arriba  y abajo) ).
- Realizan una adaptación de algún algoritmo de grafos. Para el de la ruta más corta es Dijkstra:
Dikstra]http://es.wikipedia.org/wiki/Algoritmo_de_Dijkstra]Dikstra

Y para el de la ruta aleatoria uso una modificación del DFS (Depth First Search). La modificación esque elige las ramas aleatoriamente:
http://es.wikipedia.org/wiki/B%C3%BAsqueda_en_profundidad

El algoritmo finaliza cuando llegan al vértice final, una vez allí "van hacia atrás" pintando el camino hasta el inicio.

¿Lenguaje?

En C no se pueden inicializar los miembros de estructura en la declaración, tienes que inicializarlas cuando la crees.

En C++ se pueden inicializar desde los constructores, o directamente en la declaración si la variable es static.

En C++11 puedes inicializar todas las variables en la declaración.

Añado un código que te resuelve el laberinto buscando la ruta más corta:

Código (cpp) [Seleccionar] Expandir

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

#define INIX 1
#define INIY 1
#define FINX 22
#define FINY 25
#define MAX_X 24
#define MAX_Y 28

void mostrar(char a[][MAX_Y],char *msg);
void color (int n);

typedef struct cord
{
   int x,y;
} Cord;

typedef struct nodo
{
   int Distancia;
   Cord Posicion;
   char Calculado;
   struct nodo* anterior;
} Nodo;

char buscarSolucion(char mapa[][MAX_Y],Cord Ini,Cord Fin);
void MarcarNodo(Nodo* Actual,Nodo* Otro);

int main ()
{

   char a[MAX_X][MAX_Y]=
   {
       "000000000000000000000000000",
       "012222222222222222222222220",
       "022020200020002000000000020",
       "022202022020202000000000020",
       "020000000020202000000000020",
       "020222220020220200022222220",
       "022000000000000200020000020",
       "022222222222200200020000020",
       "022200000000200222222222000",
       "022222222200200000020002020",
       "022200000020222222222222220",
       "022222222200200000000000020",
       "020000000000222222222222220",
       "022000022200200000000000020",
       "020000000000200222222222220",
       "022222222222222200000000020",
       "020000000000000222222202020",
       "020000000000000200000202020",
       "022222222222222200000202020",
       "000002000000000200002222220",
       "020222222222222222222200000",
       "020000000000000000000222220",
       "022222222222222222222220010",
       "000000000000000000000000000"
   };
   mostrar(a,"LABERINTO");

   Cord Inicio;
   Inicio.x = INIX;
   Inicio.y = INIY;

   Cord Final;
   Final.x = FINX;
   Final.y = FINY;

   buscarSolucion(a,Inicio,Final);

   return 0;
}

void mostrar(char a[][MAX_Y],char *msg)
{
   system ("cls");
   int i,j;
   for( i=0; i<MAX_X; i++)
   {
       for( j=0; j<MAX_Y-1; j++)
       {
           if ((i==FINX && j==FINY) ||(i==INIX && j==INIY))
               color(215);
           else if (a[i][j]=='X')
               color(125);
           else if (a[i][j]=='0')
               color(175);
           else
               color(7);
           printf("%c ",a[i][j]);
           fflush(stdout);
       }
       putchar('\n');
   }
   color(7);
   printf ("\n\t\t%s\n\n",msg);
   system ("pause");
}

void color (int n)
{
   SetConsoleTextAttribute(GetStdHandle (STD_OUTPUT_HANDLE), n );
}

char buscarSolucion(char mapa[][MAX_Y],Cord Ini,Cord Fin)
{
   if (Ini.x == Fin.x && Ini.y == Fin.y)
   {
       return 1;
   }
   Cord Actual;
   Actual.x = Ini.x;
   Actual.y = Ini.y;

   Nodo* Totales[MAX_X][MAX_Y];

   int Nodos = 0;
   int i = 0;
   int j = 0;

   for (; i < MAX_X; i++)
   {
       for (j = 0; j < MAX_Y; j++)
       {
           if (mapa[i][j] != '0')
           {
               Totales[i][j] = (Nodo*) malloc(sizeof(Nodo));
               Totales[i][j]->anterior = 0;
               Totales[i][j]->Calculado = 0;
               Totales[i][j]->Distancia = -1;
               Totales[i][j]->Posicion.x = i;
               Totales[i][j]->Posicion.y = j;
               Nodos++;
           }
           else Totales[i][j] = 0;
       }
   }

   Totales[Ini.x][Ini.y]->Distancia = 0;

   Cord Min;

  //mapa[Actual.x][Actual.y] = 'X';

   while ((Actual.x != Fin.x || Actual.y != Fin.y) && Nodos != 0)
   {
       // Izquierda

       if (Totales[Actual.x-1][Actual.y] && Totales[Actual.x-1][Actual.y]->Calculado == 0)
       {
           MarcarNodo(Totales[Actual.x][Actual.y],Totales[Actual.x-1][Actual.y]);
       }

       // Derecha

       if (Totales[Actual.x+1][Actual.y] && Totales[Actual.x+1][Actual.y]->Calculado == 0)
       {
           MarcarNodo(Totales[Actual.x][Actual.y],Totales[Actual.x+1][Actual.y]);
       }

       // Abajo

       if (Totales[Actual.x][Actual.y-1] && Totales[Actual.x][Actual.y-1]->Calculado == 0)
       {
           MarcarNodo(Totales[Actual.x][Actual.y],Totales[Actual.x][Actual.y-1]);
       }

       // Arriba

       if (Totales[Actual.x][Actual.y+1] && Totales[Actual.x][Actual.y+1]->Calculado == 0)
       {
          MarcarNodo(Totales[Actual.x][Actual.y],Totales[Actual.x][Actual.y+1]);
       }

       Totales[Actual.x][Actual.y]->Calculado = 1; //Marcado!
       
       // Buscando un valor de referencia al minimo

       for (i = 0; i < MAX_X; i++)
       {
           for (j = 0; j < MAX_Y; j++)
           {
               if (Totales[i][j] && Totales[i][j]->Calculado == 0 && Totales[i][j]->Distancia != -1)
               {
                   Min.x = i;
                   Min.y = j;
                   i = 25;
                   j = 29;
               }
           }
       }

       // Buscando la distancia minima

       for (; i < MAX_X; i++)
       {
           for (j = 0; j < MAX_Y; j++)
           {
               if (Totales[i][j] && Totales[i][j]->Distancia < Totales[Min.x][Min.y]->Distancia
                   && Totales[i][j]->Distancia != -1 && Totales[i][j]->Calculado == 0)
               {
                   Min.x = i;
                   Min.y = j;
               }
           }
       }
       Actual.x = Min.x;
       Actual.y = Min.y;
       Nodos--;
   }

   Nodo* Cosa = Totales[Actual.x][Actual.y];

   while (Cosa)
   {
       Actual.x = Cosa->Posicion.x;
       Actual.y = Cosa->Posicion.y;
       mapa[Actual.x][Actual.y] = 'X';
       Cosa = Cosa->anterior;
   }

   // borrar

   for (i = 0; i < 24; i++)
   {
       for (j = 0; j < 28; j++)
       {
           free(Totales[i][j]);
       }
   }

   mostrar(mapa,"Prueba");

   return (Nodos != 0);
}

void MarcarNodo(Nodo* Actual,Nodo* Otro)
{
   if (Otro->Distancia == -1)
   {
       Otro->Distancia = Actual->Distancia+1;
       Otro->anterior = Actual;
   }
   else if (Actual->Distancia+1 < Otro->Distancia)
   {
       Otro->Distancia = Actual->Distancia+1;
       Otro->anterior = Actual;
   }
}

No hay ninguna diferencia entre leer de teclado y un fichero. Podrías incluso cambiar el stdin (fichero del teclado) hacia un txt para que se lea directamente con las mismas funciones:

Código (cpp) [Seleccionar] Expandir

stdin = freopen("archivo.txt", "r", stdin);

Por cierto la indentación no es la adecuada. No es tabular todo el código, sino tabular los bloques. La idea esque puedas reconocer cual es cada bloque (entiendase por bloque un condicional, una función, un bucle...):

Código (cpp) [Seleccionar] Expandir

#include <stdio.h>

struct Palabras
{
  char letras[10]; //letras de cada palabra, maximo 10 letras
};
struct Palabras Tpalabras[6]; //vector con informacion de todas las palabras, maximo 6.

void main(void)
{
  int ch, i, j;

  puts("introduzca sus palabras a buscar separadas por espacios y un punto en la ultima para indicar que se han acabado: ");

  for(i=0;i<6;i++)
  {
      for(j=0;j<10;j++)
      {
          if(ch=getchar() != '.') break;
          else
          {
              if(ch=getchar()!= ' ')Tpalabras[i].letras[j]=getchar();
              else continue;
          }
      }
  }
}

Cada llave abierta son 4 espacios a la derecha más que tabular, y cada llave cerrada son 4 espacios menos para tabular.

Selecciona las líneas de código:



Pulsa TAB:



Indentado. Aunque si usas el Codeblocks la indentación te la mete automaticamente en cada salto de línea.

^^

Insisto SoyelRobert:

Código (cpp) [Seleccionar] Expandir

int main ()
{
char c;
FILE *fe;
FILE *fs;

fe= fopen("C:\entrada.txt", "r");
fs= fopen("C:\salida.txt", "a");

//...

}

Deja 4 espacios después de una llave, asi se pueden identificar bloques fácilmente:

Código (cpp) [Seleccionar] Expandir

int main ()
{
   char c;
   FILE *fe;
   FILE *fs;

   fe= fopen("C:\entrada.txt", "r");
   fs= fopen("C:\salida.txt", "a");

   //...
}

Eso en un editor de código es seleccionar las líneas y apretar TAB. O bien usar el plugin que indenta el código automaticamente (en el Codeblocks se llama "Source code formatter (AStyle)").

Estás prácticas son prácticamente obligadas para cualquier progamador, de hecho algunos lenguajes (como el python) no tienen llaves y se identifican los bloques con la indentación.

Mirate este post que hize sobre el formato BMP:
http://www.elotrolado.net/hilo_imagenes-bmp-destripandolas-a-fondo_1807836

Si coges el color de cada pixel de la pantalla podrías formar un BMP.