A mí tampoco me va leo. ¿No tendrás activado el fpermissive?
El error se debe a que has declarado una matriz de 27 elementos por columna, tu le has puesto 27 elementos +caracter nulo.
¿Dónde se mira lo del fpermissive?.
En todo caso la matriz sería de 24x28 para incluir el caracter nulo, aunque luego en la impresión se iría hasta<27, como está, teniendo en cuenta que empezamos a contar de cero.
Pero es muy raro. Tengo activado el modo -Wall y el -pedantic y no me "canta" nada, ni warnings.
Espero noticias.
Saluditos! ..... !!!!
REEDITO: No, no tengo activado el modo fpermissive.
Lo raro es que lo ejecuté tanto en Code::Blocks como en Dev-C++ y ninguno se "quejo".
Pero bueno, no deja de ser un error y ya lo he corregido en todos los post.
Gracias por la observación.
« Última modificación: 30 Diciembre 2013, 15:52 pm por leosansan »
¡waaa eso ya es tecnología punta! Tengo echo unos pinitos jaja, pero no es nada comparado a esto. XD Tampoco es a colores como lo de leo y el tuyo. Un par de ajustes y lo subo si prometéis no reír de mi. >< Ando algo desanimado pero estoy en ello. Saludos
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
Que dice jaja es un peazo de código jeje Para que no repitiera el camino, y digo camino sin salida fue hacer una especie de backup del trayecto XD Primero hice una for para contar todos los números 2 que hay. después hice un par de tablas con esa cantidad, una para x y una para y. luego un contador y y le fue grabando a cada vuelta el valor de la posición actual. Bien...eso solo se activa cuando el punto se encuentra con números 1, o sea ya explorado. Entonces en ese momento empieza una cuenta atrás del contador y voy imprimiendo lo que había guardado en backupx y backupy Funciona de perfectamente y es capaz de hacer el personaje volver por todo el camino. Para marcar ese camino lo relleno con ceros, o sea que se vuelve hasta la primera intercesión hasta encontrar un 2 nuevamente y lo rellena el camino sin salida con ceros para no meterse mas por ahí XDD
hay unos bugcitos jaja
Pero bueno, no soy tan bueno con los punteros jaja Pero hace el apaño.
Bueno lo pongo aquí: No se compara con el vuestro pero llego al final. tampoco le hice que se rompiera el bucle así que si me lo vaes a echar como fallo arreglad vosotros jajaja
Otra cosa, que me gusta ver la x andando por el mapa jaja Asi puedo analizar lo que va haciendo XD As veces se queda un rato parado en una intercesión, eso lo hace hasta que obtiene un numero aleatorio correcto. Podía mejorarlo pero bua lo dejo así que soy mu vaguito XD Como dije no es como el vuestro pero me sirve. Saludos a todos, me lo paso bomba con esos códigos
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. creo que es por los ceros, a lo mejor si sustituyo los 0 po X o otra cosa. Creo que es así por que creo que termina la tabla con char( 0 ) no? Si saben por que, pasa eso me gustaría saber si declaro char tabla[10] no le puedo meter de 0 a 9 por que me dice no sequela de fpermisive los webos. Me parece que en el caso de char la ultima letra es 0 no es ¿así? La cosa es que veo vuestro código funcionar y el mio pues no anda. es raro pero me esta pasando pffff
« Última modificación: 4 Enero 2014, 16:18 pm por vangodp »
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).
Citar
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.
En línea
Por favor, no me manden MP con dudas. Usen el foro, gracias.
¡¡¡Pedazo de código amchacon!!!!. Está visto que te lo has currado de lo lindo.
Antes que nada GRACIAS. Es un código muy pero que muy interesante, al menos para mí. Me recuerda que tengo que ponerme las pilas en el tema de estructuras, listas y muy especialmente en arboles, facilita mucho las cosas.
Como comprobarás por mi código final, yo me apaño, creo que bastante bien, con los arrays. Y es que el mundo de donde vengo se pierde en el tiempo. Era una época en que lo más que habían para estas cosas eran los arrays y, en todo caso, los famosos sprites. Eso sí, tenían capacidades gráficas y de sonido de forma nativa, nada de librerías externas ni cosas por el estilo. Sin duda era mucho más fácil programar un ping-pong o un break. La verdad que en ese sentido el C me decepciona ya que las librerías gráficas, al menos las que he ojeado, son todo un *oñazo y poco intuitivas. Pero en fin, es lo que hay.
Y vamos a lo que vamos, a comentar y realizar observaciones, que no críticas -no entra en mi ánimo ni mucho menos- sobre los códigos y métodos usados en vuestros códigos.
Repito querido amigo Mikel Angelo, son sólo observaciones, no quiero que te lo tomes o mal ni las veas como críticas.
Los colores los he copiado totalmente del código de Leo, es un artista.
No es para tanto. Además lo explique, creo que meridianamente clarito, en el tema de GAMA DE COLORES, tema que aconsejo a todo el que quiera darle un poco de vidilla a sus códigos.
La verdad es que el tema de grafos es, como diría, espeso, eso es. Lo tuve que dominar en profundidad en su momento, tanto por haberlo dado en la asignatura correspodiente de Álgebra como por las múltiples aplicaciones en otras asignaturas, como Regulación Automática, Administración de Empresas,Procesos químicos, Economía,etc.
Pero siempre me dejo un mal regusto, me parece primitivo en los tiempos que corren con el uso de los ordenadores. Así que me voy a poner a ello y voy a desarrollar mi propio sistema para determinar el camino más corto entre dos puntos, que se note que soy Ingeniero y que hacemos honor al nombre: ingeniar, innovar.
No es moco de pavo el problemita pero si pillo un par de días, la familia ocupa casi todo el tiempo, pero el problema tiene unas implicaciones la mar de interesantes, como la búsqueda del camino más corto entre dos puntos en un viaje en coche, o la mejor ruta para el reparto de mercancías entre dos puntos/ciudades, entre otros muchos casos.
Y respecto al uso del DFS (Depth First Search)
comentar que el problema que nos traemos entre manos, que no es baladí, es algo más complejo ya que implica que el árbol cierre y/o conecte buena parte de las subramas de las ramas principales y que el origen y fin sean los nodos extremos, es decir que se cierren las ramas por abajo en un punto final, amén de las comentadas interconexciones entre subramas. Vamos que es bastante más complejo que un simple árbol como el que muestra la figura y las modificaciones que abría que hacer al susodicho método DFS son de tal envergadura que yo me pondría, y me voy a poner, a desarrollar un nuevo método.
Lo de pintar el camino hacia atrás ni me molesto porque es como algo obvio.
................................................................. Funciona de perfectamente y es capaz de hacer el personaje volver por todo el camino. ......................................... hay unos bugcitos jaja .................................................................
A veces se queda un rato parado en una intercesión, eso lo hace hasta que obtiene un numero aleatorio correcto. Podía mejorarlo pero bua lo dejo así que soy mu vaguito XD ............................................................................. Como diga que no anda os grabo un video jajaj Otra cosa que tengo problemas es con la declaracion de las tablas. .............................................. La cosa es que veo vuestro código funcionar y el mio pues no anda. es raro pero me esta pasando pffff
Por vídeos que no quede esta vez.
* Por un lado debes dejar un espacio en blanco al lado de %c del printf que te dibuja el laberinto. Tal como lo tienes sale demasiado pegado en horizontal y no se ve bien.
* ¿Intentas provocar un ataque de epilepsia a los usuarios?. Es insufrible el que cada vez que camines por el laberinto se redibuje toda la matriz, eso trae como consecuencia un parpadeo incesante de la imagen que hace difícil seguir el movimiento de la casilla en cuestión. Observa si no:
SetConsoleTextAttribute(GetStdHandle (STD_OUTPUT_HANDLE), n );
}
** ¿Y como evitas el parpadeo?. Sencillo, dibujas una sola vez la matriz y ya no refrescas más la pantalla con el system("pause") cada vez que haces un movimiento. Lo que haces es aprovechar que la matriz está dibujada y sobre esa misma matriz mueves la casilla.
** ¿Y cómo diablos consigues que se mueva la casilla sin cambiar la matriz?. Sencillo, con una función de las API de Windows que permite situar el cursor en cualquier posición de la pantalla y escribir, e incluso sobrescribir, en un punto determinado. La función que realiza tal cometido es "goto", así como la función "color" es la encargada de dar color. Te pongo un vídeo de muestra, no te preocupes que todos duran menos de un minuto- y el código que te muestra cómo hacer lo que te comento:
Código
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
#define FIL 7
#define COL 8
void color (int n);
int gotoxy(int x, int y);
int main (){
int i=0,j=0,k=0,fil=1,col=1;
char a[7][8];
system("pause");
system("cls");
for(i=0;i<15;i++){
gotoxy (10+2*i,10);
printf("*");
}
Sleep (2000);
for(i=0;i<15;i++){
Sleep (250);
gotoxy (10+2*i,10);
printf("X");
}
puts("\n\n");
system("pause");
system("cls");
for(i=0;i<27;i++)
printf("* ");
putchar('\n');
for(i=0;i<27;i++){
Sleep(150);
gotoxy (2*i,0);
printf("X ");
}
for(i=0;i<27;i++){
Sleep(100);
gotoxy (2*i,4);
printf("X");
}
for(i=0;i<6;i++){
for(j=0;j<6;j++){
gotoxy (2*j+6,i+6);
printf("* ");
}
}
for(i=0;i<6;i++){
for(j=0;j<6;j++){
Sleep(250);
gotoxy (2*j+6,i+6);
printf("X");
}
}
putchar('\n');
system("pause");
system("cls");
for(i=0;i<7;i++){
a[i][7]='\0';
for(j=0;j<7;j++){
if(j>=i-1&& j<i+1&& j>0&& j<6&& i<6)
a[i][j]='X';
elseif(i==0|| j==0|| i==6|| j==6)
a[i][j]='*';
else
a[i][j]='0';
}
}
putchar('\n');
for(i=0;i<7;i++){
a[i][7]='\0';
for(j=0;j<7;j++){
if((i==j || j==i-1)&& i>0&& j<6&& j>0&& i<6)
a[i][j]='X';
elseif(i==0|| j==0|| i==6|| j==6)
a[i][j]='*';
else
a[i][j]='0';
}
}
gotoxy (0,10);
for(i=0;i<7;i++){
for(j=0;j<7;j++){
printf("%c ",a[i][j]);
}
putchar('\n');
}
system("pause");
/*for (i=0;i<7;i++){
a[i][7]='\0';
for (j=0;j<7;j++){
if (i==0 || j==0 || i==6 || j==6 )
a[i][j]='*';
else if (i>=j)
a[i][j]='X';
else
a[i][j]='0';
}
}*/
for(i=0;i<7;i++)
printf("%s\n",a[i]);
system("pause");
gotoxy (0,0);
for(i=0;i<7;i++){
for(j=0;j<7;j++){
printf("%c ",a[i][j]);
}
putchar('\n');
}
fil=1,col=1;
while(1){
Sleep(1000);
if(fil==FIL-2&& col==COL-3){
gotoxy (2*col,fil);
printf("%c ",'F');
break;
}
elseif(a[fil+1][col]=='X'&& fil<FIL){
color(215);
gotoxy (2*col,fil);
printf("%c ",'F');fil++;
}
elseif(a[fil][col+1]=='X'&& col<COL){
color(215);
gotoxy (2*(col),fil);
printf("%c ",'F');col++;
}
elseif(a[fil-1][col]=='X'&& fil>0){
color(215);
gotoxy (2*(col),fil);
printf("%c ",'F');fil--;
}
elseif(a[fil][col-1]=='X'&& col>0){
color(215);
gotoxy (2*col,fil);
printf(" %c ",'F');col--;
}
}
color(7);
gotoxy (0,30);
printf("Final!");
putchar('\n');
return0;
}
void color (int n)
{
SetConsoleTextAttribute(GetStdHandle (STD_OUTPUT_HANDLE), n );
Como ves es sencillo pero muy efectivo, Todo es jugar con las coordenadas de goto(x,y). Y al respecto te hago una observación, el ordenador usa como ejes coordenados el horizontal superior como eje OX y el vertical izquierdo como eje OY, de forma que el origen de coordenada está en el vértice superior izquierdo de la pantalla, como ya imagino sabrás. Eso provoca una pequeña distorsión y/o problema a la hora de escribir en pantalla con la mencionada función goto(x,y) y es que las coordenadas x,y se corresponden con los índices i,j o, como en tu caso, x,y. Observa que en la matriz normalmente al poner (i,j) la i es para las filas y la y para las columnas. Ahí es donde tienes que tener cuidado ya que las filas, osea la i, se corresponde en pantalla con la Y del goto(x,y), mientras la j se corresponde con la x.
* En cuanto a la declaración de las tablas mencionarte que tenías un problema al indicar la fila y columna final. por eso tenías que sobredimensionarlas. En los códigos que te paso ya he corregido ese problema.
* Efectivamente tienes un pequeño bug principal. Si te fijas en la imagen y vídeo siguientes quedan unos "1" sin "pintar":
Eso que a primera vista parece un problema nimio resulta que es un problema realmente vital. Se pone de manifiesto al aplicarle yo el que la pantalla no parpadee con el uso del goyo(x,y). Observa el vídeo:
y mira como se "pega" en la rama horizontal. No puede retroceder como sería lo normal y es por lo que te comenté, ese "1" no lo has cambiado al hacer el recorrido y la casilla que se mueve la detecta como errónea:
¿Y yo?.
La verdad es que poca cosa, aunque interesantes, es que con tanta fiestas y familia alrededor no he tenido tiempo pá ná.
Pero bueno, algo si que he adelantado.
La principal novedad que he introducido es el hecho de no trabajar ya con una matriz predefinida en el código, eso era como demasiado fácil. Ahora la matriz se genera de forma aleatoria.
Para hacer el código más rico, introduzco una variables, de nombres peso, c_peso y peso_i, que permiten jugar a poner más o menos 2=camino o 0=pared. Además aseguro que la matriz generada tenga al menos una solución, cosa que si la genero aleatoriamente de forma total no ocurriría la mayor parte de las veces. Y la salida que busco es "UNA", dejo para un posterior código, como ya comenté más arriba, el desarrollo de un método que me permita elegir el camino con menor coste.
Sí, digo bien, con menor coste ya que pueden haber varias soluciones que del principio al final recorran el mismo número de casillas pero con distinto coste. ¿Que qué es eso del coste?. Ni más ni menos que el número de cambios de dirección en el camino. Imaginaos que vais de una ciudad a otra, el camino óptimo será el que tenga menos "curvas", que en este caso se traduce por el menor número de cambios de dirección. No vale eso de abajo. derecha una y otra vez si puedes ir recto hacia abajo y luego directo a la derecha sin tomar curvas en medio.
Y un vídeo de un minutito que muestra el código en acción y después el código:
Autor
En línea
