Foro de elhacker.net

Programación => Programación C/C++ => Mensaje iniciado por: Albertocn en 8 Diciembre 2013, 17:52 pm



Título: Ayuda con programa urgente!
Publicado por: Albertocn en 8 Diciembre 2013, 17:52 pm
Hola qué tal, soy nuevo en el foro, espero me puedan ayudar con un problema que tengo.
Lo que pasa es que tengo que hacer un laberinto en c++, se tiene que ir recorriendo solo automáticamente hasta llegar al final, es de 25x25, pero tiene que recorrer cada punto del camino, los ceros representan el espacio vacío y los unos el posible camino, me he roto la cabeza pensando como hacerle pero no tengo idea cómo hacerle, por el momento ya tengo el laberinto(más o menos).
Espero me puedan ayudar, me urge demasiado.
Gracias y saludos



Título: Re: Ayuda con programa urgente!
Publicado por: Albertocn en 8 Diciembre 2013, 17:54 pm
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
main()
{
clrscr();
system("color 4F");
int arreglo[25][25]={0},x=0,y=0;
arreglo[1][0]=1;
arreglo[1][1]=1;
arreglo[1][2]=1;
arreglo[1][3]=1;
arreglo[1][4]=1;
arreglo[1][5]=1;
arreglo[2][5]=1;
arreglo[3][5]=1;
arreglo[6][7]=1;
arreglo[5][7]=1;
arreglo[4][5]=1;
arreglo[4][6]=1;
arreglo[4][7]=1;
arreglo[7][8]=1;
arreglo[7][7]=1;
arreglo[8][8]=1;
arreglo[8][9]=1;
arreglo[8][10]=1;
arreglo[8][11]=1;
arreglo[8][12]=1;
arreglo[8][13]=1;
arreglo[9][13]=1;
arreglo[10][13]=1;
arreglo[10][12]=1;
arreglo[10][11]=1;
arreglo[10][10]=1;
arreglo[10][9]=1;
arreglo[10][8]=1;
arreglo[10][7]=1;
arreglo[10][6]=1;
arreglo[10][5]=1;
arreglo[11][5]=1;
arreglo[12][5]=1;
arreglo[13][0]=1;
arreglo[13][1]=1;
arreglo[13][2]=1;
arreglo[13][3]=1;
arreglo[13][4]=1;
arreglo[13][5]=1;
arreglo[14][0]=1;
arreglo[15][0]=1;
arreglo[16][0]=1;
arreglo[16][1]=1;
arreglo[16][2]=1;
arreglo[16][3]=1;
arreglo[16][4]=1;
arreglo[16][5]=1;
arreglo[16][6]=1;
arreglo[16][7]=1;
arreglo[16][8]=1;
arreglo[16][9]=1;
arreglo[16][10]=1;
arreglo[16][11]=1;
arreglo[16][12]=1;
arreglo[16][13]=1;
arreglo[16][14]=1;
arreglo[16][15]=1;
arreglo[17][15]=1;
arreglo[18][15]=1;
arreglo[18][16]=1;
arreglo[18][17]=1;
arreglo[18][18]=1;
arreglo[18][19]=1;
arreglo[19][19]=1;
arreglo[20][19]=1;
arreglo[20][18]=1;
arreglo[20][17]=1;
arreglo[20][16]=1;
arreglo[21][16]=1;
arreglo[21][15]=1;
arreglo[21][14]=1;
arreglo[21][13]=1;
arreglo[21][12]=1;
arreglo[21][11]=1;
arreglo[21][10]=1;
arreglo[21][9]=1;
arreglo[22][9]=1;
arreglo[23][9]=1;
arreglo[24][9]=1;
arreglo[24][10]=1;
arreglo[24][11]=1;
arreglo[24][12]=1;
arreglo[24][13]=1;
arreglo[24][14]=1;
arreglo[24][15]=1;
arreglo[24][16]=1;
arreglo[24][17]=1;
arreglo[23][17]=1;
arreglo[23][18]=1;
arreglo[23][19]=1;
arreglo[23][20]=1;
arreglo[23][21]=1;
arreglo[23][22]=1;
arreglo[23][23]=1;
arreglo[23][24]=2;
for(x=0;x<25;x++)
{
for(y=0;y<25;y++)
{
printf("%d",arreglo
  • [y]);
}
printf("\n");
}
}
getch();
}


Título: Re: Ayuda con programa urgente!
Publicado por: leosansan en 8 Diciembre 2013, 19:54 pm
Antes que nada cuando postees código elige las etiquetas GeSHi y toma la C++ y en medio de las etiquetas Code que aparecen "pegas" tu código. Al no hacerlo de esta manera parte del código no sale correcta, especialmente las matrices.

Saluditos! ..... !!!!        (http://st.forocoches.com/foro/images/smilies/aaaaa.gif)


Título: Re: Ayuda con programa urgente!
Publicado por: Albertocn en 9 Diciembre 2013, 03:11 am
Gracias por el dato...a ver si ya sale mejor.
Código
  1. #include <stdio.h>
  2. #include <conio.h>
  3. #include <dos.h>
  4. main()
  5. {
  6. clrscr();
  7. int arreglo[25][25]={0},x=0,y=0;
  8. arreglo[1][0]=1;
  9. arreglo[1][1]=1;
  10. arreglo[1][2]=1;
  11. arreglo[1][3]=1;
  12. arreglo[1][4]=1;
  13. arreglo[1][5]=1;
  14. arreglo[2][5]=1;
  15. arreglo[3][5]=1;
  16. arreglo[6][7]=1;
  17. arreglo[5][7]=1;
  18. arreglo[4][5]=1;
  19. arreglo[4][6]=1;
  20. arreglo[4][7]=1;
  21. arreglo[7][8]=1;
  22. arreglo[7][7]=1;
  23. arreglo[8][8]=1;
  24. arreglo[8][9]=1;
  25. arreglo[8][10]=1;
  26. arreglo[8][11]=1;
  27. arreglo[8][12]=1;
  28. arreglo[8][13]=1;
  29. arreglo[9][13]=1;
  30. arreglo[10][13]=1;
  31. arreglo[10][12]=1;
  32. arreglo[10][11]=1;
  33. arreglo[10][10]=1;
  34. arreglo[10][9]=1;
  35. arreglo[10][8]=1;
  36. arreglo[10][7]=1;
  37. arreglo[10][6]=1;
  38. arreglo[10][5]=1;
  39. arreglo[11][5]=1;
  40. arreglo[12][5]=1;
  41. arreglo[13][0]=1;
  42. arreglo[13][1]=1;
  43. arreglo[13][2]=1;
  44. arreglo[13][3]=1;
  45. arreglo[13][4]=1;
  46. arreglo[13][5]=1;
  47. arreglo[14][0]=1;
  48. arreglo[15][0]=1;
  49. arreglo[16][0]=1;
  50. arreglo[16][1]=1;
  51. arreglo[16][2]=1;
  52. arreglo[16][3]=1;
  53. arreglo[16][4]=1;
  54. arreglo[16][5]=1;
  55. arreglo[16][6]=1;
  56. arreglo[16][7]=1;
  57. arreglo[16][8]=1;
  58. arreglo[16][9]=1;
  59. arreglo[16][10]=1;
  60. arreglo[16][11]=1;
  61. arreglo[16][12]=1;
  62. arreglo[16][13]=1;
  63. arreglo[16][14]=1;
  64. arreglo[16][15]=1;
  65. arreglo[17][15]=1;
  66. arreglo[18][15]=1;
  67. arreglo[18][16]=1;
  68. arreglo[18][17]=1;
  69. arreglo[18][18]=1;
  70. arreglo[18][19]=1;
  71. arreglo[19][19]=1;
  72. arreglo[20][19]=1;
  73. arreglo[20][18]=1;
  74. arreglo[20][17]=1;
  75. arreglo[20][16]=1;
  76. arreglo[21][16]=1;
  77. arreglo[21][15]=1;
  78. arreglo[21][14]=1;
  79. arreglo[21][13]=1;
  80. arreglo[21][12]=1;
  81. arreglo[21][11]=1;
  82. arreglo[21][10]=1;
  83. arreglo[21][9]=1;
  84. arreglo[22][9]=1;
  85. arreglo[23][9]=1;
  86. arreglo[24][9]=1;
  87. arreglo[24][10]=1;
  88. arreglo[24][11]=1;
  89. arreglo[24][12]=1;
  90. arreglo[24][13]=1;
  91. arreglo[24][14]=1;
  92. arreglo[24][15]=1;
  93. arreglo[24][16]=1;
  94. arreglo[24][17]=1;
  95. arreglo[23][17]=1;
  96. arreglo[23][18]=1;
  97. arreglo[23][19]=1;
  98. arreglo[23][20]=1;
  99. arreglo[23][21]=1;
  100. arreglo[23][22]=1;
  101. arreglo[23][23]=1;
  102. arreglo[23][24]=2;
  103. for(x=0;x<25;x++)
  104. {
  105. for(y=0;y<25;y++)
  106. {
  107. printf("%d",arreglo[x][y]);
  108. delay(10);
  109. }
  110. printf("\n");
  111. delay(12);
  112. }
  113. for(x=0;x<25;x++)
  114. {
  115. for(y=0;y<25;y++)
  116. {
  117. I
  118. }
  119. }
  120. getch();
  121. }


Título: Re: Ayuda con programa urgente!
Publicado por: vangodp en 9 Diciembre 2013, 04:29 am
Código
  1.  
  2. int MAXCOL = 10;
  3. int MAXFIL = 10;
  4.  
  5.  
  6. char mapa[MAXCOL][MAXFIL]={
  7. "XXXXXXXXXX",
  8. "X00P00000X",
  9. "XXXXXXXX0X",
  10. "X00000000X",
  11. "XXX0XXXXXX",
  12. "X0000X000X",
  13. "X0XX000X0X",
  14. "X0XX0XXX0X",
  15. "X0000XXX0F",//<-Aqui la 'F' de final XD
  16. "XXXXXXXXXX",
  17. };
  18.  
  19. // Dado lo de arriba sabemos que 0 esta por descubrir  
  20. // y lo que ya hemos caminado es 1, pero aun no caminamos nada.
  21. // Las X nunca deben cambiar ;) o romperíamos una pared XDD
  22. // La 'F' es de final si la queremos, en tu caso quieres recorrer el mapa completo pero
  23. //ya veremos como XD
  24. // Sabemos que el personaje aparece en un determinado punto del array mapa.
  25. // Ese punto es mapa [1][3]¿no? Desde este punto deberemos realizar nuestro calculo de recorrido.
  26. // Veamos como podemos hacer:
  27. // Antes que nada hay que tener claro como se va mover el personaje.
  28. // En mi caso se va mover de izquierda a derecha y al contrario de derecha a izquierda.
  29. // Y también lo va hacer hacia arriba y hacia abajo.
  30. // Eso en cálculos seria mas o menos así:
  31. // Si se mueve a la derecha aumenta, si se mueve a la izquierda disminuye ¿ok?
  32. // Entonces hacemos así:
  33. // Usaremos coordenadas X y coordenadas Y, muy usadas para hacer un videojuego :D
  34. // Como funciona?
  35.  
  36. // Declaramos 2 variables para representar la posición del tipo entero.
  37. // Le damos el valor inicial del mapa de arriba para que inicie donde queremos
  38. int y = 1; //
  39. int x = 3; //
  40.  
  41. // Eso hace que el personaje inicie en la P del mapa de arriba.
  42. mapa[y][x]
  43.  
  44. // ahora bien creo que lo vas captando ya la intención:D
  45. // Si aumentamos la coordenada x
  46. // La P pasaría de estar en la casilla 3 para estar en la 4 ¿no?Seria mas o menos así:
  47.  
  48. // MAXCOL 0 "XXXXXXXXXX",
  49. // MAXCOL 1 "X00P00000X",
  50. //           01234....9
  51. //           |||||_MAXFIL 4->Aquí se va poner la P si le sumamos +1:D
  52. //           ||||__MAXFIL 3->Aquí esta la P ahora
  53. //           |||___MAXFIL 2
  54. //           ||____MAXFIL 1
  55. //           |_____MAXFIL 0
  56.  
  57. //Una vez incrementada la x así se queda
  58. // MAXCOL 0 "XXXXXXXXXX",
  59. // MAXCOL 1 "X000P0000X",
  60. //           01234....9
  61. //           |||||_MAXFIL 4->Aquí se va poner la P si le sumamos +1:D
  62. //           ||||__MAXFIL 3->Aquí estaba la P Y nuestro personaje ya estuvo aquí, tenia que ser 1
  63. //           |||___MAXFIL 2
  64. //           ||____MAXFIL 1
  65. //           |_____MAXFIL 0
  66.  
  67. // Una vez desplazado el personaje la posición anterior debería quedar en 1
  68. // Antes personaje estaba en mapa[1][3]...ahora esta en mapa[1][4]
  69. // Y la posición mapa[1][3] antigua ahora queda así mapa[1][3]=1
  70. // Bueno mas o menos lo pillamos ¿no?
  71.  
  72. // Ahora que sabemos como nos movemos pues queda ver los casos que podemos movernos.
  73. // Ejemplo: si nos movemos solo de arriba abajo y de un lado a otro pues
  74. //si quiero ir a la izquierda antes tengo que ver si en esa izquierda esta la X (pared) o
  75. //si ya hemos estado ahí antes, o sea 1.
  76.  
  77. // Algo así en código:
  78.  
  79. // Digamos que estamos en la posición mapa[1][4] con el incremento del ejemplo anterior
  80. // Para saber si nos podemos ir a mapa[1][5](Derecha) una forma puede ser:
  81.  
  82. if ( mapa[1][5] == 0 )
  83.   x++;
  84.  
  85. // si queremos ir hacia abajo
  86.  
  87. if ( mapa[2][4] == 0 )
  88.   y++;
  89.  
  90. // El 1(campo ya explorado) en realidad el 1 no imposibilita atravesar-lo.
  91. // Imagine que llegues a un punto como este y salimos de la V:
  92. //     XXXXXXXXXXXX
  93. //     XV11111111PX
  94. //     XXXXXX0XXXXX
  95. //     X000000XXXXX
  96.  
  97. // Como ves la única forma de salir es volver hacia donde ya hemos pasado hasta llegar aquí:
  98. //     XXXXXXXXXXXX
  99. //     X11111P1111X
  100. //     XXXXXX0XXXXX
  101. //     X000000XXXXX
  102.  
  103. // Pues aquí el personaje puede ir hacia 3 direcciones, pero solo una es la buena
  104. // Debes de hacer que prefiera la 0 envés de 1, pero si no hay remedio pues que pase
  105. // por 1 hasta llegar a otro 0 :D
  106.  
  107. // Bien solo nos queda lo del final 'F'
  108. // si lo que quieres es que encuentre el F antes de terminar bien caso contrario puedes
  109. //poner una validación de si no encontrado todos los 0 no puedes salir
  110. // O simplemente si todo los ceros se terminaron pues FIN XD
  111. // Eso es un poco de lógica de videojuegos.
  112. // No se si te sirve pero es algo :D
  113.  

Espero que te sirva.
Me ha dado una gana de hacer un come cocos jaja
¡Mucha suerte! :D


Título: Re: Ayuda con programa urgente!
Publicado por: Albertocn en 9 Diciembre 2013, 05:24 am
Muchísimas gracias por responder en verdad y por tomarte el tiempo de ayudarme, creo que es más sencillo de lo que parece, mira, me explico mejor, con el código que subí arriba se generó un laberinto de 25x25, usé matrices, le asigné valores de "1" al camino, el resto son valores de 0, que representan las paredes, ahora lo que necesito es que empiece a recorrer el laberinto automáticamente usando delay hasta llegar al dos, para eso se usa un for también, pero no sé como hacer para que lo recorra....


Título: Re: Ayuda con programa urgente!
Publicado por: vangodp en 9 Diciembre 2013, 05:48 am
Que es eso:
for(y=0;y<25;y++)
{
I   //Eso me da error
}


Título: Re: Ayuda con programa urgente!
Publicado por: vangodp en 9 Diciembre 2013, 06:01 am
Código
  1.    #include <stdio.h>
  2.    #include <conio.h>
  3.    #include <dos.h>
  4.    #include <windows.h>
  5.    main()
  6.    {
  7. system("cls");
  8.    int arreglo[25][25]={0},x=0,y=0;
  9.    arreglo[1][0]=1;
  10.    arreglo[1][1]=1;
  11.    arreglo[1][2]=1;
  12.    arreglo[1][3]=1;
  13.    arreglo[1][4]=1;
  14.    arreglo[1][5]=1;
  15.    arreglo[2][5]=1;
  16.    arreglo[3][5]=1;
  17.    arreglo[6][7]=1;
  18.    arreglo[5][7]=1;
  19.    arreglo[4][5]=1;
  20.    arreglo[4][6]=1;
  21.    arreglo[4][7]=1;
  22.    arreglo[7][8]=1;
  23.    arreglo[7][7]=1;
  24.    arreglo[8][8]=1;
  25.    arreglo[8][9]=1;
  26.    arreglo[8][10]=1;
  27.    arreglo[8][11]=1;
  28.    arreglo[8][12]=1;
  29.    arreglo[8][13]=1;
  30.    arreglo[9][13]=1;
  31.    arreglo[10][13]=1;
  32.    arreglo[10][12]=1;
  33.    arreglo[10][11]=1;
  34.    arreglo[10][10]=1;
  35.    arreglo[10][9]=1;
  36.    arreglo[10][8]=1;
  37.    arreglo[10][7]=1;
  38.    arreglo[10][6]=1;
  39.    arreglo[10][5]=1;
  40.    arreglo[11][5]=1;
  41.    arreglo[12][5]=1;
  42.    arreglo[13][0]=1;
  43.    arreglo[13][1]=1;
  44.    arreglo[13][2]=1;
  45.    arreglo[13][3]=1;
  46.    arreglo[13][4]=1;
  47.    arreglo[13][5]=1;
  48.    arreglo[14][0]=1;
  49.    arreglo[15][0]=1;
  50.    arreglo[16][0]=1;
  51.    arreglo[16][1]=1;
  52.    arreglo[16][2]=1;
  53.    arreglo[16][3]=1;
  54.    arreglo[16][4]=1;
  55.    arreglo[16][5]=1;
  56.    arreglo[16][6]=1;
  57.    arreglo[16][7]=1;
  58.    arreglo[16][8]=1;
  59.    arreglo[16][9]=1;
  60.    arreglo[16][10]=1;
  61.    arreglo[16][11]=1;
  62.    arreglo[16][12]=1;
  63.    arreglo[16][13]=1;
  64.    arreglo[16][14]=1;
  65.    arreglo[16][15]=1;
  66.    arreglo[17][15]=1;
  67.    arreglo[18][15]=1;
  68.    arreglo[18][16]=1;
  69.    arreglo[18][17]=1;
  70.    arreglo[18][18]=1;
  71.    arreglo[18][19]=1;
  72.    arreglo[19][19]=1;
  73.    arreglo[20][19]=1;
  74.    arreglo[20][18]=1;
  75.    arreglo[20][17]=1;
  76.    arreglo[20][16]=1;
  77.    arreglo[21][16]=1;
  78.    arreglo[21][15]=1;
  79.    arreglo[21][14]=1;
  80.    arreglo[21][13]=1;
  81.    arreglo[21][12]=1;
  82.    arreglo[21][11]=1;
  83.    arreglo[21][10]=1;
  84.    arreglo[21][9]=1;
  85.    arreglo[22][9]=1;
  86.    arreglo[23][9]=1;
  87.    arreglo[24][9]=1;
  88.    arreglo[24][10]=1;
  89.    arreglo[24][11]=1;
  90.    arreglo[24][12]=1;
  91.    arreglo[24][13]=1;
  92.    arreglo[24][14]=1;
  93.    arreglo[24][15]=1;
  94.    arreglo[24][16]=1;
  95.    arreglo[24][17]=1;
  96.    arreglo[23][17]=1;
  97.    arreglo[23][18]=1;
  98.    arreglo[23][19]=1;
  99.    arreglo[23][20]=1;
  100.    arreglo[23][21]=1;
  101.    arreglo[23][22]=1;
  102.    arreglo[23][23]=1;
  103.    arreglo[23][24]=2;
  104.  
  105.     for(x=0;x<25;x++)
  106.     {
  107.     for(y=0;y<25;y++)
  108.     {
  109.     printf("%d",arreglo[x][y]);
  110.     Sleep(50);
  111.     }
  112.     printf("\n");
  113.     Sleep(50);
  114.     }
  115.  
  116.  
  117. system("pause");
  118.  
  119. }
  120.  

Eso es lo que eh logrado pero lo unico que hace es imprimir numero a numero esperando un rato entre cada letra.
Me sale eso:
0000000000000000000000000
1111110000000000000000000
0000010000000000000000000
0000010000000000000000000
0000011100000000000000000
0000000100000000000000000
0000000100000000000000000
0000000110000000000000000
0000000011111100000000000
0000000000000100000000000
0000011111111100000000000
0000010000000000000000000
0000010000000000000000000
1111110000000000000000000
1000000000000000000000000
1000000000000000000000000
1111111111111111000000000
0000000000000001000000000
0000000000000001111100000
0000000000000000000100000
0000000000000000111100000
0000000001111111100000000
0000000001000000000000000
0000000001000000011111112
0000000001111111110000000
Presione una tecla para continuar . . .
pero va haciendo linea a linea.
numero a numero.
No se que es lo que quieres?


Título: Re: Ayuda con programa urgente!
Publicado por: vangodp en 9 Diciembre 2013, 10:25 am
Código
  1. #include <stdio.h>
  2. #include <conio.h>
  3. #include <dos.h>
  4. #include <windows.h>
  5.  
  6. #define t Sleep(200)
  7.  
  8.  
  9. void mostrar(char mapa[26][26]){
  10. system ("cls");
  11.  
  12.     for(int y=0;y<25;y++)
  13.     {
  14.     for(int x=0;x<25;x++)
  15.     {
  16.     printf("%c",mapa[y][x]);
  17.     //Sleep(1);
  18.     }
  19.     printf("\n");
  20.     //Sleep(1);
  21.     }
  22.  
  23. }
  24.  
  25. int main (){
  26.  
  27. char mapa[26][26]={
  28. "0000000000000000000000000",
  29. "1111110000000000000000000",
  30. "0000010000000000000000000",
  31. "0000010000000000000000000",
  32. "0000011100000000000000000",
  33. "0000000100000000000000000",
  34. "0000000100000000000000000",
  35. "0000000110000000000000000",
  36. "0000000011111100000000000",
  37. "0000000000000100000000000",
  38. "0000011111111100000000000",
  39. "0000010000000000000000000",
  40. "0000010000000000000000000",
  41. "1111110000000000000000000",
  42. "1000000000000000000000000",
  43. "1000000000000000000000000",
  44. "1111111111111111000000000",
  45. "0000000000000001000000000",
  46. "0000000000000001111100000",
  47. "0000000000000000000100000",
  48. "0000000000000000111100000",
  49. "0000000001111111100000000",
  50. "0000000001000000000000000",
  51. "0000000001000000011111110",
  52. "0000000001111111110000000",
  53. };
  54.  
  55.  
  56. mapa[1][0]='X';//1.0 hacia la 1.5
  57. mostrar(mapa);
  58. t;
  59.  
  60.  
  61. mapa[1][1]='X';//1.1
  62. mostrar(mapa);
  63. t;
  64.  
  65.  
  66. mapa[1][2]='X';//1.2
  67. mostrar(mapa);
  68. t;
  69.  
  70.  
  71. mapa[1][3]='X';//1.3
  72. mostrar(mapa);
  73. t;
  74.  
  75.  
  76. mapa[1][4]='X';//1.4
  77. mostrar(mapa);
  78. t;
  79.  
  80.  
  81. mapa[1][5]='X';//1.5 hacia la 4.5
  82. mostrar(mapa);
  83. t;
  84.  
  85. mapa[2][5]='X';//2.5
  86. mostrar(mapa);
  87. t;
  88.  
  89. mapa[3][5]='X';//3.5
  90. mostrar(mapa);
  91. t;
  92.  
  93. mapa[4][5]='X';//4.5 Hacia 4.7
  94. mostrar(mapa);
  95. t;
  96.  
  97. mapa[4][6]='X';//4.6
  98. mostrar(mapa);
  99. t;
  100.  
  101. mapa[4][7]='X';//4.7 hacia 7.7
  102. mostrar(mapa);
  103. t;
  104.  
  105. mapa[5][7]='X';//5.7
  106. mostrar(mapa);
  107. t;
  108.  
  109. mapa[6][7]='X';//6.7
  110. mostrar(mapa);
  111. t;
  112.  
  113. mapa[7][7]='X';//7.7 hacia 7.8
  114. mostrar(mapa);
  115. t;
  116.  
  117. mapa[7][8]='X';//7.8 hacia 8.8
  118. mostrar(mapa);
  119. t;
  120.  
  121. mapa[8][8]='X';//8.8 hacia 8.13
  122. mostrar(mapa);
  123. t;
  124.  
  125. mapa[8][9]='X';//8.9
  126. mostrar(mapa);
  127. t;
  128.  
  129. mapa[8][10]='X';//8.10
  130. mostrar(mapa);
  131. t;
  132.  
  133. mapa[8][11]='X';//8.11
  134. mostrar(mapa);
  135. t;
  136.  
  137. mapa[8][12]='X';//8.12
  138. mostrar(mapa);
  139. t;
  140.  
  141. mapa[8][13]='X';//8.13 hacia 10.13
  142. mostrar(mapa);
  143. t;
  144.  
  145. mapa[9][13]='X';//9.13
  146. mostrar(mapa);
  147. t;
  148.  
  149. mapa[10][13]='X';//10.13 hacia 10.5
  150. mostrar(mapa);
  151. t;
  152.  
  153. mapa[10][12]='X';//10.12
  154. mostrar(mapa);
  155. t;
  156.  
  157. mapa[10][11]='X';//10.11
  158. mostrar(mapa);
  159. t;
  160.  
  161. mapa[10][10]='X';//10.10
  162. mostrar(mapa);
  163. t;
  164.  
  165. mapa[10][9]='X';//10.9
  166. mostrar(mapa);
  167. t;
  168.  
  169. mapa[10][8]='X';//10.8
  170. mostrar(mapa);
  171. t;
  172.  
  173. mapa[10][7]='X';//10.7
  174. mostrar(mapa);
  175. t;
  176.  
  177. mapa[10][6]='X';//10.6
  178. mostrar(mapa);
  179. t;
  180.  
  181. mapa[10][5]='X';//10.5 hacia 13.5
  182. mostrar(mapa);
  183. t;
  184.  
  185. mapa[11][5]='X';//11.5
  186. mostrar(mapa);
  187. t;
  188.  
  189. mapa[12][5]='X';//12.5
  190. mostrar(mapa);
  191. t;
  192.  
  193. mapa[13][5]='X';//13.5 hacia 13.0
  194. mostrar(mapa);
  195. t;
  196.  
  197. mapa[13][4]='X';//13.4
  198. mostrar(mapa);
  199. t;
  200.  
  201. mapa[13][3]='X';//13.3
  202. mostrar(mapa);
  203. t;
  204.  
  205. mapa[13][2]='X';//13.2
  206. mostrar(mapa);
  207. t;
  208.  
  209. mapa[13][1]='X';//13.1
  210. mostrar(mapa);
  211. t;
  212.  
  213. mapa[13][0]='X';//13.0 hacia 16.0
  214. mostrar(mapa);
  215. t;
  216.  
  217. mapa[14][0]='X';//14.0
  218. mostrar(mapa);
  219. t;
  220.  
  221. mapa[15][0]='X';//15.0
  222. mostrar(mapa);
  223. t;
  224.  
  225. mapa[16][0]='X';//16.0 // hacia 16.15
  226. mostrar(mapa);
  227. t;
  228.  
  229. mapa[16][1]='X';//16.1
  230. mostrar(mapa);
  231. t;
  232.  
  233. mapa[16][2]='X';//16.2
  234. mostrar(mapa);
  235. t;
  236.  
  237. mapa[16][3]='X';//16.3
  238. mostrar(mapa);
  239. t;
  240.  
  241. mapa[16][4]='X';//16.4
  242. mostrar(mapa);
  243. t;
  244.  
  245. mapa[16][5]='X';//16.5
  246. mostrar(mapa);
  247. t;
  248.  
  249. mapa[16][6]='X';//16.6
  250. mostrar(mapa);
  251. t;
  252.  
  253. mapa[16][7]='X';//16.7
  254. mostrar(mapa);
  255. t;
  256.  
  257. mapa[16][8]='X';//16.8
  258. mostrar(mapa);
  259. t;
  260.  
  261. mapa[16][9]='X';//16.9
  262. mostrar(mapa);
  263. t;
  264.  
  265. mapa[16][10]='X';//16.10
  266. mostrar(mapa);
  267. t;
  268.  
  269. mapa[16][11]='X';//16.11
  270. mostrar(mapa);
  271. t;
  272.  
  273. mapa[16][12]='X';//16.12
  274. mostrar(mapa);
  275. t;
  276.  
  277. mapa[16][13]='X';//16.13
  278. mostrar(mapa);
  279. t;
  280.  
  281. mapa[16][14]='X';//16.14
  282. mostrar(mapa);
  283. t;
  284.  
  285. mapa[16][15]='X';//16.15 hacia 18.15
  286. mostrar(mapa);
  287. t;
  288.  
  289. mapa[17][15]='X';//17.15
  290. mostrar(mapa);
  291. t;
  292.  
  293. mapa[18][15]='X';//18.15 hacia 18.19
  294. mostrar(mapa);
  295. t;
  296.  
  297. mapa[18][16]='X';//18.16
  298. mostrar(mapa);
  299. t;
  300.  
  301. mapa[18][17]='X';//18.17
  302. mostrar(mapa);
  303. t;
  304.  
  305. mapa[18][18]='X';//18.18
  306. mostrar(mapa);
  307. t;
  308.  
  309. mapa[18][19]='X';//18.19 hacia 20.19
  310. mostrar(mapa);
  311. t;
  312.  
  313. mapa[19][19]='X';//19.19
  314. mostrar(mapa);
  315. t;
  316.  
  317. mapa[20][19]='X';//20.19 hacia 20.16
  318. mostrar(mapa);
  319. t;
  320.  
  321. mapa[20][18]='X';//20.18
  322. mostrar(mapa);
  323. t;
  324.  
  325. mapa[20][17]='X';//20.17
  326. mostrar(mapa);
  327. t;
  328.  
  329. mapa[20][16]='X';//20.16 hacia 21.16
  330. mostrar(mapa);
  331. t;
  332.  
  333. mapa[21][16]='X';//21.16 hacia 21.9
  334. mostrar(mapa);
  335. t;
  336.  
  337. mapa[21][15]='X';//21.15
  338. mostrar(mapa);
  339. t;
  340.  
  341. mapa[21][14]='X';//21.14
  342. mostrar(mapa);
  343. t;
  344.  
  345. mapa[21][13]='X';//21.13
  346. mostrar(mapa);
  347. t;
  348.  
  349. mapa[21][12]='X';//21.12
  350. mostrar(mapa);
  351. t;
  352.  
  353. mapa[21][11]='X';//21.11
  354. mostrar(mapa);
  355. t;
  356.  
  357. mapa[21][10]='X';//21.10
  358. mostrar(mapa);
  359. t;
  360.  
  361. mapa[21][9]='X';//21.9 hacia 24.9
  362. mostrar(mapa);
  363. t;
  364.  
  365. mapa[22][9]='X';//22.9
  366. mostrar(mapa);
  367. t;
  368.  
  369. mapa[23][9]='X';//23.9
  370. mostrar(mapa);
  371. t;
  372.  
  373. mapa[24][9]='X';//24.9 hacia 24.17*
  374. mostrar(mapa);
  375. t;
  376.  
  377. mapa[24][10]='X';//24.10
  378. mostrar(mapa);
  379. t;
  380.  
  381. mapa[24][11]='X';//24.11
  382. mostrar(mapa);
  383. t;
  384.  
  385. mapa[24][12]='X';//24.12
  386. mostrar(mapa);
  387. t;
  388.  
  389. mapa[24][13]='X';//24.13
  390. mostrar(mapa);
  391. t;
  392.  
  393. mapa[24][14]='X';//24.14
  394. mostrar(mapa);
  395. t;
  396.  
  397. mapa[24][15]='X';//24.15
  398. mostrar(mapa);
  399. t;
  400.  
  401. mapa[24][16]='X';//24.16
  402. mostrar(mapa);
  403. t;
  404.  
  405. mapa[24][17]='X';//24.17 hacia 23.17
  406. mostrar(mapa);
  407. t;
  408.  
  409. mapa[23][17]='X';//23.17 hacia 23.24
  410. mostrar(mapa);
  411. t;
  412.  
  413. mapa[23][18]='X';//23.18
  414. mostrar(mapa);
  415. t;
  416.  
  417. mapa[23][19]='X';//23.19
  418. mostrar(mapa);
  419. t;
  420.  
  421. mapa[23][20]='X';//23.20
  422. mostrar(mapa);
  423. t;
  424.  
  425. mapa[23][21]='X';//23.21
  426. mostrar(mapa);
  427. t;
  428.  
  429. mapa[23][22]='X';//23.22
  430. mostrar(mapa);
  431. t;
  432.  
  433. mapa[23][23]='X';//23.23
  434. mostrar(mapa);
  435. t;
  436.  
  437. mapa[23][24]='X';//23.24 Fin
  438. mostrar(mapa);
  439. t;
  440.  
  441. }
  442.  

Método de fuerza bruta jaja  :laugh:

No se si es eso pero me divierto jaja

Se puede quedar en la mitad si a cada "hacia" le pones un contador
y unos while y vas incrementando hasta llegar en el siguiente "hacia"
JAJAJ me lo paso bomba con esos programas tontos  ;D


Título: Re: Ayuda con programa urgente!
Publicado por: Albertocn en 9 Diciembre 2013, 18:39 pm
Es que apenas estoy aprendiendo...es mi primer semestre, y si, mira se supone que debe formar esto, el programa que uso es Turbo c++, no me pregunten por qué...es con el que estamos trabajando!

0000000000000000000000000
1111110000000000000000000
0000010000000000000000000
0000010000000000000000000
0000011100000000000000000
0000000100000000000000000
0000000100000000000000000
0000000110000000000000000
0000000011111100000000000
0000000000000100000000000
0000011111111100000000000
0000010000000000000000000
0000010000000000000000000
1111110000000000000000000
1000000000000000000000000
1000000000000000000000000
1111111111111111000000000
0000000000000001000000000
0000000000000001111100000
0000000000000000000100000
0000000000000000111100000
0000000001111111100000000
0000000001000000000000000
0000000001000000011111112
0000000001111111110000000

Y lo que yo quiero es que de alguna manera, con un símbolo, por ejemplo un #, vaya recorriendo los unos hasta llegar al 2, pero no se como meter el for dentro de l for que ya tengo, osea automaticamente....


Título: Re: Ayuda con programa urgente!
Publicado por: ivancea96 en 9 Diciembre 2013, 21:50 pm
Si solo es un laberinto de 1 carril, puedes hacer esto:

En unas variables X e Y guardas la posición actual. (Por donde estás en cada momento).
Buscas cuál es el 1 o 2 que hay delante. Haces que unas variables tempX y tempY guarden los datos de X e Y, y X e Y las igualas a la nueva posición.
Ahora vuelves a buscar, con una condición: El nuevo 1 o 2 a buscar no puede estar en la posición anterior (tempX o tempY).
Con cada paso, muestras la pantalla.

Es el algoritmo que se me ocurre. Solo para recorridos con 1 dirección y 1 de grosor en el camino.


Código
  1. /** Buscar unos o doses **/
  2. for(int i=-1; i<2; i++)
  3.    for(int j=-1; j<2; j++)
  4.        if(!(x+i == tempX && y+j == tempY) && (i || j) && (vector[x+i][y+j] == 1 || vector[x+i][y+j] == 2)){
  5.            tempX = X;
  6.            tempY = Y;
  7.            X = X+i;
  8.            Y = Y+j;
  9.        }
  10. //.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.
  11. // - Mostrar pantalla, comprobar si es un 2 para finalizar, etc, etc... -
  12. //'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'-'
  13.  


----------------Breve explicación de las condiciones:----------------

Código
  1. !(x+i == tempX && y+j == tempY)

-Los nuevos valores NO pueden ser iguales a los anteriores (Para no retroceder en el laberinto)

Código
  1. (i || j)

-I y J NO pueden ser 0 (Significaría que nos situaremos en la misma casilla, donde estamos)

Código
  1. (vector[x+i][y+j] == 1 || vector[x+i][y+j] == 2)

-El siguiente paso en el laberinto DEBE ser un 1 o un 2 (Es el número asociado al camino)



Y bueno, suerte :3 Espero no haberme equivocado en nada jaja


Título: Re: Ayuda con programa urgente!
Publicado por: vangodp en 10 Diciembre 2013, 02:05 am
Alberto, aun que usas borland puedes instalar otros compiladores.
Si te paso un código echo en dev cpp o codeblocks no lo vas entender por que no tienes el compilador?
Instalas otro como codeblocks, al menos ves que hace el código.
No uso borland, por que doy preferencia al free.
Ni se si existe borland free.  :silbar:
¿Que es mejor?Que tu muñeco vaya como un perro enseñado el camino o lo busque por si solo.
El camino puede no siempre ser directo, puede haber calles sin salida¿No?
Lo que te hablo y también ivancea96, es lo mejor.
Que se busque el su caminito :D

Y si declaras el mapa como lo hace yo te sera mas facil:

Código
  1. char mapa[26][26]={
  2. "0000000000000000000000000",
  3. "1111110000000000000000000",
  4. "0000010000000000000000000",
  5. "0000010000000000000000000",
  6. "0000011100000000000000000",
  7. "0000000100000000000000000",
  8. "0000000100000000000000000",
  9. "0000000110000000000000000",
  10. "0000000011111100000000000",
  11. "0000000000000100000000000",
  12. "0000011111111100000000000",
  13. "0000010000000000000000000",
  14. "0000010000000000000000000",
  15. "1111110000000000000000000",
  16. "1000000000000000000000000",
  17. "1000000000000000000000000",
  18. "1111111111111111000000000",
  19. "0000000000000001000000000",
  20. "0000000000000001111100000",
  21. "0000000000000000000100000",
  22. "0000000000000000111100000",
  23. "0000000001111111100000000",
  24. "0000000001000000000000000",
  25. "0000000001000000011111112",
  26. "0000000001111111110000000",
  27. };
  28.  
¿Cuantas lineas de código eh ajorado aquí?
Pero se trata de char y no de int, se le guarda como un "string entre comillas doble"
si lo guardas como int se guarda { {1,2,3,4,5,6}, {9,2,5,7,8,8} } mas o menos, ya ves que tienes que ir poniendo comas entre los números y llaves y yo que se que mas.
De esta manera hasta ves el mapa como queda :D


Título: Re: Ayuda con programa urgente!
Publicado por: Albertocn en 10 Diciembre 2013, 03:56 am
Se ve mucho más fácil hacerlo así como dices, ¿pero cómo lo imprimo?, ¿también con el for?, créanme que es un problema tener un compilador como el que estamos usando y más ya que estoy empezando con esto de la programación, desafortunadamente el proyecto nos lo piden así, ya tomó mas forma el laberinto, aquí mi duda es, el for que me sugirieron, ¿dónde lo meto en mi programa?, ¿cómo quedaría?...he intentado otras cosas pero se me cicla!, es bastante desesperante esto...

Código
  1. #include <stdio.h>
  2. #include <conio.h>
  3. #include <dos.h>
  4. main()
  5. {
  6. textcolor(BLUE);
  7. clrscr();
  8. int arreglo[25][25]={0},x=0,y=0;
  9. arreglo[1][0]=1;
  10. arreglo[1][1]=1;
  11. arreglo[1][2]=1;
  12. arreglo[1][3]=1;
  13. arreglo[1][4]=1;
  14. arreglo[1][5]=1;
  15. arreglo[2][5]=1;
  16. arreglo[3][5]=1;
  17. arreglo[6][7]=1;
  18. arreglo[5][7]=1;
  19. arreglo[4][5]=1;
  20. arreglo[4][6]=1;
  21. arreglo[4][7]=1;
  22. arreglo[7][8]=1;
  23. arreglo[7][7]=1;
  24. arreglo[8][8]=1;
  25. arreglo[8][9]=1;
  26. arreglo[8][10]=1;
  27. arreglo[8][11]=1;
  28. arreglo[8][12]=1;
  29. arreglo[8][13]=1;
  30. arreglo[9][13]=1;
  31. arreglo[10][13]=1;
  32. arreglo[10][12]=1;
  33. arreglo[10][11]=1;
  34. arreglo[10][10]=1;
  35. arreglo[10][9]=1;
  36. arreglo[10][8]=1;
  37. arreglo[10][7]=1;
  38. arreglo[10][6]=1;
  39. arreglo[10][5]=1;
  40. arreglo[11][5]=1;
  41. arreglo[12][5]=1;
  42. arreglo[13][0]=1;
  43. arreglo[13][1]=1;
  44. arreglo[13][2]=1;
  45. arreglo[13][3]=1;
  46. arreglo[13][4]=1;
  47. arreglo[13][5]=1;
  48. arreglo[14][0]=1;
  49. arreglo[15][0]=1;
  50. arreglo[16][0]=1;
  51. arreglo[16][1]=1;
  52. arreglo[16][2]=1;
  53. arreglo[16][3]=1;
  54. arreglo[16][4]=1;
  55. arreglo[16][5]=1;
  56. arreglo[16][6]=1;
  57. arreglo[16][7]=1;
  58. arreglo[16][8]=1;
  59. arreglo[16][9]=1;
  60. arreglo[16][10]=1;
  61. arreglo[16][11]=1;
  62. arreglo[16][12]=1;
  63. arreglo[16][13]=1;
  64. arreglo[16][14]=1;
  65. arreglo[16][15]=1;
  66. arreglo[17][15]=1;
  67. arreglo[18][15]=1;
  68. arreglo[18][16]=1;
  69. arreglo[18][17]=1;
  70. arreglo[18][18]=1;
  71. arreglo[18][19]=1;
  72. arreglo[19][19]=1;
  73. arreglo[20][19]=1;
  74. arreglo[20][18]=1;
  75. arreglo[20][17]=1;
  76. arreglo[20][16]=1;
  77. arreglo[21][16]=1;
  78. arreglo[21][15]=1;
  79. arreglo[21][14]=1;
  80. arreglo[21][13]=1;
  81. arreglo[21][12]=1;
  82. arreglo[21][11]=1;
  83. arreglo[21][10]=1;
  84. arreglo[21][9]=1;
  85. arreglo[22][9]=1;
  86. arreglo[23][9]=1;
  87. arreglo[24][9]=1;
  88. arreglo[24][10]=1;
  89. arreglo[24][11]=1;
  90. arreglo[24][12]=1;
  91. arreglo[24][13]=1;
  92. arreglo[24][14]=1;
  93. arreglo[24][15]=1;
  94. arreglo[24][16]=1;
  95. arreglo[24][17]=1;
  96. arreglo[23][17]=1;
  97. arreglo[23][18]=1;
  98. arreglo[23][19]=1;
  99. arreglo[23][20]=1;
  100. arreglo[23][21]=1;
  101. arreglo[23][22]=1;
  102. arreglo[23][23]=1;
  103. arreglo[23][24]=2;
  104. arreglo[15][10]=1;
  105. arreglo[14][10]=1;
  106. arreglo[14][11]=1;
  107. arreglo[14][12]=1;
  108. arreglo[14][13]=1;
  109. arreglo[6][8]=1;
  110. arreglo[6][9]=1;
  111. arreglo[6][10]=1;
  112. arreglo[6][11]=1;
  113. arreglo[6][12]=1;
  114. arreglo[6][13]=1;
  115. arreglo[7][13]=1;
  116. arreglo[17][0]=1;
  117. arreglo[18][0]=1;
  118. arreglo[19][0]=1;
  119. arreglo[19][1]=1;
  120. arreglo[19][2]=1;
  121. arreglo[19][3]=1;
  122. arreglo[20][3]=1;
  123. arreglo[20][4]=1;
  124. arreglo[20][5]=1;
  125. for(x=0;x<25;x++)
  126. {
  127. for(y=0;y<25;y++)
  128. {
  129. printf("%d",arreglo[x][y]);
  130. }
  131. printf("\n");
  132. }
  133. for(x=0;x<25;x++)
  134. {
  135. for(y=0;y<25;y++)
  136. {
  137. }
  138. }
  139. getch();
  140. }


Título: Re: Ayuda con programa urgente!
Publicado por: Albertocn en 10 Diciembre 2013, 03:58 am
Quedó igual sólo le di más forma, tiene dos for debajo de los for que use para imprimir, no afectan en nada, es ahí donde no se que ponerle para que me empiece a recorrer el camino, hasta el momento es lo único que nos han enseñado, for, while, if, switch y funciones.
Código
  1. #include <stdio.h>
  2. #include <conio.h>
  3. #include <dos.h>
  4. main()
  5. {
  6. textcolor(BLUE);
  7. clrscr();
  8. int arreglo[25][25]={0},x=0,y=0;
  9. arreglo[1][0]=1;
  10. arreglo[1][1]=1;
  11. arreglo[1][2]=1;
  12. arreglo[1][3]=1;
  13. arreglo[1][4]=1;
  14. arreglo[1][5]=1;
  15. arreglo[2][5]=1;
  16. arreglo[3][5]=1;
  17. arreglo[6][7]=1;
  18. arreglo[5][7]=1;
  19. arreglo[4][5]=1;
  20. arreglo[4][6]=1;
  21. arreglo[4][7]=1;
  22. arreglo[7][8]=1;
  23. arreglo[7][7]=1;
  24. arreglo[8][8]=1;
  25. arreglo[8][9]=1;
  26. arreglo[8][10]=1;
  27. arreglo[8][11]=1;
  28. arreglo[8][12]=1;
  29. arreglo[8][13]=1;
  30. arreglo[9][13]=1;
  31. arreglo[10][13]=1;
  32. arreglo[10][12]=1;
  33. arreglo[10][11]=1;
  34. arreglo[10][10]=1;
  35. arreglo[10][9]=1;
  36. arreglo[10][8]=1;
  37. arreglo[10][7]=1;
  38. arreglo[10][6]=1;
  39. arreglo[10][5]=1;
  40. arreglo[11][5]=1;
  41. arreglo[12][5]=1;
  42. arreglo[13][0]=1;
  43. arreglo[13][1]=1;
  44. arreglo[13][2]=1;
  45. arreglo[13][3]=1;
  46. arreglo[13][4]=1;
  47. arreglo[13][5]=1;
  48. arreglo[14][0]=1;
  49. arreglo[15][0]=1;
  50. arreglo[16][0]=1;
  51. arreglo[16][1]=1;
  52. arreglo[16][2]=1;
  53. arreglo[16][3]=1;
  54. arreglo[16][4]=1;
  55. arreglo[16][5]=1;
  56. arreglo[16][6]=1;
  57. arreglo[16][7]=1;
  58. arreglo[16][8]=1;
  59. arreglo[16][9]=1;
  60. arreglo[16][10]=1;
  61. arreglo[16][11]=1;
  62. arreglo[16][12]=1;
  63. arreglo[16][13]=1;
  64. arreglo[16][14]=1;
  65. arreglo[16][15]=1;
  66. arreglo[17][15]=1;
  67. arreglo[18][15]=1;
  68. arreglo[18][16]=1;
  69. arreglo[18][17]=1;
  70. arreglo[18][18]=1;
  71. arreglo[18][19]=1;
  72. arreglo[19][19]=1;
  73. arreglo[20][19]=1;
  74. arreglo[20][18]=1;
  75. arreglo[20][17]=1;
  76. arreglo[20][16]=1;
  77. arreglo[21][16]=1;
  78. arreglo[21][15]=1;
  79. arreglo[21][14]=1;
  80. arreglo[21][13]=1;
  81. arreglo[21][12]=1;
  82. arreglo[21][11]=1;
  83. arreglo[21][10]=1;
  84. arreglo[21][9]=1;
  85. arreglo[22][9]=1;
  86. arreglo[23][9]=1;
  87. arreglo[24][9]=1;
  88. arreglo[24][10]=1;
  89. arreglo[24][11]=1;
  90. arreglo[24][12]=1;
  91. arreglo[24][13]=1;
  92. arreglo[24][14]=1;
  93. arreglo[24][15]=1;
  94. arreglo[24][16]=1;
  95. arreglo[24][17]=1;
  96. arreglo[23][17]=1;
  97. arreglo[23][18]=1;
  98. arreglo[23][19]=1;
  99. arreglo[23][20]=1;
  100. arreglo[23][21]=1;
  101. arreglo[23][22]=1;
  102. arreglo[23][23]=1;
  103. arreglo[23][24]=2;
  104. arreglo[15][10]=1;
  105. arreglo[14][10]=1;
  106. arreglo[14][11]=1;
  107. arreglo[14][12]=1;
  108. arreglo[14][13]=1;
  109. arreglo[6][8]=1;
  110. arreglo[6][9]=1;
  111. arreglo[6][10]=1;
  112. arreglo[6][11]=1;
  113. arreglo[6][12]=1;
  114. arreglo[6][13]=1;
  115. arreglo[7][13]=1;
  116. arreglo[17][0]=1;
  117. arreglo[18][0]=1;
  118. arreglo[19][0]=1;
  119. arreglo[19][1]=1;
  120. arreglo[19][2]=1;
  121. arreglo[19][3]=1;
  122. arreglo[20][3]=1;
  123. arreglo[20][4]=1;
  124. arreglo[20][5]=1;
  125. for(x=0;x<25;x++)
  126. {
  127. for(y=0;y<25;y++)
  128. {
  129. printf("%d",arreglo[x][y]);
  130. }
  131. printf("\n");
  132. }
  133. for(x=0;x<25;x++)
  134. {
  135. for(y=0;y<25;y++)
  136. {
  137. }
  138. }
  139. getch();
  140. }


Título: Re: Ayuda con programa urgente!
Publicado por: vangodp en 10 Diciembre 2013, 10:12 am
Código
  1. #include <stdio.h>
  2. #include <conio.h>
  3. #include <dos.h>
  4. #include <windows.h>
  5.  
  6. #define tiempo Sleep(5) /* Esto hace una pausa pero depende de windows.h */
  7.  
  8. void mostrar(char mapa[26][26]){
  9.     system ("cls"); /*Esto limpia la pantalla pero depende de windows.h*/
  10.     for(int y=0;y<25;y++){
  11.          for(int x=0;x<25;x++){
  12.               printf("%c",mapa[y][x]);
  13.               /*tiempo;*/
  14.          }
  15.          printf("\n");
  16.          /*tiempo; */
  17.     }
  18. }
  19.  
  20. int main (){
  21.  
  22. char mapa[26][26]={
  23. "0000000000000000000000000",
  24. "1111110000000000000000000",
  25. "0000010000000000000000000",
  26. "0000010000000000000000000",
  27. "0000011100000000000000000",
  28. "0000000100000000000000000",
  29. "0000000100000000000000000",
  30. "0000000110000000000000000",
  31. "0000000011111100000000000",
  32. "0000000000000100000000000",
  33. "0000011111111100000000000",
  34. "0000010000000000000000000",
  35. "0000010000000000000000000",
  36. "1111110000000000000000000",
  37. "1000000000000000000000000",
  38. "1000000000000000000000000",
  39. "1111111111111111000000000",
  40. "0000000000000001000000000",
  41. "0000000000000001111100000",
  42. "0000000000000000000100000",
  43. "0000000000000000111100000",
  44. "0000000001111111100000000",
  45. "0000000001000000000000000",
  46. "0000000001000000011111110",
  47. "0000000001111111110000000",
  48. };/*Fin de mapa*/
  49.  
  50. /*cuando quiera imprimir llamas a la funcion mostrar y le pasas el mapa.*/
  51. mostrar(mapa);
  52.  
  53. }/*Fin de main*/
  54.  


Título: Re: Ayuda con programa urgente!
Publicado por: leosansan en 10 Diciembre 2013, 15:48 pm
Lo dejo a medio camino, entre la fuerza bruta de vangodp y la solución definitiva de ivancea96 - que usaría en un laberinto generado aleatoriamente, pero no es el caso- . Lo que hago es aprovecharme de que el laberinto está prefijado y con el la solución o alternativas de movimientos.

Esto hace lo que quieres:


Código
  1. #include <stdio.h>
  2. //#include <conio.h> //usar en TurboC
  3.  
  4. void mostrar(char a[25][26]){
  5.    system ("cls");//creo que es clrscr() en TurboC
  6.    int i,j;
  7.    for( i=0;i<25;i++) {
  8.        for( j=0;j<25;j++) {
  9.            printf("%c ",a[i][j]);
  10.        }
  11.        printf("\n");
  12.    }
  13.    printf("\n");
  14.    //system ("pause");//puedes usar getch() o delay en TurboC
  15. }
  16.  
  17. int main (){
  18.    char a[25][26]={
  19.    "0000000000000000000000000",
  20.    "1111110000000000000000000",
  21.    "0000010000000000000000000",
  22.    "0000010000000000000000000",
  23.    "0000011100000000000000000",
  24.    "0000000100000000000000000",
  25.    "0000000100000000000000000",
  26.    "0000000110000000000000000",
  27.    "0000000011111100000000000",
  28.    "0000000000000100000000000",
  29.    "0000011111111100000000000",
  30.    "0000010000000000000000000",
  31.    "0000010000000000000000000",
  32.    "1111110000000000000000000",
  33.    "1000000000000000000000000",
  34.    "1000000000000000000000000",
  35.    "1111111111111111000000000",
  36.    "0000000000000001000000000",
  37.    "0000000000000001111100000",
  38.    "0000000000000000000100000",
  39.    "0000000000000000111100000",
  40.    "0000000001111111100000000",
  41.    "0000000001000000000000000",
  42.    "0000000001000000011111112",
  43.    "0000000001111111110000000",
  44.    };
  45.    int i=1,j=0,flag=0;
  46.    while (j<24){
  47.            if (i==1 && j==0)
  48.            a[i][j++]='X';
  49.            else if (a[i+1][j]=='1' && i<24 && flag==0)
  50.                a[i++][j]='X';
  51.            else if (a[i][j+1]=='1')
  52.                a[i][j++]='X';
  53.            else if (i<24 && a[i+1][j]=='0' && a[i][j+1]=='0'|| a[i][j+1]=='X')
  54.                a[i][(j--)]='X';
  55.            else if (i==24 && a[i][j+1]==1 )
  56.                a[i][j++]='X';
  57.            else if (i==24 && a[i][j+1]=='0' ){
  58.                a[i--][j]='X';
  59.                flag=1;
  60.            }
  61.            if (i==23 && j<24 && flag==1)
  62.                a[i][j++]='X';
  63.            //mostrar(a);
  64.        }
  65.    a[i][j]='X';
  66.    mostrar(a);
  67.    //getch();
  68.    return 0;
  69. }
  70.  

Ya, ya sé que es mejorable pero me da pereza xD.

Reedito:

¿Quién dijo lento?. Para muestra un botón:

Código
  1. 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  2. X X X X X X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  3. 0 0 0 0 0 X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  4. 0 0 0 0 0 X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  5. 0 0 0 0 0 X X X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  6. 0 0 0 0 0 0 0 X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  7. 0 0 0 0 0 0 0 X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  8. 0 0 0 0 0 0 0 X X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  9. 0 0 0 0 0 0 0 0 X X X X X X 0 0 0 0 0 0 0 0 0 0 0
  10. 0 0 0 0 0 0 0 0 0 0 0 0 0 X 0 0 0 0 0 0 0 0 0 0 0
  11. 0 0 0 0 0 X X X X X X X X X 0 0 0 0 0 0 0 0 0 0 0
  12. 0 0 0 0 0 X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  13. 0 0 0 0 0 X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  14. X X X X X X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  15. X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  16. X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  17. X X X X X X X X X X X X X X X X 0 0 0 0 0 0 0 0 0
  18. 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 X 0 0 0 0 0 0 0 0 0
  19. 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 X X X X X 0 0 0 0 0
  20. 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 X 0 0 0 0 0
  21. 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 X X X X 0 0 0 0 0
  22. 0 0 0 0 0 0 0 0 0 X X X X X X X X 0 0 0 0 0 0 0 0
  23. 0 0 0 0 0 0 0 0 0 X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
  24. 0 0 0 0 0 0 0 0 0 X 0 0 0 0 0 0 0 X X X X X X X X
  25. 0 0 0 0 0 0 0 0 0 X X X X X X X X X 0 0 0 0 0 0 0
  26.  
Process returned 0 (0x0)   execution time : 0.123 s


Saluditos! ..... !!!!        (http://st.forocoches.com/foro/images/smilies/aaaaa.gif)


Título: Re: Ayuda con programa urgente!
Publicado por: vangodp en 10 Diciembre 2013, 18:18 pm
jaja muy buena leo ;).
eh pensado en hacer que ande todo el camino solo buscando la salida.
Pero se toma algún tiempo XDD
Por cierto en el array no se por que pero le tengo que poner a[26][26]
con 25 me da error.¿por que sera?
En la funcion y en main


Título: Re: Ayuda con programa urgente!
Publicado por: leosansan en 10 Diciembre 2013, 19:57 pm
jaja muy buena leo ;).
eh pensado en hacer que ande todo el camino solo buscando la salida.
Pero se toma algún tiempo XDD

Es por tener que "dibujar" una matriz de 25x25, no creo que sea por otra cosa. Supongo que dependerá en gran medida de la tarjeta gráfica. O bien desactivas el system ("pause") de la función mostrar.

Por cierto en el array no se por que pero le tengo que poner a[26][26]
con 25 me da error.¿por que sera?
En la funcion y en main

Eso me extraña más ya que la matriz es de 25 elementos. A mí al menos me funciona sin problemas. Mira que error te "canta" y me cuentas a ver que ocurre.

Saluditos! ..... !!!!        (http://st.forocoches.com/foro/images/smilies/aaaaa.gif)


Título: Re: Ayuda con programa urgente!
Publicado por: vangodp en 16 Diciembre 2013, 16:09 pm
Buenas que tal!
Eh mejorado un poco el código :D
Lo eh echo auto suficiente jaja
Este se busca la salida solo XD
Puedes cambiar el mapa a gusto.
Es algo ineficiente aun, lo estoy puliendo cosillas como cuando encuentra una calle sin salida, le tarda algo en volver al camino, pero lo encuentra.
Aquí le dejo el rollo, jaja me eh reído un montón con el código jaja

Código
  1. #include <iostream>
  2. #include <windows.h>
  3. #include <stdio.h>
  4. #include <time.h>
  5. using namespace std;
  6.  
  7. int rand2 (){
  8. srand(time(NULL));
  9. int n = (0 + rand() % 2);
  10. return n;
  11. }
  12. int rand3 (){
  13. srand(time(NULL));
  14. int n = (0 + rand() % 3);
  15. return n;
  16. }
  17. int rand4 (){
  18. srand(time(NULL));
  19. int n = (0 + rand() % 4);
  20. return n;
  21. }
  22.  
  23. void mostrar(char mapa[29][29]){
  24. system ("cls");
  25.  
  26.     for(int y=0;y<29;y++)
  27.     {
  28.     for(int x=0;x<29;x++)
  29.     {
  30.     printf("%c",mapa[y][x]);
  31.     //Sleep(5);
  32.     }
  33.     printf("\n");
  34.     //Sleep(5);
  35.     }
  36.  
  37. }
  38.  
  39. // GO ONE
  40. void go_arriba( char mapa[29][29], int &x, int &y ){
  41. mapa [y][x]='1';
  42. y--;
  43. mapa [y][x]='X';
  44. }
  45. void go_izquierda( char mapa[29][29], int &x, int &y ){
  46. mapa [y][x]='1';
  47. x--;
  48. mapa [y][x]='X';
  49. }
  50. void go_derecha( char mapa[29][29], int &x, int &y ){
  51. mapa [y][x]='1';
  52. x++;
  53. mapa [y][x]='X';
  54. }  
  55. void go_abajo( char mapa[29][29], int &x, int &y ){
  56. mapa [y][x]='1';
  57. y++;
  58. mapa [y][x]='X';
  59. }
  60. // DECIDE 2
  61. void decide_arriba_izquierda ( char mapa[29][29], int &x, int &y ){
  62. switch ( rand2() ){
  63. case 0:
  64. go_arriba( mapa, x, y );
  65. break;
  66. case 1:
  67. go_izquierda( mapa, x, y );
  68. break;
  69. default:
  70. cout << "error:decide_arriba_izquierda"<<endl;
  71. cin.ignore();
  72. break;
  73. }
  74.  
  75. }
  76. void decide_arriba_derecha ( char mapa[29][29], int &x, int &y ){
  77. switch ( rand2() ){
  78. case 0:
  79. go_arriba ( mapa, x, y );
  80. break;
  81. case 1:
  82. go_derecha ( mapa, x, y );
  83. break;
  84. default:
  85. cout << "error:decide_arriba_derecha"<<endl;
  86. cin.ignore();
  87. break;
  88. }
  89. }
  90. void decide_arriba_abajo ( char mapa[29][29], int &x, int &y ){
  91. switch ( rand2() ){
  92. case 0:
  93. go_arriba( mapa, x, y );
  94. break;
  95. case 1:
  96. go_abajo( mapa, x, y );
  97. break;
  98. default:
  99. cout << "decide_arriba_abajo"<<endl;
  100. cin.ignore();
  101. break;
  102. }
  103. }
  104. void decide_izquierda_derecha ( char mapa[29][29], int &x, int &y ){
  105. switch ( rand2() ){
  106. case 0:
  107. go_izquierda( mapa, x, y );
  108. break;
  109. case 1:
  110. go_derecha( mapa, x, y );
  111. break;
  112. default:
  113. cout << "error:decide_izquierda_derecha"<<endl;
  114. cin.ignore();
  115. break;
  116. }
  117. }
  118. void decide_izquierda_abajo ( char mapa[29][29], int &x, int &y ){
  119. switch ( rand2() ){
  120. case 0:
  121. go_izquierda( mapa, x, y );
  122. break;
  123. case 1:
  124. go_abajo( mapa, x, y );
  125. break;
  126. default:
  127. cout << "error:decide_izquierda_abajo"<<endl;
  128. cin.ignore();
  129. break;
  130. }
  131. }
  132. void decide_derecha_abajo ( char mapa[29][29], int &x, int &y ){
  133. switch ( rand2() ){
  134. case 0:
  135. go_derecha( mapa, x, y );
  136. break;
  137. case 1:
  138. go_abajo( mapa, x, y );
  139. break;
  140. default:
  141. cout << "error:decide_derecha_abajo"<<endl;
  142. cin.ignore();
  143. break;
  144. }
  145. }
  146. // DECIDE 3
  147. void decide_arriba_izquierda_derecha ( char mapa[29][29], int &x, int &y ){
  148. switch ( rand3() ){
  149. case 0:
  150. go_arriba( mapa, x, y );
  151. break;
  152. case 1:
  153. go_izquierda( mapa, x, y );
  154. break;
  155. case 2:
  156. go_derecha( mapa, x, y );
  157. break;
  158. default:
  159. cout << "error:decide_arriba_izquierda_derecha"<<endl;
  160. cin.ignore();
  161. break;
  162. }
  163. }
  164. void decide_arriba_izquierda_abajo ( char mapa[29][29], int &x, int &y ){
  165. switch ( rand3() ){
  166. case 0:
  167. go_arriba( mapa, x, y );
  168. break;
  169. case 1:
  170. go_izquierda( mapa, x, y );
  171. break;
  172. case 2:
  173. go_abajo( mapa, x, y );
  174. break;
  175. default:
  176. cout << "error:decide_arriba_izquierda_abajo"<<endl;
  177. cin.ignore();
  178. break;
  179. }  
  180. }
  181. void decide_arriba_derecha_abajo ( char mapa[29][29], int &x, int &y ){
  182. switch ( rand3() ){
  183. case 0:
  184. go_arriba( mapa, x, y );
  185. break;
  186. case 1:
  187. go_derecha( mapa, x, y );
  188. break;
  189. case 2:
  190. go_abajo( mapa, x, y );
  191. break;
  192. default:
  193. cout << "error:decide_arriba_derecha_abajo"<<endl;
  194. cin.ignore();
  195. break;
  196. }  
  197. }
  198. void decide_izquierda_derecha_abajo ( char mapa[29][29], int &x, int &y ){
  199. switch ( rand3() ){
  200. case 0:
  201. go_izquierda( mapa, x, y );
  202. break;
  203. case 1:
  204. go_derecha( mapa, x, y );
  205. break;
  206. case 2:
  207. go_abajo( mapa, x, y );
  208. break;
  209. default:
  210. cout << "error:decide_izquierda_derecha_abajo"<<endl;
  211. cin.ignore();
  212. break;
  213. }  
  214. }
  215. // DECIDE 4
  216. void decide_arriba_izquierda_derecha_abajo ( char mapa[29][29], int &x, int &y ){
  217. switch ( rand4() ){
  218. case 0:
  219. go_arriba( mapa, x, y );
  220. break;
  221. case 1:
  222. go_izquierda( mapa, x, y );
  223. break;
  224. case 2:
  225. go_derecha( mapa, x, y );
  226. break;
  227. case 3:
  228. go_abajo( mapa, x, y );
  229. break;
  230. default:
  231. cout << "error:decide_arriba_izquierda_derecha_abajo"<<endl;
  232. cin.ignore();
  233. break;
  234. }  
  235. }
  236. // ESPECIAL CASES
  237.  
  238. //MAIN_MAIN_MAIN_MAIN_MAIN_MAIN_MAIN_MAIN_MAIN_MAIN_MAIN_MAIN_MAIN_MAIN_MAINMAIN_MAIN_MAIN
  239. int main (){
  240.  
  241.  
  242.  
  243. //MAPA DE TIPO CHAR, MAS ADELANTE HACEMOS UN CAST PARA INT
  244. char mapa[29][29]={
  245.  
  246. "000000000000000000000000000",
  247. "0X0222222222222222222222220",
  248. "020200000000000000000000020",
  249. "020222222222222200000000020",
  250. "020200000000000000000000020",
  251. "020222222222222200022222220",
  252. "020000000000000200020000020",
  253. "020222222222200200000000020",
  254. "020200000000200222222222020",
  255. "020222222200200000000002020",
  256. "020000000200222222222222020",
  257. "022222220200000000000000020",
  258. "000000020200222222222222220",
  259. "000000022200200000000000000",
  260. "000000000000200222222222220",
  261. "022222222222200200000000020",
  262. "020000000000000222222202020",
  263. "020000000000000200000202020",
  264. "022222222222222200000202020",
  265. "000000000000000000000202220",
  266. "022222222222222222222200000",
  267. "020000000000000000000000000",
  268. "02222222222222222222222FIN0",
  269. "000000000000000000000000000"
  270.  
  271. };
  272.  
  273. //VARIABLES LOCALES
  274. int n;
  275. cout << "velocidad de busqueda?" << endl;
  276. cin >> n;
  277.  
  278. //POSICION INICIAL (CORRDENADAS)
  279. int x = 1;
  280. int y = 1;
  281.  
  282. //CONVERTIMOS EN INT LOS POCIBLES CAMINOS A TOMAR
  283. int arriba = (int (mapa [ y - 1] [ x ])-48);
  284. int izquierda = (int (mapa [ y ] [ x -1 ])-48);
  285. int derecha = (int (mapa [ y ] [ x + 1 ])-48);
  286. int abajo = (int (mapa [ y + 1] [ x ])-48);
  287.  
  288. //CONDICION DEL BUCLE PRINCIPAL: SI NO SE ENCUENTRA EL FIN DEL MAPA SIEMPRE SERA FALSO.
  289. bool fin = false;
  290.  
  291. //BUCLE PRINCIPAL: COMPRUEBA QUE NO ENCONTREMOS LA SALIDA.
  292. while ( !fin ){
  293.  
  294. //Valores de los pocibles caminos
  295. arriba = (int (mapa [ y - 1] [ x ]-48));
  296. izquierda = (int (mapa [ y ] [ x -1 ]-48));
  297. derecha = (int (mapa [ y ] [ x + 1 ]-48));
  298. abajo = (int (mapa [ y + 1] [ x ]-48));
  299.  
  300. //CASOS
  301. if ( arriba == 0 && izquierda == 0 && derecha == 0 && abajo == 0 ){//(0,0,0,0)*
  302. //NO SE elige NADA
  303. }
  304. if ( arriba == 0 && izquierda == 0 && derecha == 0 && abajo == 1 ){//(0,0,0,1)*
  305. //abajo
  306. go_abajo(mapa, x, y);
  307. }
  308. if ( arriba == 0 && izquierda == 0 && derecha == 0 && abajo == 2 ){//(0,0,0,2)*
  309. //abajo
  310. go_abajo(mapa, x, y);
  311. }
  312. if ( arriba == 0 && izquierda == 0 && derecha == 1 && abajo == 0 ) {//(0,0,1,0)*
  313. //derecha
  314. go_derecha(mapa, x, y);
  315. }
  316. if ( arriba == 0 && izquierda == 0 && derecha == 1 && abajo == 1 ){//(0,0,1,1)*
  317. //derecha || abajo
  318. decide_derecha_abajo ( mapa, x, y );
  319. }
  320. if ( arriba == 0 && izquierda == 0 && derecha == 1 && abajo == 2 ){//(0,0,1,2)*
  321. //abajo
  322. go_abajo(mapa, x, y);
  323. }
  324. if ( arriba == 0 && izquierda == 0 && derecha == 2 && abajo == 0 ){//(0,0,2,0)*
  325. //derecha
  326. go_derecha(mapa, x, y);
  327. }
  328. if ( arriba == 0 && izquierda == 0 && derecha == 2 && abajo == 1 ){//(0,0,2,1)*
  329. //derecha
  330. go_derecha(mapa, x, y);
  331. }
  332. if ( arriba == 0 && izquierda == 0 && derecha == 2 && abajo == 2 ){//(0,0,2,2)*
  333. //derecha || abajo
  334. decide_derecha_abajo ( mapa, x, y );
  335. }
  336. if ( arriba == 0 && izquierda == 1 && derecha == 0 && abajo == 0 ){//(0,1,0,0)*
  337. //izquierda
  338. go_izquierda(mapa, x, y);
  339. }
  340. if ( arriba == 0 && izquierda == 1 && derecha == 0 && abajo == 1 ){//(0,1,0,1)*
  341. //izquierda || abajo
  342. decide_izquierda_abajo ( mapa, x, y );
  343. }
  344. if ( arriba == 0 && izquierda == 1 && derecha == 0 && abajo == 2 ){//(0,1,0,2)*
  345. //abajo
  346. go_abajo(mapa, x, y);
  347. }
  348. if ( arriba == 0 && izquierda == 1 && derecha == 1 && abajo == 0 ){//(0,1,1,0)*
  349. //izquierda || derecha
  350. decide_izquierda_derecha ( mapa, x, y );
  351. }
  352. if ( arriba == 0 && izquierda == 1 && derecha == 1 && abajo == 1 ){//(0,1,1,1)*
  353. //izquierda || derecha || abajo
  354. decide_izquierda_derecha_abajo ( mapa, x, y );
  355. }
  356. if ( arriba == 0 && izquierda == 1 && derecha == 1 && abajo == 2 ){//(0,1,1,2)*
  357. //abajo
  358. go_abajo(mapa, x, y);
  359. }
  360. if ( arriba == 0 && izquierda == 1 && derecha == 2 && abajo == 0 ){//(0,1,2,0)*
  361. //derecha
  362. go_derecha(mapa, x, y);
  363. }
  364. if ( arriba == 0 && izquierda == 1 && derecha == 2 && abajo == 1 ){//(0,1,2,1)*
  365. //derecha
  366. go_derecha(mapa, x, y);
  367. }
  368. if ( arriba == 0 && izquierda == 1 && derecha == 2 && abajo == 2 ){//(0,1,2,2)*
  369. //derecha || abajo
  370. decide_derecha_abajo ( mapa, x, y );
  371. }
  372. if ( arriba == 0 && izquierda == 2 && derecha == 0 && abajo == 0 ){//(0,2,0,0)*
  373. //izquierda
  374. go_izquierda(mapa, x, y);
  375. }
  376. if ( arriba == 0 && izquierda == 2 && derecha == 0 && abajo == 1 ){//(0,2,0,1)*
  377. //izquierda
  378. go_izquierda(mapa, x, y);
  379. }
  380. if ( arriba == 0 && izquierda == 2 && derecha == 0 && abajo == 2 ){//(0,2,0,2)*
  381. //izquierda || abajo
  382. decide_izquierda_abajo ( mapa, x, y );
  383. }
  384. if ( arriba == 0 && izquierda == 2 && derecha == 1 && abajo == 0 ){//(0,2,1,0)*
  385. //izquierda
  386. go_izquierda(mapa, x, y);
  387. }
  388. if ( arriba == 0 && izquierda == 2 && derecha == 1 && abajo == 1 ){//(0,2,1,1)*
  389. //izquierda
  390. go_izquierda(mapa, x, y);
  391. }
  392. if ( arriba == 0 && izquierda == 2 && derecha == 1 && abajo == 2 ){//(0,2,1,2)*
  393. //izquierda || abajo
  394. decide_izquierda_abajo ( mapa, x, y );
  395. }
  396. if ( arriba == 0 && izquierda == 2 && derecha == 2 && abajo == 0 ){//(0,2,2,0)*
  397. //izquierda || derecha
  398. decide_izquierda_derecha ( mapa, x, y );
  399. }
  400. if ( arriba == 0 && izquierda == 2 && derecha == 2 && abajo == 1 ){//(0,2,2,1)*
  401. //izquierda || derecha
  402. decide_izquierda_derecha ( mapa, x, y );
  403. }
  404. if ( arriba == 0 && izquierda == 2 && derecha == 2 && abajo == 2 ){//(0,2,2,2)*
  405. //izquierda || derecha || abajo
  406. decide_izquierda_derecha_abajo ( mapa, x, y );
  407. }
  408. if ( arriba == 1 && izquierda == 0 && derecha == 0 && abajo == 0 ){//(1,0,0,0)*
  409. //arriba
  410. go_arriba(mapa, x, y);
  411. }
  412. if ( arriba == 1 && izquierda == 0 && derecha == 0 && abajo == 1 ){//(1,0,0,1)*ESPECIAL
  413. //arriba || abajo
  414. decide_arriba_abajo ( mapa, x, y );
  415. }
  416. if ( arriba == 1 && izquierda == 0 && derecha == 0 && abajo == 2 ){//(1,0,0,2)*
  417. //abajo
  418. go_abajo(mapa, x, y);
  419. }
  420. if ( arriba == 1 && izquierda == 0 && derecha == 1 && abajo == 0 ){//(1,0,1,0)*
  421. //arriba || derecha
  422. decide_arriba_derecha ( mapa, x, y );
  423. }
  424. if ( arriba == 1 && izquierda == 0 && derecha == 1 && abajo == 1 ){//(1,0,1,1)*
  425. //arriba || derecha || abajo
  426. decide_arriba_derecha_abajo ( mapa, x, y );
  427. }
  428. if ( arriba == 1 && izquierda == 0 && derecha == 1 && abajo == 2 ){//(1,0,1,2)*
  429. //abajo
  430. go_abajo(mapa, x, y);
  431. }
  432. if ( arriba == 1 && izquierda == 0 && derecha == 2 && abajo == 0 ){//(1,0,2,0)*
  433. //derecha
  434. go_derecha(mapa, x, y);
  435. }
  436. if ( arriba == 1 && izquierda == 0 && derecha == 2 && abajo == 1 ){//(1,0,2,1)*
  437. //derecha
  438. go_derecha(mapa, x, y);
  439. }
  440. if ( arriba == 1 && izquierda == 0 && derecha == 2 && abajo == 2 ){//(1,0,2,2)*
  441. //derecha || abajo
  442. decide_derecha_abajo ( mapa, x, y );
  443. }
  444. if ( arriba == 1 && izquierda == 1 && derecha == 0 && abajo == 0 ){//(1,1,0,0)*
  445. //arriba || izquierda
  446. decide_arriba_izquierda ( mapa, x, y );
  447. }
  448. if ( arriba == 1 && izquierda == 1 && derecha == 0 && abajo == 1 ){//(1,1,0,1)*
  449. //arriba || izquierda || abajo
  450. decide_arriba_izquierda_abajo ( mapa, x, y );
  451. }
  452. if ( arriba == 1 && izquierda == 1 && derecha == 0 && abajo == 2 ){//(1,1,0,2)*
  453. //abajo
  454. go_abajo(mapa, x, y);
  455. }
  456. if ( arriba == 1 && izquierda == 1 && derecha == 1 && abajo == 0 ){//(1,1,1,0)*
  457. //arriba || izquierda || derecha
  458. }
  459. if ( arriba == 1 && izquierda == 1 && derecha == 1 && abajo == 1 ){//(1,1,1,1)
  460. //arriba || izquierda || derecha || abajo
  461. decide_arriba_izquierda_derecha_abajo ( mapa, x, y );
  462. }
  463. if ( arriba == 1 && izquierda == 1 && derecha == 1 && abajo == 2 ){//(1,1,1,2)*
  464. //abajo
  465. go_abajo(mapa, x, y);
  466. }
  467. if ( arriba == 1 && izquierda == 1 && derecha == 2 && abajo == 0 ){//(1,1,2,0)*
  468. //derecha
  469. go_derecha(mapa, x, y);
  470. }
  471. if ( arriba == 1 && izquierda == 1 && derecha == 2 && abajo == 1 ){//(1,1,2,1)*
  472. //derecha
  473. go_derecha(mapa, x, y);
  474. }
  475. if ( arriba == 1 && izquierda == 1 && derecha == 2 && abajo == 2 ){//(1,1,2,2)*
  476. //derecha || abajo
  477. decide_derecha_abajo ( mapa, x, y );
  478. }
  479. if ( arriba == 1 && izquierda == 2 && derecha == 0 && abajo == 0 ){//(1,2,0,0)*
  480. //izquierda
  481. go_izquierda(mapa, x, y);
  482. }
  483. if ( arriba == 1 && izquierda == 2 && derecha == 0 && abajo == 1 ){//(1,2,0,1)*
  484. //izquierda
  485. go_izquierda(mapa, x, y);
  486. }
  487. if ( arriba == 1 && izquierda == 2 && derecha == 0 && abajo == 2 ){//(1,2,0,2)*
  488. //izquierda || abajo
  489. decide_izquierda_abajo ( mapa, x, y );
  490. }
  491. if ( arriba == 1 && izquierda == 2 && derecha == 1 && abajo == 0 ){//(1,2,1,0)*
  492. //izquierda
  493. go_izquierda(mapa, x, y);
  494. }
  495. if ( arriba == 1 && izquierda == 2 && derecha == 1 && abajo == 1 ){//(1,2,1,1)*
  496. //izquierda
  497. go_izquierda(mapa, x, y);
  498. }
  499. if ( arriba == 1 && izquierda == 2 && derecha == 1 && abajo == 2 ){//(1,2,1,2)*
  500. //izquierda || abajo
  501. decide_izquierda_abajo ( mapa, x, y );
  502. }
  503. if ( arriba == 1 && izquierda == 2 && derecha == 2 && abajo == 0 ){//(1,2,2,0)*
  504. //izquierda || derecha
  505. decide_izquierda_derecha ( mapa, x, y );
  506. }
  507. if ( arriba == 1 && izquierda == 2 && derecha == 2 && abajo == 1 ){//(1,2,2,1)*
  508. //izquierda || derecha
  509. decide_izquierda_derecha ( mapa, x, y );
  510. }
  511. if ( arriba == 1 && izquierda == 2 && derecha == 2 && abajo == 2 ){//(1,2,2,2)
  512. //izquierda || derecha || abajo
  513. decide_izquierda_derecha_abajo ( mapa, x, y );
  514. }
  515. if ( arriba == 2 && izquierda == 0 && derecha == 0 && abajo == 0 ){//(2,0,0,0)
  516. //arriba
  517. go_arriba(mapa, x, y);
  518. }
  519. if ( arriba == 2 && izquierda == 0 && derecha == 0 && abajo == 1 ){//(2,0,0,1)
  520. //arriba
  521. go_arriba(mapa, x, y);
  522. }
  523. if ( arriba == 2 && izquierda == 0 && derecha == 0 && abajo == 2 ){//(2,0,0,2)
  524. //arriba || abajo
  525. decide_arriba_abajo ( mapa, x, y );
  526. }
  527. if ( arriba == 2 && izquierda == 0 && derecha == 1 && abajo == 0 ){//(2,0,1,0)
  528. //arriba
  529. go_arriba(mapa, x, y);
  530. }
  531. if ( arriba == 2 && izquierda == 0 && derecha == 1 && abajo == 1 ){//(2,0,1,1)
  532. //arriba
  533. go_arriba(mapa, x, y);
  534. }
  535. if ( arriba == 2 && izquierda == 0 && derecha == 1 && abajo == 2 ){//(2,0,1,2)
  536. //arriba || abajo
  537. decide_arriba_abajo ( mapa, x, y );
  538. }
  539. if ( arriba == 2 && izquierda == 0 && derecha == 2 && abajo == 0 ){//(2,0,2,0)
  540. //arriba || derecha
  541. decide_arriba_derecha ( mapa, x, y );
  542. }
  543. if ( arriba == 2 && izquierda == 0 && derecha == 2 && abajo == 1 ){//(2,0,2,1)
  544. //arriba || derecha
  545. decide_arriba_derecha ( mapa, x, y );
  546. }
  547. if ( arriba == 2 && izquierda == 0 && derecha == 2 && abajo == 2 ){//(2,0,2,2)
  548. //arriba || derecha || abajo
  549. decide_arriba_derecha_abajo ( mapa, x, y );
  550. }
  551. if ( arriba == 2 && izquierda == 1 && derecha == 0 && abajo == 0 ){//(2,1,0,0)
  552. //arriba
  553. go_arriba(mapa, x, y);
  554. }
  555. if ( arriba == 2 && izquierda == 1 && derecha == 0 && abajo == 1 ){//(2,1,0,1)
  556. //arriba
  557. go_arriba(mapa, x, y);
  558. }
  559. if ( arriba == 2 && izquierda == 1 && derecha == 0 && abajo == 2 ){//(2,1,0,2)
  560. //arriba || abajo
  561. decide_arriba_abajo ( mapa, x, y );
  562. }
  563. if ( arriba == 2 && izquierda == 1 && derecha == 1 && abajo == 0 ){//(2,1,1,0)
  564. //arriba
  565. go_arriba(mapa, x, y);
  566. }
  567. if ( arriba == 2 && izquierda == 1 && derecha == 1 && abajo == 1 ){//(2,1,1,1)
  568. //arriba
  569. go_arriba(mapa, x, y);
  570. }
  571. if ( arriba == 2 && izquierda == 1 && derecha == 1 && abajo == 2 ){//(2,1,1,2)
  572. //arriba || abajo
  573. decide_arriba_abajo ( mapa, x, y );
  574. }
  575. if ( arriba == 2 && izquierda == 1 && derecha == 2 && abajo == 0 ){//(2,1,2,0)
  576. //arriba || derecha
  577. decide_arriba_derecha ( mapa, x, y );
  578. }
  579. if ( arriba == 2 && izquierda == 1 && derecha == 2 && abajo == 1 ){//(2,1,2,1)
  580. //arriba || derecha
  581. decide_arriba_derecha ( mapa, x, y );
  582. }
  583. if ( arriba == 2 && izquierda == 1 && derecha == 2 && abajo == 2 ){//(2,1,2,2)
  584. //arriba || derecha || abajo
  585. decide_arriba_derecha_abajo ( mapa, x, y );
  586. }
  587. if ( arriba == 2 && izquierda == 2 && derecha == 0 && abajo == 0 ){//(2,2,0,0)
  588. //arriba || izquierda
  589. decide_arriba_izquierda ( mapa, x, y );
  590. }
  591. if ( arriba == 2 && izquierda == 2 && derecha == 0 && abajo == 1 ){//(2,2,0,1)
  592. //arriba || izquierda
  593. decide_arriba_izquierda ( mapa, x, y );
  594. }
  595. if ( arriba == 2 && izquierda == 2 && derecha == 0 && abajo == 0 ){//(2,2,0,0)
  596. //arriba || izquierda
  597. decide_arriba_izquierda ( mapa, x, y );
  598. }
  599. if ( arriba == 2 && izquierda == 2 && derecha == 0 && abajo == 2 ){//(2,2,0,2)
  600. //arriba || izquierda || abajo
  601. decide_arriba_izquierda_abajo ( mapa, x, y );
  602. }
  603. if ( arriba == 2 && izquierda == 2 && derecha == 1 && abajo == 0 ){//(2,2,1,0)
  604. //arriba || izquierda
  605. decide_arriba_izquierda ( mapa, x, y );
  606. }
  607. if ( arriba == 2 && izquierda == 2 && derecha == 1 && abajo == 1 ){//(2,2,1,1)
  608. //arriba || izquierda
  609. decide_arriba_izquierda ( mapa, x, y );
  610. }
  611. if ( arriba == 2 && izquierda == 2 && derecha == 1 && abajo == 2 ){//(2,2,1,2)
  612. //arriba || izquierda || abajo
  613. decide_arriba_izquierda_abajo ( mapa, x, y );
  614. }
  615. if ( arriba == 2 && izquierda == 2 && derecha == 2 && abajo == 0 ){//(2,2,2,0)
  616. //arriba || izquierda || derecha
  617. decide_arriba_izquierda_derecha ( mapa, x, y );
  618. }
  619. if ( arriba == 2 && izquierda == 2 && derecha == 2 && abajo == 1 ){//(2,2,2,1)
  620. //arriba || izquierda || derecha
  621. decide_arriba_izquierda_derecha ( mapa, x, y );
  622. }
  623. if ( arriba == 2 && izquierda == 2 && derecha == 2 && abajo == 2 ){//(2,2,2,2)
  624. //arriba || izquierda || derecha || abajo
  625. decide_arriba_izquierda_derecha_abajo ( mapa, x, y );
  626. }
  627.  
  628.  
  629.  
  630.  
  631. // ON SCREEN PRINT
  632. mostrar (mapa);
  633. Sleep(n);
  634. //system("pause");
  635. }
  636.  
  637.  
  638. return 0;
  639. }
  640.  

Esta echo en dev cpp orwell
Pronto subo la 2.0 o mejor lo mejoren vosotros si quieren  ;-)

Se debe de poner 0 en los bordes o puede ser bug :D
La X va buscando el 2, si no hay remedio busca 1 y el 0 es como pared.
Debe tener 0 en todo el lado externo.
Tomar el 0 como pared y rodear todo el mapa.


Título: Re: Ayuda con programa urgente!
Publicado por: ivancea96 en 16 Diciembre 2013, 19:04 pm
Perdona, que diga algo: Todos esos "if" los podrías cambiar por 1 único if dentro de un bucle de 4 "for". No se que algoritmo usaste, pero bueno, evitar hacer ese tipo de "copy&paste" es mejor. especialmente para la vista.


Título: Re: Ayuda con programa urgente!
Publicado por: vangodp en 16 Diciembre 2013, 19:38 pm
Puedes ser amable de decir como valido cada caso con 4 for?
Soy todo oídos :D
El algoritmo es la casualidad.
la posición actual de la x mira arriba, abajo, izquierda y derecha buscando el mejor camino.
Primero busca el numero 2 que se supone ser no explorado, el 1 es que ya ha estado ahí y 0 no lo puede atravesar(pared).
Si no hay remedio pasa por el uno otra vez pero prefiere el 2.
Hasta llegar al final que aun no esta echo.
Pretendo mejorarlo pero un novato lo tiene muy limitado como yo.
Lo voy mejorando como para leer el mapa desde un archivo.
No perder mucho tiempo en salir de un camino ya explorado.
A ver si lo paso a SDL que me mola. :D
Si encuentra 2 o mas caminos iguales elige al azar, por eso cuando entra en una calle sin salida se vuelve algo lento, tengo que hacer que al llegar al final recuerde el camino o lo que sea.


Título: Re: Ayuda con programa urgente!
Publicado por: ivancea96 en 16 Diciembre 2013, 20:22 pm
Código
  1. int a[4] = {arriba, izquierda, derecha, abajo};
  2. void (*f[])() = {go_arriba, go_izquierda, go_derecha, go_abajo};
  3. if(a[0] + a[1] + a[2] + a[3] > 0){
  4. int primos = {2, 3, 5, 7};
  5. int mayor=0;
  6. int temp=1;
  7. int cont=1;
  8. for(int i=0;i<4;i++)
  9.    if(a[i] > mayor){mayor=a[i];temp=primos[i];} //Miramos cual es el mayor
  10. for(int i=0; i<4; i++)
  11.    if(temp%primos[i]!=0 && a[i]==mayor){temp*=primos[i]; ++cont;} //Miramos cuales son iguales al mayor
  12. switch(cont){
  13.    case 1: for(int i=0;i<4;i++) if(temp%primos[i] == 0){(*f[i])();break;}break;
  14.    case 2: //Aqui sería ver cuales son los elegidos, y elegir al azar cual usar.
  15.    case 3: //idem
  16. }
  17. }

En fin, no se si tengo algún fallo por ahí. De ser así, y si te gusta el algoritmo, puedes corregirlo. Te dejo para, si lo usases, lo continues tú jaja

EDITO: Los 4 for eran una posibilidad, pero preferí esa, que me pareció más rápida.


Título: Re: Ayuda con programa urgente!
Publicado por: vangodp en 16 Diciembre 2013, 20:56 pm
Lo voy echar un ojo ;)
Gracias, a ver si lo achicamos :D


Título: Re: Ayuda con programa urgente!
Publicado por: vangodp en 17 Diciembre 2013, 08:38 am

Hola ivan, hola a todos.
Tengo una duda.
¿Que hace esta linea?
void (*f[])() = {go_arriba, go_izquierda, go_derecha, go_abajo};
Algunas cosas me son algo confusas por la inesperiencia que tengo?
Si no puedes explicarme al menos dime de que se trata y ya lo investigo por mi cuenta :D
Suerte!


Título: Re: Ayuda con programa urgente!
Publicado por: ivancea96 en 17 Diciembre 2013, 15:14 pm
Código
  1. void (*f[])() = {go_arriba, go_izquierda, go_derecha, go_abajo};

Para poder ordenar, metí todas las funciones en un array de funciones.
Cuando se pone algo como:
Código
  1. char (*ptrchar) (int);
  2. ptrchar = prueba;
  3. char prueba(int a){ //pasar funcion como parametro
  4.    return (char)a;

ptrchar es un puntero a una función char. ¿Qué variables recibe sa función? "char (*ptrchar) (int);". En vez de int, podríamos poner (char, int[]), por ejemplo. En fin.

Es la primera vez que uso en la práctica lo de puntero a funciones, así que no se si irá bien del todo jaja. Pero puedes echarle un vistazo :o


Título: Re: Ayuda con programa urgente!
Publicado por: leosansan en 20 Diciembre 2013, 11:54 am
¡Pedazo de código!

;-) ;-) ;-) ;-) ;-) ;-) ;-) ;-) ;-) ;-)

UUUUFFFFFFFFFFFFF !!!!!!!!!!!!!.................... tanto trabajo merece la pena que se cite entero por largo que sea. Enhora buena por  tu paciencia para desarrollar semejante pedazo de código. ¿De dónde sacas tanto tiempo y ánimos?. Yo cuando voy por la línea 100 ya me parece que me paso  :o

Pero vamos por partes. Te cito


Eh mejorado un poco el código :D
Lo eh echo auto suficiente jaja
Este se busca la salida solo XD
Puedes cambiar el mapa a gusto.
Es algo ineficiente aun, lo estoy puliendo cosillas como cuando encuentra una calle sin salida, le tarda algo en volver al camino, pero lo encuentra.


Lo de mejorar supongo que no te referías al código que postee anteriormente. Estaba desarrollado para un laberinto concreto que puso el autor del tema y hacía lo que se le pedía: buscar la salida y la encontraba.  :silbar: :silbar:

Lo de ineficiente lo dices tú, yo soy demasiado pardillo aún en este mundillo para poner calificativos y mucho menos despectivos. Lo que no dejo de alabar es tu curro con el dichoso código.

Lo de que encuentra una salida no me parece. Lo tuve corriendo varios, pero varios, minutos y nada de nada. Fijándome un poco observe que el laberinto que propones en tu código no tiene solución: es un callejón sin salida, al menos yo la busque a simple vista y ningún camino conducía a la salida.

Tarda, pero tarda un *uevo no ya en salir, sino en moverse hacia alguna dirección concreta. Yo diría que más que buscar la salida, deambula sin tino concreto.


Esta echo en dev cpp orwell
Pronto subo la 2.0 o mejor lo mejoren vosotros si quieren  ;-)
Se debe de poner 0 en los bordes o puede ser bug :D

Dichosita manía con el DevC++, por muy Orwell que sea y no es por que no lo haya probado, que sí que lo he hecho, pero con lo chulo que es el Code::Blocks.
:rolleyes:

Espero que no cunda el desánimo, a mí me suele  ocurrir xD, y te animes a por una versión más depurada.

Y, en tu caso, lo del bug si no hay ceros en los bordes es porque los índices de la matriz que usas se sobrepasarían. Haz la prueba y veras que el mensaje que manda el programa es el de índices fuera de rango. Ello se debe a las condiciones que pones en los caminos lleva más allá del rango permitido, que ya de por sí es excesivo.

Conste que todo lo que te planteo amigo vangodp es con el mayor de los respetos y cariño hacía tí y hacía el curro que te has pegado.

Y ahora respecto al código un par de observaciones:

* Las dimensiones de la matriz no se corresponden con su tamaño. Una cosa es que pongas ceros, yo también lo hago, ya te comentaré, y otra es que trates de evitar un error lógico del código con esa artimaña.

* Creo sinceramente que consideras demasiadas opciones, o mejor dicho, las desmenuzas en demasía, lo que da origen a una cantidad interminable de "if". No paro de repetirlo, lo sé, pero te has pegado un curro de cuidado. Por un lado el obtener todas esas posibilidades y luego la paciencia de plasmarlo o escribirlo. Este es mi post más largo y ya estoy cansado, con lo que me imagino que tú no veas.

* Algo que no me termina de convencer es el uso de la aleatoriedad para elegir los movimientos, porque ello conduce a una secuencia casi interminable de pasos: tan  pronto da dos pasitos a la derecha como tres a la izquierda, sube tres y baja cuatro, etc. La consecuencia de esa aleatoriedad es que hace intervenir a la Estadística y ésta nos confirma que más bien irá rondando de forma continua cada nueva posición, lo que hace muy ineficiente el método.

Todo ello me ha animado a intentar, ya te comenté que soy muy nuevo en este mundillo, un método alternativo sin aleatorios y teniendo en cuenta que sólo hay cuatro posibles movimientos -ABAJO:DERECHA_ARRIBA_IZQUIERDA-, en ese orden de preferencia ya que partimos de que la salida está en la parte superior izquierda y la llegada en la inferior derecha, por lo que lo razonable es dar preferencia a los movimientos hacia abajo y a la derecha, respecto a los de hacia arriba y a la izquierda ya que estos últimos, así de entrada, tienden a alejarnos del objetivo. Ello no quiere decir que no los use ya que son necesarios  para caminar hacia atrás en caso de encerrona. Eso sí, no son movimientos al azar ni por capricho. Lo que hago es comparar cada posible movimiento hacia una posición con los otros tres posibles y camino hacia el de menor valor.

¿Hacia el de menor valor?. Pues sí, porque yo uso una segunda matriz numérica y cada pasito que doy incremento el valor del elemento de la matriz, y así voy buscando continuamente los de menos valor.

Y ya está bien de rollo y para botón una muestra de solución al laberinto que planteaste, con alguna pequeña modificación para que tuviera solución:


Citar


                Movimientos = 168

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 I 2 X X X X X X X X X X X X X X X X X X X X X X X 0
0 X 0 X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 X 0
0 X 0 X X X X X X X X X X X X X 0 0 0 0 0 0 0 0 0 X 0
0 X 0 X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 X 0
0 X 0 X X X X X X X X X X X X X 0 0 0 2 2 2 2 2 2 X 0
0 X 0 0 0 0 0 0 0 0 0 0 0 0 0 X 0 0 0 2 0 0 0 0 0 X 0
0 X 0 X X X X X X X X X X 0 0 X 0 0 0 0 0 0 0 0 0 X 0
0 X 0 X 0 0 0 0 0 0 0 0 X 0 0 X X X X X X X X X 0 X 0
0 X 0 X X X X X X X 0 0 X 0 0 0 0 0 0 0 0 0 0 X 0 X 0
0 X 0 0 0 0 0 0 0 X 0 0 X X X X X X X X X X X X 0 X 0
0 X X X X X X X 0 X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 X 0
0 0 0 0 0 0 0 X 0 X 0 0 2 2 2 2 2 2 2 2 2 2 2 2 2 X 0
0 0 0 0 0 0 0 X X X 0 0 2 0 0 0 0 0 0 0 0 0 0 0 0 X 0
0 0 0 0 0 0 0 0 0 0 0 0 2 0 0 2 2 2 2 2 2 2 2 2 2 X 0
0 2 2 2 2 2 2 2 2 2 2 2 2 0 0 2 0 0 0 0 0 0 0 0 0 X 0
0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 2 2 2 2 2 2 2 0 X 0 X 0
0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 2 0 X 0 X 0
0 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 0 0 0 0 0 2 0 X 0 X 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 X X X X X 0
0 2 0 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 X 0 0 0 0 0
0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 X X X X X 0
0 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 X X 0 0 F 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Presione una tecla para continuar . . .

Process returned 0 (0x0)   execution time : 0.586 s


Observa que de de I y llega a F.

Y el  código que me van a comer y con algunas explicaciones incluidas:


Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. void mostrar_b(int b[][27]);
  5. void mostrar(char a[][28]);
  6.  
  7. int main (){
  8.    char a[24][28]={
  9.    "000000000000000000000000000",
  10.    "012222222222222222222222220",
  11.    "020200000000000000000000020",
  12.    "020222222222222200000000020",
  13.    "020200000000000000000000020",
  14.    "020222222222222200022222220",
  15.    "020000000000000200020000020",
  16.    "020222222222200200000000020",
  17.    "020200000000200222222222020",
  18.    "020222222200200000000002020",
  19.    "020000000200222222222222020",
  20.    "022222220200000000000000020",
  21.    "000000020200222222222222220",
  22.    "000000022200200000000000020",
  23.    "000000000000200222222222220",
  24.    "022222222222200200000000020",
  25.    "020000000000000222222202020",
  26.    "020000000000000200000202020",
  27.    "022222222222222200000202020",
  28.    "000000000000000200000222220",
  29.    "020222222222222222222200000",
  30.    "020000000000000000000222220",
  31.    "022222222222222222222220010",
  32.    "000000000000000000000000000"
  33.    };
  34.    int i,j,cont=0;
  35.     int b[24][27];
  36.        for( i=0;i<24;i++) {
  37.            for( j=0;j<27;j++) {
  38.                b[i][j]=(int)(a[i][j]-48);
  39.                if (b[i][j]==0)
  40.                    b[i][j]=9;
  41.        }
  42.    }
  43.    i=1,j=1;
  44.    b[1][1]=3;
  45.    a[i][j]='I';
  46.    //mostrar_b(b);//activalo para ver como se rellena la matriz de numeros
  47.    mostrar (a);
  48.    system ("cls");
  49.    while (1){
  50. //De los cuatro que rodean al b[i][j] tomo uno y comparo los otros tres
  51.        if     (i+1<24 && b[i+1][j]>0 && b[i+1][j]<=b[i-1][j]
  52.                  && b[i+1][j]<=b[i][j-1] && b[i+1][j]<=b[i][j+1]){
  53.                a[i+1][j]='X';     //   en esta condicion
  54.                if (b[i+1][j]==1){ //elijo  hacua ABAJO si es menor o igual
  55.                    a[i+1][j]='F'; //que los otros tres que rodean a b[i][j]
  56.                    break;
  57.                }
  58.                b[i+1][j]++;
  59.                i++;
  60.        }
  61.        else if (j+1<27 && b[i][j+1]>0 && b[i][j+1]<=b[i][j-1]
  62.                  && b[i][j+1]<=b[i-1][j] && b[i][j+1]<=b[i+1][j]){
  63.                a[i][j+1]='X';     //    en esta condicion
  64.                if (b[i][j+1]==1){ //elijo  hacia la DERECHA si es menor o igual
  65.                    a[i][j+1]='F'; //que los otros tres que rodean a b[i][j]
  66.                    break;
  67.                }
  68.                b[i][j+1]++;
  69.                j++;
  70.        }
  71.        else if (i-1>=0 && b[i-1][j]>0 && b[i-1][j]<=b[i+1][j]
  72.                  && b[i-1][j]<=b[i][j-1] && b[i-1][j]<=b[i][j+1]){
  73.                a[i-1][j]='X';     //    en esta condicion
  74.                if (b[i-1][j]==1){ //elijo  hacia la ARRIBA si es menor o igual
  75.                    a[i-1][j]='F'; //que los otros tres que rodean a b[i][j]
  76.                    break;
  77.                }
  78.                b[i-1][j]++;
  79.                i--;
  80.        }
  81.        else if (j-1>0 && b[i][j-1]>0 && b[i][j-1]<=b[i][j+1]
  82.                  && b[i][j-1]<=b[i-1][j] && b[i][j-1]<=b[i+1][j]){
  83.                a[i][j-1]='X';     //    en esta condicion
  84.                if (b[i][j-1]==1){ //elijo  hacia la IZQUIERDA si es menor o igual
  85.                    a[i][j-1]='F';  //que los otros tres que rodean a b[i][j]
  86.                    break;
  87.                }
  88.                b[i][j-1]++;
  89.                if (j-1>0){
  90.                j--;
  91.                }
  92.        }
  93.        //mostrar_b( b);//activalo para ver como se rellena la matriz de numeros
  94.        cont++;//
  95.    }
  96.    printf ("\n\n\t\tMovimientos = %d\n\n",cont);
  97.    mostrar_b(b);//activalo para ver como queda al fimal la matriz de numeros
  98.    mostrar(a);
  99.    return 0;
  100. }
  101.  
  102. void mostrar_b(int b[][27]){
  103.    system ("cls");
  104.    int i,j;
  105.    for( i=0;i<24;i++) {
  106.        for( j=0;j<27;j++) {
  107.            printf("%d ",b[i][j]);
  108.            fflush(stdout);
  109.        }
  110.        puts("");
  111.    }
  112.    system ("pause");
  113. }
  114.  
  115. void mostrar(char a[][28]){
  116.    system ("cls");
  117.    int i,j;
  118.    for( i=0;i<24;i++) {
  119.        for( j=0;j<27;j++) {
  120.            printf("%c ",a[i][j]);
  121.            fflush(stdout);
  122.        }
  123.        puts("");
  124.    }
  125.    puts("");
  126.    system ("pause");
  127. }
  128.  

Mis observaciones respecto al mismo:

* Está poco testeado, apenas una decena de variantes sobre ese laberinto.

* Queda por pulir la presentación final a fin de que sólo salga el camino directo y no los delante y atrás de cuando se queda rodeado por una muralla. Por cierto, observa que aunque eso ocurra saldrá de la misma el solito  ;-) ;-)

* Los cuatro casos son muy semejantes por lo que pienso que podría reducirse el código con una función. Aunque para lo corto que es no se si merece la pena.

* La idea propuesta es la más cortita respecto a otras soluciones que hacían lo mismo pero con más código, incluso me planteo el uso de una sola función para  ambas matrices.

Espero no haberla pifiado demasiado . :silbar: :silbar:

Como he dicho, estoy aún en pañales así que serán bienvenidas correcciones, observaciones y sugerencias y, ¿por qué no?, espero ansiosamente que alguien más haga aportaciones con códigos seguramente mucho más eficientes e ingeniosos que el mío. Se me ocurre con recursividad y esas cosas.

Y ya está. UUUFFFFF....... menudo rollo les he metido.Sorry, nada como tener un ratito de tiempo libre.
:laugh: :laugh:

P.D: Se pueden tener más soluciones cambiando el orden de los if y eslse  .

Saluditos! ..... !!!!        (http://st.forocoches.com/foro/images/smilies/aaaaa.gif)


Título: Re: Ayuda con programa urgente!
Publicado por: vangodp en 20 Diciembre 2013, 14:24 pm
Bueno lo de depurar el código na que decir, por que la razón tiene quien la tiene jaja.
Estoy seguro que el código se puede mejorar, incluyendo el tuyo como bien lo comentas y creo que en su día también lo hice ¡Creo! XD
Al final dejas señalado lo que podías haber mejorado pero no lo has echo por que no te salio lo mismo me pasa jaja. XD
Lo del aleatorio no abro mano XDD. Si no, no seria una búsqueda es mas como una trampa saber el camino ¿no?
Se supone que no sabes el camino, y si llegas a un punto con 3 o mas elecciones¿Que harás, vas hacia el final?  :laugh:
Estoy de acuerdo contigo sobre que cuando entra en un punto sin salida el se queda perdido por lo que comentas.Pero eso tiene solucion ¡Creame!XD
Lo del final si podías ver que no lo hice pero te lo pongo aquí ya que no dejas pasar una XD:

Código
  1. if( mapa[y][x] == 'F' ){
  2. cout << "TACHANNNN!!!!XDLOLOL";
  3. break;
  4. }

Sobre lo del camino sin salida bien puede ser que si al llegar al final y no encuentra nada, lo rellene con ceros envés de unos, marcando así que ese camino no pueda volver a entrar. XDD

Son fallos tontos los que me estas señalando se lo dije que deje muchas cosas por hacer jeje
La cosa es que por no seguir deje mucho que hacer pero bueno :rolleyes:
No voy a comentar tu código (¡aun!)por que no lo vi, pero lo mirare con lupa jeje.
Sobre el Dev estoy seguro que hay un millón de compiladores mejor, esta el vim vs emacs de toda la vida y un millón de ellos mas y no creas que no los probé todos jaja.
Pero seguiré con el Dev por que me parece muy muy sencillo y me va bien no me gusta que me de chuletas los programas XD.
Me costo como que 2 días hacer este código, no digo escribiéndole ya que eso me tardo unas 3 o 4 horas XD.
Voy a subir una nueva versión con esos problemas arreglados,  por supuesto tendré tu código en cuenta...si puedo aprender algo seguro lo haré ademas pinta muy bien.
Seguro que podemos afinar ese laberinto y hacerle que encuentre la salida muy rápidamente :D
¡Gracias por comentar, eres grande! ;)


Título: Re: Ayuda con programa urgente!
Publicado por: leosansan en 20 Diciembre 2013, 15:55 pm

¡Gracias por comentar, eres grande! ;)


De eso nada, un aficionadillo simplemente. Estoy seguro que en conocimientos del lenguaje me ganas sobrado. En ese aspecto siento envidia sana de rir3760. ¡Que tío más grande!, ese si que domina el C/C++ hasta decir basta. Si no fuera porque ya soy mayor diría aquello que de mayor quiero ser como él.

Pero otra cosa es el ingenio para que afloren ideas simples a problemas aparentemente complicados, como el caso que nos ocupa. Lástima que no se anime mas gente y que aporten nuevas ideas o caminos.


..................................................................
Lo del aleatorio no abro mano XDD. Si no, no seria una búsqueda es mas como una trampa saber el camino ¿no?
Se supone que no sabes el camino, y si llegas a un punto con 3 o mas elecciones¿Que harás, vas hacia el final?  :laugh:
...........................................

Ahí estás lo bueno de mi último código. No parto de un camino predeterminado,sino que voy eligiendo en cada posición la óptima, es más si te fijas en la solución que aporto veras que en uno de los caminos que sigue la X llega a un callejón donde delante arriba y abajo está bloqueada y ¡ voilâ ! se da la vuelta y retrocede sobre sus propios pasos buscando un nuevo camino:

Citar
0 X 0 X 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 X 0 X X X X X X X X X X X X X 0 0 0   <===aki retrocede y luego sube
0 X 0 X 0 0 0 0 0 0 0 0 0 0 0 0 0

 ¿Y como lo hago?. Con lo que ya te comenté de usar a la vez otra matriz con números que según vas pasando por las casillas se incrementan, de manera que en cada movimiento voy seleccionando la posición mas favorable  ;-) ;-) ;-) ¡¡¡ Como me quiero!!!  >:D >:D >:D

Para ver mejor el cómo funciona, activa las líneas del código que te deje marcadas y veras la forma en  que actúa la matriz de números y como se seccionan las casillas. Lo dejé expresamente para ti, ya que supuse te interesaría el tema.

Un fuerte abrazo y Felices Navidades.


Saluditos! ..... !!!!        (http://st.forocoches.com/foro/images/smilies/aaaaa.gif)


Título: Re: Ayuda con programa urgente!
Publicado por: vangodp en 20 Diciembre 2013, 17:01 pm
ok! lo prometo que le echare un ojo. $_$  :P
Pero lo hare con tiempo y detenidamente :D
Y no soy mejor ni mas grande que nadie, creo que 2 mejor que uno :DD
Lo de hacer que aprenda sobre la marcha esta muy bien :D
Otra cosa seria hacer que si reconoce el camino no vuelva a tomar el camino equivocado, eso seria una pasada. XDD
Pronto abriremos una empresa de IA y haremos armas para el ejercito jajaj
Me aguarde :DD
¡Saludos!
    .....CONTINUARA... XD

http://www.youtube.com/watch?v=_FMzr46JZhE (http://www.youtube.com/watch?v=_FMzr46JZhE)


Título: Re: Ayuda con programa urgente!
Publicado por: leosansan en 20 Diciembre 2013, 18:03 pm
ok! lo prometo que le echare un ojo. $_$  :P
.......................................................................
Otra cosa seria hacer que si reconoce el camino no vuelva a tomar el camino equivocado, eso seria una pasada. XDD
..................................................................


Pues es justamente lo que hace el programa. Ejecútalo y lo veras, pero no te olvides de activar las líneas de código que están  desactivadas para verlo. Las desactivo porque una vez comprobado que todo funciona, o al menos eso parece, vaya como un tiro. Recuerda el tiempo de ejecución en hallar el camino de salida y eso a pesar de que recula en un par de ocasiones:

Citar

Process returned 0 (0x0)   execution time : 0.586 s


No está nada mal para un aficionado.

(http://i1280.photobucket.com/albums/a497/leosansan/NAVIDAD/Emoticones-de-Navidad-20_zps3c85e0b5.gif)   Felices Navidades y Próspero Año Nuevo.    (http://i1280.photobucket.com/albums/a497/leosansan/NAVIDAD/Emoticones-de-Navidad-20_zps3c85e0b5.gif)

Saluditos! ..... !!!!

(http://st.forocoches.com/foro/images/smilies/aaaaa.gif)

 


Título: Re: Ayuda con programa urgente!
Publicado por: vangodp en 20 Diciembre 2013, 20:35 pm
con cual programa as compilado?Ya que se que no usas Dev XDD


Título: Re: Ayuda con programa urgente!
Publicado por: leosansan en 20 Diciembre 2013, 21:45 pm
con cual programa as compilado?Ya que se que no usas Dev XDD

Code::Blocks

Y una imagen de prueba de que furula bien:

(http://i1280.photobucket.com/albums/a497/leosansan/GRAFICOS1/laberinto_zps25515fe2.jpg)


Felices Navidades y Próspero Año Nuevo.

Saluditos! ..... !!!!

(http://st.forocoches.com/foro/images/smilies/aaaaa.gif)


Título: Re: Ayuda con programa urgente!
Publicado por: leosansan en 29 Diciembre 2013, 15:51 pm
Perdonen que reviva el tema, pero la aportación es diferente.

Por un lado un código que no resuelve directamente el laberinto, pero permitir "ver" los caminos de salida al estar el laberinto "coloreado". Como ejemplo, a mi nietillo le encanta buscar las soluciones y como es muy fácil cambiar el laberinto, cada vez que quiere jugar tiene   un laberinto diferente.

Y de muestra un pantallazo:


(http://i1280.photobucket.com/albums/a497/leosansan/GRAFICOS1/laberintosinmas_zpsb0628ec6.jpg)

Sí ya lo sé, no resuelve nada pero permite a simple vista localizar los caminos de salida. Es como un juego, repito.

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4. #include <windows.h>
  5.  
  6. void mostrar(char a[][28],char *msg);
  7. void color (int n)
  8.  
  9. int main (){
  10.  
  11.    char a[24][28]={
  12.    "000000000000000000000000000",
  13.    "012222222222222222222222220",
  14.    "022020200020002000000000020",
  15.    "022202022020202000000000020",
  16.    "020000000020202000000000020",
  17.    "020222220020220200022222220",
  18.    "022000000000000200020000020",
  19.    "022222222222200200020000020",
  20.    "022200000000200222222222000",
  21.    "022222222200200000020002020",
  22.    "022200000020222222222222220",
  23.    "022222222200200000000000020",
  24.    "020000000000222222222222220",
  25.    "022000022200200000000000020",
  26.    "020000000000200222222222220",
  27.    "022222222222222200000000020",
  28.    "020000000000000222222202020",
  29.    "020000000000000200000202020",
  30.    "022222222222222200000202020",
  31.    "000002000000000200002222220",
  32.    "020222222222222222222200000",
  33.    "020000000000000000000222220",
  34.    "022222222222222222222220010",
  35.    "000000000000000000000000000"
  36.    };
  37.    mostrar(a,"LABERINTO");
  38.    return 0;
  39. }
  40.  
  41.  
  42. void mostrar(char a[][28],char *msg){
  43.    system ("cls");
  44.    int i,j;
  45.    for( i=0;i<24;i++) {
  46.        for( j=0;j<27;j++) {
  47.            if ((i==22 && j==25) ||(i==1 && j==1))
  48.                color(215);
  49.            else if (a[i][j]=='X')
  50.                color(125);
  51.            else if (a[i][j]=='0')
  52.                color(175);
  53.            else
  54.            color(7);
  55.            printf("%c ",a[i][j]);
  56.            fflush(stdout);
  57.        }
  58.        putchar('\n');
  59.    }
  60.    color(7);
  61.    printf ("\n\t\t%s\n\n",msg);
  62.    system ("pause");
  63. }
  64.  
  65. void color (int n)
  66. {
  67.        SetConsoleTextAttribute(GetStdHandle (STD_OUTPUT_HANDLE), n );
  68. }
  69.  

Y a la espera de que vangodp saque su versión 2.0, la 1.0 no furula ni pá dios, dejo una opción muy simple. Se trata de que de forma totalmente aleatoria el ordenador busque la salida .... y siempre la encuentra y mas de una combinación posible en general. Tiene el inconveniente de que muestra todos los movimientos, incluso los de retroceso. Pero en fin, si vangodp no veo que se anime me pondré yo a ello. :silbar:

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4. #include <windows.h>
  5.  
  6. void mostrar(char a[][27],char *msg);
  7. void color (int n);
  8.  
  9. int main (){
  10.  
  11.    char a[24][27]={
  12.    "000000000000000000000000000",
  13.    "012222222222222222222222220",
  14.    "022020200020002000000000020",
  15.    "022202022020202000000000020",
  16.    "020000000020202000000000020",
  17.    "020222220020220200022222220",
  18.    "022000000000000200020000020",
  19.    "022222222222200200020000020",
  20.    "022200000000200222222222000",
  21.    "022222222200200000020002020",
  22.    "022200000020222222222222220",
  23.    "022222222200200000000000020",
  24.    "020000000000222222222222220",
  25.    "022000022200200000000000020",
  26.    "020000000000200222222222220",
  27.    "022222222222222200000000020",
  28.    "020000000000000222222202020",
  29.    "020000000000000200000202020",
  30.    "022222222222222200000202020",
  31.    "000002000000000200002222220",
  32.    "020222222222222222222200000",
  33.    "020000000000000000000222220",
  34.    "022222222222222222222220010",
  35.    "000000000000000000000000000"
  36.    };
  37.    int i,j,incre_i,incre_j;
  38.    i=1,j=1;
  39.    a[1][1]='I';
  40.    a[22][25]='F';
  41.    srand((unsigned) time(NULL));
  42.    mostrar(a,"LABERINTO");
  43.    system ("cls");
  44.    while (i!=21 || j!=25){
  45.        incre_i=rand()%3;
  46.        if (incre_i==2)
  47.            incre_i=-1;
  48.        incre_j=rand()%3;
  49.        if (incre_j==2)
  50.            incre_j=-1;
  51.        if ((incre_i==0 || incre_j==0) && (incre_i!=incre_j)  && (incre_i!=-incre_j)){
  52.            i+=incre_i;
  53.            if (i<0)
  54.                i++;
  55.            j+=incre_j;
  56.            if (j<0)
  57.                j++;
  58.            if (i>22)
  59.                i--;
  60.            if (j>25)
  61.                j--;
  62.            if (a[i][j]=='2' || a[i][j]=='X' || a[i][j]=='I') {
  63.                a[i][j]='X';
  64.            }
  65.            else {
  66.                i-=incre_i;
  67.                j-=incre_j;
  68.            }
  69.        }
  70.    }
  71.    mostrar(a,"SOLUCION");
  72.    return 0;
  73. }
  74.  
  75.  
  76. void mostrar(char a[][27],char *msg){
  77.    int i,j;
  78.    system ("cls");
  79.    for( i=0;i<24;i++) {
  80.        for( j=0;j<27;j++) {
  81.            if ((i==22 && j==25) ||(i==1 && j==1))
  82.                color(215);
  83.            else if (a[i][j]=='X')
  84.                color(125);
  85.            else if (a[i][j]=='0')
  86.                color(175);
  87.            else
  88.            color(7);
  89.            printf("%c ",a[i][j]);
  90.            fflush(stdout);
  91.        }
  92.        putchar('\n');
  93.    }
  94.    color(7);
  95.    printf ("\n\t\t%s\n\n",msg);
  96.    system ("pause");
  97. }
  98.  
  99. void color (int n)
  100. {
  101.        SetConsoleTextAttribute(GetStdHandle (STD_OUTPUT_HANDLE), n );
  102. }
  103.  

Cada vez que ejecutas el programa la solución puede variar al ser los movimientos totalmente aleatorios.


;-)  ;-) Felices Navidades y Próspero Año Nuevo.  ;-)  ;-)


¡¡¡¡ Saluditos! ..... !!!!


(http://st.forocoches.com/foro/images/smilies/aaaaa.gif)

REEDITADO


Título: Re: Ayuda con programa urgente!
Publicado por: vangodp en 30 Diciembre 2013, 02:06 am
Muy buena :D, promesa es deuda. jeje
Ya tendrás noticias mías  ;D
Código
  1. C:\Documents and Settings\joe mismow\Escritorio\mapaleosansancolor.cpp||In function 'int main()':|
  2. C:\Documents and Settings\joe mismow\Escritorio\mapaleosansancolor.cpp|36|error: initializer-string for array of chars is too long [-fpermissive]|
  3. C:\Documents and Settings\joe mismow\Escritorio\mapaleosansancolor.cpp|36|error: initializer-string for array of chars is too long [-fpermissive]|
  4. C:\Documents and Settings\joe mismow\Escritorio\mapaleosansancolor.cpp|36|error: initializer-string for array of chars is too long [-fpermissive]|
  5. C:\Documents and Settings\joe mismow\Escritorio\mapaleosansancolor.cpp|36|error: initializer-string for array of chars is too long [-fpermissive]|
  6. C:\Documents and Settings\joe mismow\Escritorio\mapaleosansancolor.cpp|36|error: initializer-string for array of chars is too long [-fpermissive]|
  7. C:\Documents and Settings\joe mismow\Escritorio\mapaleosansancolor.cpp|36|error: initializer-string for array of chars is too long [-fpermissive]|
  8. C:\Documents and Settings\joe mismow\Escritorio\mapaleosansancolor.cpp|36|error: initializer-string for array of chars is too long [-fpermissive]|
  9. C:\Documents and Settings\joe mismow\Escritorio\mapaleosansancolor.cpp|36|error: initializer-string for array of chars is too long [-fpermissive]|
  10. C:\Documents and Settings\joe mismow\Escritorio\mapaleosansancolor.cpp|36|error: initializer-string for array of chars is too long [-fpermissive]|
  11. C:\Documents and Settings\joe mismow\Escritorio\mapaleosansancolor.cpp|36|error: initializer-string for array of chars is too long [-fpermissive]|
  12. C:\Documents and Settings\joe mismow\Escritorio\mapaleosansancolor.cpp|36|error: initializer-string for array of chars is too long [-fpermissive]|
  13. C:\Documents and Settings\joe mismow\Escritorio\mapaleosansancolor.cpp|36|error: initializer-string for array of chars is too long [-fpermissive]|
  14. C:\Documents and Settings\joe mismow\Escritorio\mapaleosansancolor.cpp|36|error: initializer-string for array of chars is too long [-fpermissive]|
  15. C:\Documents and Settings\joe mismow\Escritorio\mapaleosansancolor.cpp|36|error: initializer-string for array of chars is too long [-fpermissive]|
  16. C:\Documents and Settings\joe mismow\Escritorio\mapaleosansancolor.cpp|36|error: initializer-string for array of chars is too long [-fpermissive]|
  17. C:\Documents and Settings\joe mismow\Escritorio\mapaleosansancolor.cpp|36|error: initializer-string for array of chars is too long [-fpermissive]|
  18. C:\Documents and Settings\joe mismow\Escritorio\mapaleosansancolor.cpp|36|error: initializer-string for array of chars is too long [-fpermissive]|
  19. C:\Documents and Settings\joe mismow\Escritorio\mapaleosansancolor.cpp|36|error: initializer-string for array of chars is too long [-fpermissive]|
  20. C:\Documents and Settings\joe mismow\Escritorio\mapaleosansancolor.cpp|36|error: initializer-string for array of chars is too long [-fpermissive]|
  21. C:\Documents and Settings\joe mismow\Escritorio\mapaleosansancolor.cpp|36|error: initializer-string for array of chars is too long [-fpermissive]|
  22. C:\Documents and Settings\joe mismow\Escritorio\mapaleosansancolor.cpp|36|error: initializer-string for array of chars is too long [-fpermissive]|
  23. C:\Documents and Settings\joe mismow\Escritorio\mapaleosansancolor.cpp|36|error: initializer-string for array of chars is too long [-fpermissive]|
  24. C:\Documents and Settings\joe mismow\Escritorio\mapaleosansancolor.cpp|36|error: initializer-string for array of chars is too long [-fpermissive]|
  25. C:\Documents and Settings\joe mismow\Escritorio\mapaleosansancolor.cpp|36|error: initializer-string for array of chars is too long [-fpermissive]|
  26. C:\Documents and Settings\joe mismow\Escritorio\mapaleosansancolor.cpp|42|warning: deprecated conversion from string constant to 'char*' [-Wwrite-strings]|
  27. C:\Documents and Settings\joe mismow\Escritorio\mapaleosansancolor.cpp|71|warning: deprecated conversion from string constant to 'char*' [-Wwrite-strings]|
  28. ||=== Build finished: 24 errors, 2 warnings (0 minutes, 1 seconds) ===|
  29.  
  30.  
A ver que me dices XDD en la foto se ve bien  ;-)


Título: Re: Ayuda con programa urgente!
Publicado por: leosansan en 30 Diciembre 2013, 06:08 am
Muy buena :D, promesa es deuda. jeje
Ya tendrás noticias mías  ;D
...............................................................................
A ver que me dices XDD en la foto se ve bien  ;-)

LO he intentado compilar en DevC aver que tal y casi me da un sofocón:

Citar
36 C:\Dev-Cpp\SinNombre1.cpp initializer-string for array of chars is too long
....................................................................

Y así un motón de líneas. Pero claro, no me fije que por defecto el "programilla" lo guarda con extensión .cpp por defecto. Así que volví a guardarlo con extensión .c y ¡boommmm!, corre sin pronlemas ni advertencias:

(http://i1280.photobucket.com/albums/a497/leosansan/GRAFICOS1/laberintocoloDevC_zps4b82d2cf.jpg)

Ya sabía que te daría problemas por el dichosito Dev.C++. Te reitero mi sugerencia de trabajar mejor con Code::Blocks (http://www.codeblocks.org/downloads/26)

Elige la de 96.8 MB, la codeblocks-13.12mingw-setup-TDM-GCC-481.exe.


Mira mi salida en Code::Blocks, y eso con el compilador en modo pedantic o Wall que canta a la más mínima::

Citar
...............................................................
Process terminated with status 0 (0 minutes, 0 seconds)
0 errors, 0 warnings (0 minutes, 0 seconds)

.....................................

Ya me cuentas como te ha ido.

(http://st.forocoches.com/foro/images/smilies/aaaaa.gif)


¡¡¡¡ Saluditos! ..... !!!!

:rolleyes: ;) ;) ;) :rolleyes:






Título: Re: Ayuda con programa urgente!
Publicado por: vangodp en 30 Diciembre 2013, 11:15 am
no me diga que ha sido dev que los avisos que te puse es de un codeblocks  :laugh:
El dev solo lo confirma.
No eches la culpa a la herramienta sino al carpintero jeje ;D
Que opciones tienes en tu ide.
Algo afecta, la cosa es que lo uso por defecto y me tira esos errores tanto en uno como en otro.
el problema se da en la declaración del mapa casi siempre[y]
  • parece que si ponemos el numero justo de casas que vamos usar se buguea.
Me parece que no debemos usar la ultima posición de ese arreglo en ambos sentidos, tanto en x como en y.
Si alguien lo sabe a que se deve, puede que sea el guwin, tu usas el 7 y yo el xp puede que eso influya.
Te repito que hago lo que tu en dev, no le eches la culpa al pobre por no ser como una navaja Suiza.XDDD
Ademas pega el código aquí que fotos no quiero ver XDD
Saludos!^^


Título: Re: Ayuda con programa urgente!
Publicado por: vangodp en 30 Diciembre 2013, 11:23 am
Eh echo lo que me dices de grardarlo como c.
Y tachan funciona :D muy bien.
Se ve colorines muy monos.:D
Pero me gusta que vayamos viendo como se lo monta.
Lo que no quita el merito, muy muy bueno si señor.
Lo que creo que pasa es que lo estaba guardando lo tuyo como cpp y tu lo mio como c.
Uno usa gcc y el otro g++.
Creo que ahora ya lo sabemos  ;)


Título: Re: Ayuda con programa urgente!
Publicado por: leosansan en 30 Diciembre 2013, 12:19 pm
..............................
Ademas pega el código aquí que fotos no quiero ver XDD
Saludos!^^


Pero si ya lo había puesto. Ahí va otra vez el código del laberinto con color:

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4. #include <windows.h>
  5.  
  6. void mostrar(char a[][28],char *msg);
  7. void color (int n);
  8.  
  9. int main (){
  10.  
  11.    char a[24][28]={
  12.    "000000000000000000000000000",
  13.    "012222222222222222222222220",
  14.    "022020200020002000000000020",
  15.    "022202022020202000000000020",
  16.    "020000000020202000000000020",
  17.    "020222220020220200022222220",
  18.    "022000000000000200020000020",
  19.    "022222222222200200020000020",
  20.    "022200000000200222222222000",
  21.    "022222222200200000020002020",
  22.    "022200000020222222222222220",
  23.    "022222222200200000000000020",
  24.    "020000000000222222222222220",
  25.    "022000022200200000000000020",
  26.    "020000000000200222222222220",
  27.    "022222222222222200000000020",
  28.    "020000000000000222222202020",
  29.    "020000000000000200000202020",
  30.    "022222222222222200000202020",
  31.    "000002000000000200002222220",
  32.    "020222222222222222222200000",
  33.    "020000000000000000000222220",
  34.    "022222222222222222222220010",
  35.    "000000000000000000000000000"
  36.    };
  37.    mostrar(a,"LABERINTO");
  38.    return 0;
  39. }
  40.  
  41.  
  42. void mostrar(char a[][28],char *msg){
  43.    system ("cls");
  44.    int i,j;
  45.    for( i=0;i<24;i++) {
  46.        for( j=0;j<27;j++) {
  47.            if ((i==22 && j==25) ||(i==1 && j==1))
  48.                color(215);
  49.            else if (a[i][j]=='X')
  50.                color(125);
  51.            else if (a[i][j]=='0')
  52.                color(175);
  53.            else
  54.            color(7);
  55.            printf("%c ",a[i][j]);
  56.            fflush(stdout);
  57.        }
  58.        putchar('\n');
  59.    }
  60.    color(7);
  61.    printf ("\n\t\t%s\n\n",msg);
  62.    system ("pause");
  63. }
  64.  
  65. void color (int n)
  66. {
  67.        SetConsoleTextAttribute(GetStdHandle (STD_OUTPUT_HANDLE), n );
  68. }
  69.  

Ya me contaras que te parece.

Y el tuyo ni en .cpp me tira.  :o :o :o


(http://st.forocoches.com/foro/images/smilies/aaaaa.gif)


¡¡¡¡ Saluditos! ..... !!!!

:rolleyes: ;) ;) ;) :rolleyes:

P.D:Me has liado con eso de que no había puesto el código. O estoy muy espeso, que también.

Saluditos! ..... !!!!        (http://st.forocoches.com/foro/images/smilies/aaaaa.gif)


Título: Re: Ayuda con programa urgente!
Publicado por: vangodp en 30 Diciembre 2013, 12:26 pm
a ver si te voy a tener que grabar un video XD


Título: Re: Ayuda con programa urgente!
Publicado por: amchacon en 30 Diciembre 2013, 14:13 pm
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.


Título: Re: Ayuda con programa urgente!
Publicado por: leosansan en 30 Diciembre 2013, 14:54 pm
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. :rolleyes: :rolleyes: :rolleyes:

Espero noticias.


Saluditos! ..... !!!!        (http://st.forocoches.com/foro/images/smilies/aaaaa.gif)

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. ;) ;) ;)




Título: Re: Ayuda con programa urgente!
Publicado por: vangodp en 30 Diciembre 2013, 19:54 pm
a mi si me funciono guardando en .c


Título: Re: Ayuda con programa urgente!
Publicado por: amchacon en 4 Enero 2014, 00:01 am
Añado un código que te resuelve el laberinto buscando la ruta más corta:

(http://img543.imageshack.us/img543/5373/su0q.png)

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4. #include <windows.h>
  5.  
  6. #define INIX 1
  7. #define INIY 1
  8. #define FINX 22
  9. #define FINY 25
  10. #define MAX_X 24
  11. #define MAX_Y 28
  12.  
  13. void mostrar(char a[][MAX_Y],char *msg);
  14. void color (int n);
  15.  
  16. typedef struct cord
  17. {
  18.    int x,y;
  19. } Cord;
  20.  
  21. typedef struct nodo
  22. {
  23.    int Distancia;
  24.    Cord Posicion;
  25.    char Calculado;
  26.    struct nodo* anterior;
  27. } Nodo;
  28.  
  29. char buscarSolucion(char mapa[][MAX_Y],Cord Ini,Cord Fin);
  30. void MarcarNodo(Nodo* Actual,Nodo* Otro);
  31.  
  32. int main ()
  33. {
  34.  
  35.    char a[MAX_X][MAX_Y]=
  36.    {
  37.        "000000000000000000000000000",
  38.        "012222222222222222222222220",
  39.        "022020200020002000000000020",
  40.        "022202022020202000000000020",
  41.        "020000000020202000000000020",
  42.        "020222220020220200022222220",
  43.        "022000000000000200020000020",
  44.        "022222222222200200020000020",
  45.        "022200000000200222222222000",
  46.        "022222222200200000020002020",
  47.        "022200000020222222222222220",
  48.        "022222222200200000000000020",
  49.        "020000000000222222222222220",
  50.        "022000022200200000000000020",
  51.        "020000000000200222222222220",
  52.        "022222222222222200000000020",
  53.        "020000000000000222222202020",
  54.        "020000000000000200000202020",
  55.        "022222222222222200000202020",
  56.        "000002000000000200002222220",
  57.        "020222222222222222222200000",
  58.        "020000000000000000000222220",
  59.        "022222222222222222222220010",
  60.        "000000000000000000000000000"
  61.    };
  62.    mostrar(a,"LABERINTO");
  63.  
  64.    Cord Inicio;
  65.    Inicio.x = INIX;
  66.    Inicio.y = INIY;
  67.  
  68.    Cord Final;
  69.    Final.x = FINX;
  70.    Final.y = FINY;
  71.  
  72.    buscarSolucion(a,Inicio,Final);
  73.  
  74.    return 0;
  75. }
  76.  
  77. void mostrar(char a[][MAX_Y],char *msg)
  78. {
  79.    system ("cls");
  80.    int i,j;
  81.    for( i=0; i<MAX_X; i++)
  82.    {
  83.        for( j=0; j<MAX_Y-1; j++)
  84.        {
  85.            if ((i==FINX && j==FINY) ||(i==INIX && j==INIY))
  86.                color(215);
  87.            else if (a[i][j]=='X')
  88.                color(125);
  89.            else if (a[i][j]=='0')
  90.                color(175);
  91.            else
  92.                color(7);
  93.            printf("%c ",a[i][j]);
  94.            fflush(stdout);
  95.        }
  96.        putchar('\n');
  97.    }
  98.    color(7);
  99.    printf ("\n\t\t%s\n\n",msg);
  100.    system ("pause");
  101. }
  102.  
  103. void color (int n)
  104. {
  105.    SetConsoleTextAttribute(GetStdHandle (STD_OUTPUT_HANDLE), n );
  106. }
  107.  
  108. char buscarSolucion(char mapa[][MAX_Y],Cord Ini,Cord Fin)
  109. {
  110.    if (Ini.x == Fin.x && Ini.y == Fin.y)
  111.    {
  112.        return 1;
  113.    }
  114.    Cord Actual;
  115.    Actual.x = Ini.x;
  116.    Actual.y = Ini.y;
  117.  
  118.    Nodo* Totales[MAX_X][MAX_Y];
  119.  
  120.    int Nodos = 0;
  121.    int i = 0;
  122.    int j = 0;
  123.  
  124.    for (; i < MAX_X; i++)
  125.    {
  126.        for (j = 0; j < MAX_Y; j++)
  127.        {
  128.            if (mapa[i][j] != '0')
  129.            {
  130.                Totales[i][j] = (Nodo*) malloc(sizeof(Nodo));
  131.                Totales[i][j]->anterior = 0;
  132.                Totales[i][j]->Calculado = 0;
  133.                Totales[i][j]->Distancia = -1;
  134.                Totales[i][j]->Posicion.x = i;
  135.                Totales[i][j]->Posicion.y = j;
  136.                Nodos++;
  137.            }
  138.            else Totales[i][j] = 0;
  139.        }
  140.    }
  141.  
  142.    Totales[Ini.x][Ini.y]->Distancia = 0;
  143.  
  144.    Cord Min;
  145.  
  146.   //mapa[Actual.x][Actual.y] = 'X';
  147.  
  148.    while ((Actual.x != Fin.x || Actual.y != Fin.y) && Nodos != 0)
  149.    {
  150.        // Izquierda
  151.  
  152.        if (Totales[Actual.x-1][Actual.y] && Totales[Actual.x-1][Actual.y]->Calculado == 0)
  153.        {
  154.            MarcarNodo(Totales[Actual.x][Actual.y],Totales[Actual.x-1][Actual.y]);
  155.        }
  156.  
  157.        // Derecha
  158.  
  159.        if (Totales[Actual.x+1][Actual.y] && Totales[Actual.x+1][Actual.y]->Calculado == 0)
  160.        {
  161.            MarcarNodo(Totales[Actual.x][Actual.y],Totales[Actual.x+1][Actual.y]);
  162.        }
  163.  
  164.        // Abajo
  165.  
  166.        if (Totales[Actual.x][Actual.y-1] && Totales[Actual.x][Actual.y-1]->Calculado == 0)
  167.        {
  168.            MarcarNodo(Totales[Actual.x][Actual.y],Totales[Actual.x][Actual.y-1]);
  169.        }
  170.  
  171.        // Arriba
  172.  
  173.        if (Totales[Actual.x][Actual.y+1] && Totales[Actual.x][Actual.y+1]->Calculado == 0)
  174.        {
  175.           MarcarNodo(Totales[Actual.x][Actual.y],Totales[Actual.x][Actual.y+1]);
  176.        }
  177.  
  178.        Totales[Actual.x][Actual.y]->Calculado = 1; //Marcado!
  179.  
  180.        // Buscando un valor de referencia al minimo
  181.  
  182.        for (i = 0; i < MAX_X; i++)
  183.        {
  184.            for (j = 0; j < MAX_Y; j++)
  185.            {
  186.                if (Totales[i][j] && Totales[i][j]->Calculado == 0 && Totales[i][j]->Distancia != -1)
  187.                {
  188.                    Min.x = i;
  189.                    Min.y = j;
  190.                    i = 25;
  191.                    j = 29;
  192.                }
  193.            }
  194.        }
  195.  
  196.        // Buscando la distancia minima
  197.  
  198.        for (; i < MAX_X; i++)
  199.        {
  200.            for (j = 0; j < MAX_Y; j++)
  201.            {
  202.                if (Totales[i][j] && Totales[i][j]->Distancia < Totales[Min.x][Min.y]->Distancia
  203.                    && Totales[i][j]->Distancia != -1 && Totales[i][j]->Calculado == 0)
  204.                {
  205.                    Min.x = i;
  206.                    Min.y = j;
  207.                }
  208.            }
  209.        }
  210.        Actual.x = Min.x;
  211.        Actual.y = Min.y;
  212.        Nodos--;
  213.    }
  214.  
  215.    Nodo* Cosa = Totales[Actual.x][Actual.y];
  216.  
  217.    while (Cosa)
  218.    {
  219.        Actual.x = Cosa->Posicion.x;
  220.        Actual.y = Cosa->Posicion.y;
  221.        mapa[Actual.x][Actual.y] = 'X';
  222.        Cosa = Cosa->anterior;
  223.    }
  224.  
  225.    // borrar
  226.  
  227.    for (i = 0; i < 24; i++)
  228.    {
  229.        for (j = 0; j < 28; j++)
  230.        {
  231.            free(Totales[i][j]);
  232.        }
  233.    }
  234.  
  235.    mostrar(mapa,"Prueba");
  236.  
  237.    return (Nodos != 0);
  238. }
  239.  
  240. void MarcarNodo(Nodo* Actual,Nodo* Otro)
  241. {
  242.    if (Otro->Distancia == -1)
  243.    {
  244.        Otro->Distancia = Actual->Distancia+1;
  245.        Otro->anterior = Actual;
  246.    }
  247.    else if (Actual->Distancia+1 < Otro->Distancia)
  248.    {
  249.        Otro->Distancia = Actual->Distancia+1;
  250.        Otro->anterior = Actual;
  251.    }
  252. }


Título: Re: Ayuda con programa urgente!
Publicado por: vangodp en 4 Enero 2014, 02:45 am
¡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  ;-)



Título: Re: Ayuda con programa urgente!
Publicado por: amchacon en 4 Enero 2014, 13:30 pm
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):

(http://img837.imageshack.us/img837/8094/hwdm.png)

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4. #include <windows.h>
  5.  
  6. #define INIX 1
  7. #define INIY 1
  8. #define FINX 22
  9. #define FINY 25
  10. #define MAX_X 24
  11. #define MAX_Y 28
  12.  
  13. void mostrar(char a[][MAX_Y],char *msg);
  14. void color (int n);
  15.  
  16. typedef struct cord
  17. {
  18.    int x,y;
  19. } Cord;
  20.  
  21. typedef struct nodo
  22. {
  23.    int Distancia;
  24.    Cord Posicion;
  25.    char Calculado;
  26.    struct nodo* anterior;
  27.   // struct nodo* siguiente;
  28. } Nodo;
  29.  
  30. char buscarSolucion(char mapa[][MAX_Y],Cord Ini,Cord Fin);
  31. char buscarSolucionAleatoria(char mapa[][MAX_Y],Cord Ini,Cord Fin);
  32. void MarcarNodo(Nodo* Actual,Nodo* Otro);
  33.  
  34. int main ()
  35. {
  36.  
  37.    char a[MAX_X][MAX_Y]=
  38.    {
  39.        "000000000000000000000000000",
  40.        "012222222222222222222222220",
  41.        "022020200020002000000000020",
  42.        "022202022020202000000000020",
  43.        "020000000020202000000000020",
  44.        "020222220020220200022222220",
  45.        "022000000000000200020000020",
  46.        "022222222222200200020000020",
  47.        "022200000000200222222222000",
  48.        "022222222200200000020002020",
  49.        "022200000020222222222222220",
  50.        "022222222200200000000000020",
  51.        "020000000000222222222222220",
  52.        "022000022200200000000000020",
  53.        "020000000000200222222222220",
  54.        "022222222222222200000000020",
  55.        "020000000000000222222202020",
  56.        "020000000000000200000202020",
  57.        "022222222222222200000202020",
  58.        "000002000000000200002222220",
  59.        "020222222222222222222200000",
  60.        "020000000000000000000222220",
  61.        "022222222222222222222220010",
  62.        "000000000000000000000000000"
  63.    };
  64.    mostrar(a,"LABERINTO");
  65.   srand(time(0));
  66.    Cord Inicio;
  67.    Inicio.x = INIX;
  68.    Inicio.y = INIY;
  69.  
  70.    Cord Final;
  71.    Final.x = FINX;
  72.    Final.y = FINY;
  73.  
  74.    buscarSolucion(a,Inicio,Final);
  75.  
  76.   while(1) buscarSolucionAleatoria(a,Inicio,Final);
  77.  
  78.    return 0;
  79. }
  80.  
  81. void mostrar(char a[][MAX_Y],char *msg)
  82. {
  83.    system ("cls");
  84.    int i,j;
  85.    for( i=0; i<MAX_X; i++)
  86.    {
  87.        for( j=0; j<MAX_Y-1; j++)
  88.        {
  89.            if ((i==FINX && j==FINY) ||(i==INIX && j==INIY))
  90.                color(215);
  91.            else if (a[i][j]=='X')
  92.                color(125);
  93.            else if (a[i][j]=='0')
  94.                color(175);
  95.            else
  96.                color(7);
  97.            printf("%c ",a[i][j]);
  98.            fflush(stdout);
  99.        }
  100.        putchar('\n');
  101.    }
  102.    color(7);
  103.    printf ("\n\t\t%s\n\n",msg);
  104.    system ("pause");
  105. }
  106.  
  107. void color (int n)
  108. {
  109.    SetConsoleTextAttribute(GetStdHandle (STD_OUTPUT_HANDLE), n );
  110. }
  111.  
  112. char buscarSolucionAleatoria(char Mapa[][MAX_Y],Cord Ini,Cord Fin)
  113. {
  114.        char mapa[MAX_X][MAX_Y];
  115.    if (Ini.x == Fin.x && Ini.y == Fin.y)
  116.    {
  117.        return 1;
  118.    }
  119.    Cord Actual;
  120.    Actual.x = Ini.x;
  121.    Actual.y = Ini.y;
  122.  
  123.    Nodo* Totales[MAX_X][MAX_Y];
  124.    int i = 0;
  125.    int j = 0;
  126.  
  127.    for (; i < MAX_X; i++)
  128.    {
  129.        for (j = 0; j < MAX_Y; j++)
  130.        {
  131.            mapa[i][j] = Mapa[i][j];
  132.            if (mapa[i][j] != '0')
  133.            {
  134.                Totales[i][j] = (Nodo*) malloc(sizeof(Nodo));
  135.                Totales[i][j]->anterior = 0;
  136.                Totales[i][j]->Calculado = 0;
  137.                Totales[i][j]->Distancia = -1;
  138.                Totales[i][j]->Posicion.x = i;
  139.                Totales[i][j]->Posicion.y = j;
  140.            }
  141.            else Totales[i][j] = 0;
  142.        }
  143.    }
  144.  
  145.    Cord Min;
  146.  
  147.    int Posibilidades = 0;
  148.    Nodo* Aux[4];
  149.  
  150.    while ((Actual.x != Fin.x || Actual.y != Fin.y))
  151.    {
  152.  
  153.        // Izquierda
  154.  
  155.        Posibilidades = 0;
  156.  
  157.        if (Totales[Actual.x-1][Actual.y] && Totales[Actual.x-1][Actual.y]->Calculado == 0)
  158.        {
  159.            Aux[0] = Totales[Actual.x-1][Actual.y];
  160.            Posibilidades++;
  161.        }
  162.  
  163.        // Derecha
  164.  
  165.        if (Totales[Actual.x+1][Actual.y] && Totales[Actual.x+1][Actual.y]->Calculado == 0)
  166.        {
  167.            Aux[Posibilidades] = Totales[Actual.x+1][Actual.y];
  168.            Posibilidades++;
  169.        }
  170.  
  171.        // Abajo
  172.  
  173.        if (Totales[Actual.x][Actual.y-1] && Totales[Actual.x][Actual.y-1]->Calculado == 0)
  174.        {
  175.            Aux[Posibilidades] = Totales[Actual.x][Actual.y-1];
  176.            Posibilidades++;
  177.        }
  178.  
  179.        // Arriba
  180.  
  181.        if (Totales[Actual.x][Actual.y+1] && Totales[Actual.x][Actual.y+1]->Calculado == 0)
  182.        {
  183.           Aux[Posibilidades] = Totales[Actual.x][Actual.y+1];
  184.           Posibilidades++;
  185.        }
  186.  
  187.       Totales[Actual.x][Actual.y]->Calculado = 1; //Marcado!
  188.  
  189.        if (Posibilidades == 0)
  190.        {
  191.            if (!Totales[Actual.x][Actual.y]->anterior) return 0;
  192.  
  193.            int aux_x = Actual.x;
  194.            Actual.x = Totales[Actual.x][Actual.y]->anterior->Posicion.x;
  195.            Actual.y = Totales[aux_x][Actual.y]->anterior->Posicion.y;
  196.        }
  197.        else if (Posibilidades == 1)
  198.        {
  199.                char mapa[MAX_X][MAX_Y];Aux[0]->anterior = Totales[Actual.x][Actual.y];
  200.            Actual.x = Aux[0]->Posicion.x;
  201.            Actual.y = Aux[0]->Posicion.y;
  202.        }
  203.        else
  204.        {
  205.            int n = rand()%Posibilidades;
  206.            Aux[n]->anterior = Totales[Actual.x][Actual.y];
  207.            Actual.x = Aux[n]->Posicion.x;
  208.            Actual.y = Aux[n]->Posicion.y;
  209.        }
  210.    }
  211.    Nodo* Cosa = Totales[Actual.x][Actual.y];
  212.  
  213.    while (Cosa)
  214.    {
  215.        Actual.x = Cosa->Posicion.x;
  216.        Actual.y = Cosa->Posicion.y;
  217.        mapa[Actual.x][Actual.y] = 'X';
  218.        Cosa = Cosa->anterior;
  219.    }
  220. //&mostrar(mapa,"Ruta aleatoria");
  221.    // borrar
  222.  
  223.    for (i = 0; i < 24; i++)
  224.    {
  225.        for (j = 0; j < 28; j++)
  226.        {
  227.            free(Totales[i][j]);
  228.        }
  229.    }
  230.  
  231.    mostrar(mapa,"Ruta aleatoria");
  232.  
  233.    return 1;
  234. }
  235.  
  236. char buscarSolucion(char Mapa[][MAX_Y],Cord Ini,Cord Fin)
  237. {
  238.    char mapa[MAX_X][MAX_Y];
  239.    if (Ini.x == Fin.x && Ini.y == Fin.y)
  240.    {
  241.        return 1;
  242.    }
  243.    Cord Actual;
  244.    Actual.x = Ini.x;
  245.    Actual.y = Ini.y;
  246.  
  247.    Nodo* Totales[MAX_X][MAX_Y];
  248.  
  249.    int Nodos = 0;
  250.    int i = 0;
  251.    int j = 0;
  252.  
  253.    for (; i < MAX_X; i++)
  254.    {
  255.        for (j = 0; j < MAX_Y; j++)
  256.        {
  257.            mapa[i][j] = Mapa[i][j];
  258.            if (mapa[i][j] != '0')
  259.            {
  260.                Totales[i][j] = (Nodo*) malloc(sizeof(Nodo));
  261.                Totales[i][j]->anterior = 0;
  262.                Totales[i][j]->Calculado = 0;
  263.                Totales[i][j]->Distancia = -1;
  264.                Totales[i][j]->Posicion.x = i;
  265.                Totales[i][j]->Posicion.y = j;
  266.                Nodos++;
  267.            }
  268.            else Totales[i][j] = 0;
  269.        }
  270.    }
  271.  
  272.    Totales[Ini.x][Ini.y]->Distancia = 0;
  273.  
  274.    Cord Min;
  275.  
  276.   //mapa[Actual.x][Actual.y] = 'X';
  277.  
  278.    while ((Actual.x != Fin.x || Actual.y != Fin.y) && Nodos != 0)
  279.    {
  280.        // Izquierda
  281.  
  282.        if (Totales[Actual.x-1][Actual.y] && Totales[Actual.x-1][Actual.y]->Calculado == 0)
  283.        {
  284.            MarcarNodo(Totales[Actual.x][Actual.y],Totales[Actual.x-1][Actual.y]);
  285.        }
  286.  
  287.        // Derecha
  288.  
  289.        if (Totales[Actual.x+1][Actual.y] && Totales[Actual.x+1][Actual.y]->Calculado == 0)
  290.        {
  291.            MarcarNodo(Totales[Actual.x][Actual.y],Totales[Actual.x+1][Actual.y]);
  292.        }
  293.  
  294.        // Abajo
  295.  
  296.        if (Totales[Actual.x][Actual.y-1] && Totales[Actual.x][Actual.y-1]->Calculado == 0)
  297.        {
  298.            MarcarNodo(Totales[Actual.x][Actual.y],Totales[Actual.x][Actual.y-1]);
  299.        }
  300.  
  301.        // Arriba
  302.  
  303.        if (Totales[Actual.x][Actual.y+1] && Totales[Actual.x][Actual.y+1]->Calculado == 0)
  304.        {
  305.           MarcarNodo(Totales[Actual.x][Actual.y],Totales[Actual.x][Actual.y+1]);
  306.        }
  307.  
  308.        Totales[Actual.x][Actual.y]->Calculado = 1; //Marcado!
  309.  
  310.        // Buscando un valor de referencia al minimo
  311.  
  312.        for (i = 0; i < MAX_X; i++)
  313.        {
  314.            for (j = 0; j < MAX_Y; j++)
  315.            {
  316.                if (Totales[i][j] && Totales[i][j]->Calculado == 0 && Totales[i][j]->Distancia != -1)
  317.                {
  318.                    Min.x = i;
  319.                    Min.y = j;
  320.                    i = 25;
  321.                    j = 29;
  322.                }
  323.            }
  324.        }
  325.  
  326.        // Buscando la distancia minima
  327.  
  328.        for (; i < MAX_X; i++)
  329.        {
  330.            for (j = 0; j < MAX_Y; j++)
  331.            {
  332.                if (Totales[i][j] && Totales[i][j]->Distancia < Totales[Min.x][Min.y]->Distancia
  333.                    && Totales[i][j]->Distancia != -1 && Totales[i][j]->Calculado == 0)
  334.                {
  335.                    Min.x = i;
  336.                    Min.y = j;
  337.                }
  338.            }
  339.        }
  340.        Actual.x = Min.x;
  341.        Actual.y = Min.y;
  342.        Nodos--;
  343.    }
  344.  
  345.    Nodo* Cosa = Totales[Actual.x][Actual.y];
  346.  
  347.    while (Cosa)
  348.    {
  349.        Actual.x = Cosa->Posicion.x;
  350.        Actual.y = Cosa->Posicion.y;
  351.        mapa[Actual.x][Actual.y] = 'X';
  352.        Cosa = Cosa->anterior;
  353.    }
  354.  
  355.    // borrar
  356.  
  357.    for (i = 0; i < 24; i++)
  358.    {
  359.        for (j = 0; j < 28; j++)
  360.        {
  361.            free(Totales[i][j]);
  362.        }
  363.    }
  364.  
  365.    mostrar(mapa,"Ruta mas corta");
  366.  
  367.    return (Nodos != 0);
  368. }
  369.  
  370. void MarcarNodo(Nodo* Actual,Nodo* Otro)
  371. {
  372.    if (Otro->Distancia == -1)
  373.    {
  374.        Otro->Distancia = Actual->Distancia+1;
  375.        Otro->anterior = Actual;
  376.    }
  377.    else if (Actual->Distancia+1 < Otro->Distancia)
  378.    {
  379.        Otro->Distancia = Actual->Distancia+1;
  380.        Otro->anterior = Actual;
  381.    }
  382. }

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 (http://es.wikipedia.org/wiki/Algoritmo_de_Dijkstra)

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.


Título: Re: Ayuda con programa urgente!
Publicado por: vangodp en 4 Enero 2014, 16:08 pm
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 :D
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

Código
  1. #include <iostream>
  2. #include <windows.h>
  3. #include <stdio.h>
  4. #include <time.h>
  5.  
  6. # define udir mapa[y-1][x]
  7. # define ldir mapa[y][x-1]
  8. # define rdir mapa[y][x+1]
  9. # define ddir mapa[y+1][x]
  10. # define po mapa[y][x]
  11. using namespace std;
  12.  
  13. const int TAMY = 29;
  14. const int TAMX = 29;
  15.  
  16. int contapasos = 0;
  17.  
  18. void mostrar(char mapa[TAMY][TAMX]){
  19. system ("cls");
  20.  
  21.     for(int y=0;y<29;y++)
  22.     {
  23.     for(int x=0;x<29;x++)
  24.     {
  25.     printf("%c",mapa[y][x]);
  26.     //Sleep(5);
  27.     }
  28.     printf("\n");
  29.     //Sleep(5);
  30.     }
  31.  
  32. }
  33.  
  34. int rand4 (){
  35. srand(time(NULL));
  36. int n = (0 + rand() % 4);
  37. return n;
  38. }
  39.  
  40. void go_up ( char mapa[TAMY][TAMX], int &x , int &y ){
  41. po = '1';
  42. y--;
  43. po = 'X';
  44. }
  45.  
  46. void go_le ( char mapa[TAMY][TAMX], int &x , int &y ){
  47. po = '1';
  48. x--;
  49. po = 'X';
  50. }
  51.  
  52. void go_ri ( char mapa[TAMY][TAMX], int &x , int &y ){
  53. po = '1';
  54. x++;
  55. po = 'X';
  56. }
  57.  
  58. void go_do ( char mapa[TAMY][TAMX], int &x , int &y ){
  59. po = '1';
  60. y++;
  61. po = 'X';
  62. }
  63.  
  64.  
  65. int main (){
  66. //variables iniciales
  67. int pasos = 0;
  68. bool nodir = true;
  69. bool fin = true;
  70. int x = 1; //posicion x inicial
  71. int y = 1; //posicion y inicial
  72. int rand;
  73. char mapa[TAMY][TAMX]={
  74.   //0123456789012345678901234567
  75. "000000000000000000000000000",//0
  76. "020222222222222222222222220",//1
  77. "020200000000000000000000020",//2
  78. "020222222222222200000000020",//3
  79. "020200000000000000000000020",//4
  80. "020222222222222200022222220",//5
  81. "020000000000000200020000020",//6
  82. "020222222222200200000000020",//7
  83. "020200000000200222222222020",//8
  84. "020222222200200000000002020",//9
  85. "020000000200222222222222020",//10
  86. "022222220200000000000000020",//11
  87. "020000020200222222222222220",//12
  88. "020000022200200000000000000",//13
  89. "000000000000200222222222220",//14
  90. "022222222222200200000000020",//15
  91. "020000000000000222222202020",//16
  92. "020000000000000200000202020",//17
  93. "022222222222222200000202020",//18
  94. "000000000000000000000202220",//19
  95. "022222222222222222222200000",//20
  96. "020000000000000000000000000",//21
  97. "02222222222222222222222FIN0",//22
  98. "000000000000000000000000000" //23
  99.  
  100. };
  101. //obtenr cantidad maxima de pasos pocibles.
  102. for ( int fory = 0; fory <= TAMY; fory++  ){
  103. for ( int forx = 0; forx <= TAMX; forx++  ){
  104. if ( mapa[fory][forx] == '2' )
  105. pasos++;
  106. }
  107. }
  108. int xbackup[pasos];
  109. int ybackup[pasos];
  110.  
  111.  
  112. while ( fin ){
  113. while ( udir == '1' || ldir == '1' || rdir == '1' || ddir == '1' ){
  114. if ( udir == '2' || ldir == '2' || rdir == '2' || ddir == '2' ){
  115. break;
  116. }
  117.  
  118. contapasos--;
  119. mapa[y][x]='0';
  120. x = xbackup[contapasos];
  121. y = ybackup[contapasos];
  122. mapa[y][x]='X';
  123. mostrar( mapa );
  124. Sleep ( 100 );
  125. }
  126.  
  127. contapasos++;
  128. xbackup[contapasos]= x;
  129. ybackup[contapasos]= y;
  130.  
  131. if( udir == '2' || ldir == '2' || rdir == '2' || ddir == '2' ){
  132.  
  133. do{
  134.  
  135. rand = rand4();
  136.  
  137.  
  138. if ( udir == '2' && ldir != '2' && rdir != '2' && ddir != '2' ){
  139. go_up( mapa, x, y );
  140. break;
  141. }
  142. else if ( udir != '2' && ldir == '2' && rdir != '2' && ddir != '2' ){
  143. go_le( mapa, x, y );
  144. break;
  145. }
  146. else if ( udir != '2' && ldir != '2' && rdir == '2' && ddir != '2' ){
  147. go_ri( mapa, x, y );
  148. break;
  149. }
  150. else if ( udir != '2' && ldir != '2' && rdir != '2' && ddir == '2' ){
  151. go_do( mapa, x, y );
  152. break;
  153. }
  154.  
  155. else if ( rand == 0 ){
  156. if ( udir == '0' || udir == '1' ){
  157. nodir = true;
  158. break;
  159. }
  160. else {
  161. go_up( mapa, x, y );
  162. nodir = false;
  163. }
  164.  
  165. }
  166. else if ( rand == 1 ){
  167. if ( ldir == '0' || ldir == '1' ){
  168. nodir = true;
  169. break;
  170. }
  171. else {
  172. go_le( mapa, x, y );
  173. nodir = false;
  174. }
  175.  
  176. }
  177. else if ( rand == 2 ){
  178. if ( rdir == '0' || rdir == '1' ){
  179. nodir = true;
  180. break;
  181.  
  182. }
  183. else {
  184. go_ri( mapa, x, y );
  185. nodir = false;
  186. }
  187.  
  188. }
  189. else if ( rand == 3 ){
  190. if ( ddir == '0' || ddir == '1' ){
  191. nodir = true;
  192. break;
  193. }
  194. else {
  195. go_do( mapa, x, y );
  196. nodir = false;
  197. }
  198.  
  199. }
  200.  
  201. }while( nodir );//FIN DOWHILE
  202.  
  203. }//FIN IF
  204. mostrar( mapa );
  205. Sleep ( 100 );
  206. }//FIN DEL LOOP
  207.  
  208. }
  209.  
  210.  

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


Título: Re: Ayuda con programa urgente!
Publicado por: amchacon en 4 Enero 2014, 16:29 pm
Código
  1. int rand4 (){
  2. srand(time(NULL));
  3. int n = (0 + rand() % 4);
  4. return n;
  5. }
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.


Título: Re: Ayuda con programa urgente!
Publicado por: vangodp en 4 Enero 2014, 17:24 pm
Pues gracias man, me lo imaginaba pero no tenia certeza XD  ;-)


Título: Re: Ayuda con programa urgente!
Publicado por: leosansan en 14 Enero 2014, 10:07 am
;-) ;-) ;-) ;-) ;-) ;-) ;-) ;-)

¡¡¡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. ;) ;) ;)


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


Pues va a ser que no. Algo tendrás que revisar porque no da exactamente la ruta más corta: casi, casi, pero no.

Y como muestra dos botones:


(http://i1280.photobucket.com/albums/a497/leosansan/GRAFICOS%202/laberintoamchacon_zps567807d2.jpg)

(http://i1280.photobucket.com/albums/a497/leosansan/GRAFICOS%202/laberintoamchacon1_zpsbcd4f414.jpg)

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 (http://foro.elhacker.net/buscador2-t391209.0.html;msg1856227#msg1856227), tema que aconsejo a todo el que quiera darle un poco de vidilla a sus códigos.

- 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 (http://es.wikipedia.org/wiki/Algoritmo_de_Dijkstra)
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


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)  


(http://upload.wikimedia.org/wikipedia/commons/thumb/1/1f/Depth-first-tree.svg/250px-Depth-first-tree.svg.png)

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.


vangodp, querido amigo, ahora voy a por ti. ;) ;) ;)

.................................................................
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:


MN0Q7qENjzA

En cambio más separaditos y con color:

bJjGYkufpPk

Código
  1. #include <iostream>
  2. #include <windows.h>
  3. #include <stdio.h>
  4. #include <time.h>
  5.  
  6. # define udir mapa[y-1][x]
  7. # define ldir mapa[y][x-1]
  8. # define rdir mapa[y][x+1]
  9. # define ddir mapa[y+1][x]
  10. # define po mapa[y][x]
  11. using namespace std;
  12.  
  13. const int TAMY = 24;
  14. const int TAMX = 28;
  15.  
  16. int contapasos = 0;
  17. void mostrar(char mapa[TAMY][TAMX]);
  18. void color (int n);
  19. int gotoxy(int x, int y);
  20.  
  21. void mostrar(char mapa[TAMY][TAMX]){
  22. system ("cls");
  23.    int x,y;
  24.     for( y=0;y<TAMY;y++)
  25.     {
  26.     for( x=0;x<TAMX-1;x++)
  27.     {
  28.     if ((y==TAMY-2 && x==TAMX-3) ||(x==1 && y==1))
  29.                color(195);
  30.            else if (x==0 || y==0 || x==TAMX-2 || y==TAMY-1)
  31.                color(125);
  32.            else if (mapa[y][x]=='0')
  33.                color(175);
  34.            else if (mapa[y][x]=='X'){
  35.              mapa[y][x]='2';
  36.              color(7);
  37.            }
  38.            else if (mapa[y][x]=='1'){
  39.              mapa[y][x]='1';
  40.              color(215);
  41.            }
  42.            else
  43.              color(7);
  44.            printf("%c ",mapa[y][x]);
  45.            fflush(stdout);
  46.  
  47.     //Sleep(5);
  48.     }
  49.     color(7);
  50.     putchar('\n');
  51.     //Sleep(5);
  52.     }
  53.  
  54. }
  55.  
  56.  int rand4 (){
  57. int n = (0 + rand() % 4);
  58. return n;
  59. }
  60.  
  61. void go_up ( char mapa[TAMY][TAMX], int &x , int &y ){
  62. po = '1';
  63. y--;
  64. po = 'X';
  65. }
  66.  
  67. void go_le ( char mapa[TAMY][TAMX], int &x , int &y ){
  68. po = '1';
  69. x--;
  70. po = 'X';
  71. }
  72.  
  73. void go_ri ( char mapa[TAMY][TAMX], int &x , int &y ){
  74. po = '1';
  75. x++;
  76. po = 'X';
  77. }
  78.  
  79. void go_do ( char mapa[TAMY][TAMX], int &x , int &y ){
  80. po = '1';
  81. y++;
  82. po = 'X';
  83. }
  84.  
  85.  
  86. int main (){
  87. //variables iniciales
  88. srand(time(NULL));
  89. system ("pause");
  90. int pasos = 0;
  91. bool nodir = true;
  92. bool fin = true;
  93. int x = 1; //posicion x inicial
  94. int y = 1; //posicion y inicial
  95. int rand;
  96. char mapa[TAMY][TAMX]={
  97.   //0123456789012345678901234567
  98. "000000000000000000000000000",//0
  99. "020222222222222222222222220",//1
  100. "020200000000000000000000020",//2
  101. "020222222222222200000000020",//3
  102. "020200000000000000000000020",//4
  103. "020222222222222200022222220",//5
  104. "020000000000000200020000020",//6
  105. "020222222222200200000000020",//7
  106. "020200000000200222222222020",//8
  107. "020222222200200000000002020",//9
  108. "020000000200222222222222020",//10
  109. "022222220200000000000000020",//11
  110. "020000020200222222222222220",//12
  111. "020000022200200000000000000",//13
  112. "000000000000200222222222220",//14
  113. "022222222222200200000000020",//15
  114. "020000000000000222222202020",//16
  115. "020000000000000200000202020",//17
  116. "022222222222222200000202020",//18
  117. "000000000000000000000202220",//19
  118. "022222222222222222222200000",//20
  119. "020000000000000000000000000",//21
  120. "0222222222222222222222222F0",//22
  121. "000000000000000000000000000" //23
  122.  
  123. };
  124. //obtenr cantidad maxima de pasos pocibles.
  125. for ( int fory = 0; fory <= TAMY; fory++  ){
  126. for ( int forx = 0; forx <= TAMX; forx++  ){
  127. if ( mapa[fory][forx] == '2' )
  128. pasos++;
  129. }
  130. }
  131. int xbackup[pasos];
  132. int ybackup[pasos];
  133.  
  134.  
  135. while ( fin ){
  136. while ( udir == '1' || ldir == '1' || rdir == '1' || ddir == '1' ){
  137. if ( udir == '2' || ldir == '2' || rdir == '2' || ddir == '2' ){
  138. break;
  139. }
  140.  
  141. contapasos--;
  142. mapa[y][x]='0';
  143. x = xbackup[contapasos];
  144. y = ybackup[contapasos];
  145. mapa[y][x]='X';
  146. mostrar( mapa );
  147. //Sleep ( 100 );
  148. }
  149.  
  150. contapasos++;
  151. xbackup[contapasos]= x;
  152. ybackup[contapasos]= y;
  153.  
  154. if( udir == '2' || ldir == '2' || rdir == '2' || ddir == '2' ){
  155.  
  156. do{
  157.  
  158. rand = rand4();
  159.  
  160.  
  161. if ( udir == '2' && ldir != '2' && rdir != '2' && ddir != '2' ){
  162. go_up( mapa, x, y );
  163. break;
  164. }
  165. else if ( udir != '2' && ldir == '2' && rdir != '2' && ddir != '2' ){
  166. go_le( mapa, x, y );
  167. break;
  168. }
  169. else if ( udir != '2' && ldir != '2' && rdir == '2' && ddir != '2' ){
  170. go_ri( mapa, x, y );
  171. break;
  172. }
  173. else if ( udir != '2' && ldir != '2' && rdir != '2' && ddir == '2' ){
  174. go_do( mapa, x, y );
  175. break;
  176. }
  177.  
  178. else if ( rand == 0 ){
  179. if ( udir == '0' || udir == '1' ){
  180. nodir = true;
  181. break;
  182. }
  183. else {
  184. go_up( mapa, x, y );
  185. nodir = false;
  186. }
  187.  
  188. }
  189. else if ( rand == 1 ){
  190. if ( ldir == '0' || ldir == '1' ){
  191. nodir = true;
  192. break;
  193. }
  194. else {
  195. go_le( mapa, x, y );
  196. nodir = false;
  197. }
  198.  
  199. }
  200. else if ( rand == 2 ){
  201. if ( rdir == '0' || rdir == '1' ){
  202. nodir = true;
  203. break;
  204.  
  205. }
  206. else {
  207. go_ri( mapa, x, y );
  208. nodir = false;
  209. }
  210.  
  211. }
  212. else if ( rand == 3 ){
  213. if ( ddir == '0' || ddir == '1' ){
  214. nodir = true;
  215. break;
  216. }
  217. else {
  218. go_do( mapa, x, y );
  219. nodir = false;
  220. }
  221.  
  222. }
  223.  
  224. }while( nodir );//FIN DOWHILE
  225.  
  226. }//FIN IF
  227. mostrar( mapa );
  228. Sleep ( 100 );
  229. }//FIN DEL LOOP
  230.  
  231. }
  232. void color (int n)
  233. {
  234.        SetConsoleTextAttribute(GetStdHandle (STD_OUTPUT_HANDLE), n );
  235. }
  236.  

** ¿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:


7e4W1uDc_Gk

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4. #include <windows.h>
  5. #define FIL 7
  6. #define COL 8
  7.  
  8. void color (int n);
  9. int gotoxy(int x, int y);
  10.  
  11. int main (){
  12.  
  13.  int i=0,j=0,k=0,fil=1,col=1;
  14.  char a[7][8];
  15.  system ("pause");
  16.  system ("cls");
  17.  for (i=0;i<15;i++){
  18.    gotoxy (10+2*i,10);
  19.    printf ("*" );
  20.  }
  21.  Sleep (2000);
  22.  for (i=0;i<15;i++){
  23.    Sleep (250);
  24.    gotoxy (10+2*i,10);
  25.    printf ("X" );
  26.  }
  27.  
  28.  
  29.  
  30.  puts("\n\n");
  31.  system ("pause");
  32.  system ("cls");
  33.  for (i=0;i<27;i++)
  34.    printf ( "* ");
  35.  putchar ('\n');
  36.  for (i=0;i<27;i++){
  37.    Sleep(150);
  38.    gotoxy (2*i,0);
  39.    printf ( "X ");
  40.  }
  41.  for (i=0;i<27;i++){
  42.    Sleep(100);
  43.    gotoxy (2*i,4);
  44.    printf ( "X");
  45.  }
  46.  for (i=0;i<6;i++){
  47.    for (j=0;j<6;j++){
  48.      gotoxy (2*j+6,i+6);
  49.      printf ( "* ");
  50.    }
  51.  }
  52.  for (i=0;i<6;i++){
  53.    for (j=0;j<6;j++){
  54.      Sleep(250);
  55.      gotoxy (2*j+6,i+6);
  56.      printf ( "X");
  57.    }
  58.  }
  59.  putchar ('\n');
  60.  system ("pause");
  61.  system ("cls");
  62.  for (i=0;i<7;i++){
  63.    a[i][7]='\0';
  64.    for (j=0;j<7;j++){
  65.      if(j>=i-1 && j<i+1 && j>0 && j<6 && i<6)
  66.        a[i][j]='X';
  67.      else if(i==0 || j==0 || i==6 || j==6 )
  68.        a[i][j]='*';
  69.      else
  70.        a[i][j]='0';
  71.    }
  72.  }
  73.  putchar ('\n');
  74.  for (i=0;i<7;i++){
  75.    a[i][7]='\0';
  76.    for (j=0;j<7;j++){
  77.      if((i==j || j==i-1) && i>0 && j<6 && j>0 && i<6)
  78.        a[i][j]='X';
  79.      else if(i==0 || j==0 || i==6 || j==6 )
  80.        a[i][j]='*';
  81.      else
  82.        a[i][j]='0';
  83.    }
  84.  }
  85.  gotoxy (0,10);
  86.  for (i=0;i<7;i++){
  87.    for (j=0;j<7;j++){
  88.      printf ("%c ",a[i][j]);
  89.    }
  90.    putchar ('\n');
  91.  }
  92.  system ("pause");
  93.  /*for (i=0;i<7;i++){
  94.     a[i][7]='\0';
  95.     for (j=0;j<7;j++){
  96.       if (i==0 || j==0 || i==6 || j==6 )
  97.         a[i][j]='*';
  98.       else if (i>=j)
  99.         a[i][j]='X';
  100.       else
  101.         a[i][j]='0';
  102.     }
  103.   }*/
  104.  for (i=0;i<7;i++)
  105.    printf ("%s\n",a[i]);
  106.  system ("pause");
  107.  gotoxy (0,0);
  108.  
  109.  for (i=0;i<7;i++){
  110.    for (j=0;j<7;j++){
  111.      printf ("%c ",a[i][j]);
  112.    }
  113.    putchar ('\n');
  114.  }
  115.  fil=1,col=1;
  116.  while  (1){
  117.    Sleep(1000);
  118.    if (fil==FIL-2 && col==COL-3){
  119.      gotoxy (2*col,fil);
  120.      printf("%c ",'F');
  121.      break;
  122.    }
  123.    else if (a[fil+1][col]=='X' && fil<FIL){
  124.      color(215);
  125.      gotoxy (2*col,fil);
  126.      printf("%c ",'F');fil++;
  127.    }
  128.    else if (a[fil][col+1]=='X' && col<COL){
  129.      color(215);
  130.      gotoxy (2*(col),fil);
  131.      printf("%c ",'F');col++;
  132.    }
  133.    else if (a[fil-1][col]=='X' && fil>0){
  134.      color(215);
  135.      gotoxy (2*(col),fil);
  136.      printf("%c ",'F');fil--;
  137.    }
  138.    else if (a[fil][col-1]=='X' && col>0){
  139.      color(215);
  140.      gotoxy (2*col,fil);
  141.      printf(" %c ",'F');col--;
  142.    }
  143.  }
  144.  color(7);
  145.  gotoxy (0,30);
  146.  printf ( "Final!");
  147.  putchar ('\n');
  148.  return 0;
  149. }
  150.  
  151. void color (int n)
  152. {
  153.        SetConsoleTextAttribute(GetStdHandle (STD_OUTPUT_HANDLE), n );
  154. }
  155.  
  156.  
  157. int gotoxy(int x, int y)
  158. {
  159.   COORD coord;
  160.   HANDLE h_stdout;
  161.  
  162.   coord.X = x;
  163.   coord.Y = y;
  164.  
  165.   if ((h_stdout = GetStdHandle(STD_OUTPUT_HANDLE)) == INVALID_HANDLE_VALUE)
  166.      return 0;
  167.  
  168.   if (SetConsoleCursorPosition(h_stdout, coord) == 0)
  169.      return 0;
  170.  
  171.   return 1;
  172. }
  173.  

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":

(http://i1280.photobucket.com/albums/a497/leosansan/GRAFICOS%202/laberintovandgopbug_zps75368580.jpg)
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:


7e4W1uDc_Gk

Código
  1. #include <iostream>
  2. #include <windows.h>
  3. #include <stdio.h>
  4. #include <time.h>
  5.  
  6. # define udir mapa[y-1][x]
  7. # define ldir mapa[y][x-1]
  8. # define rdir mapa[y][x+1]
  9. # define ddir mapa[y+1][x]
  10. # define po mapa[y][x]
  11. using namespace std;
  12.  
  13. const int TAMY = 24;
  14. const int TAMX = 28;
  15.  
  16. int contapasos = 0;
  17. void mostrar(char mapa[TAMY][TAMX]);
  18. void color (int n);
  19. int gotoxy(int x, int y);
  20.  
  21. void mostrar(char mapa[TAMY][TAMX]){
  22. system ("cls");
  23.    int x,y;
  24.     for( y=0;y<TAMY;y++)
  25.     {
  26.     for( x=0;x<TAMX-1;x++)
  27.     {
  28.     if ((y==TAMY-2 && x==TAMX-3) ||(x==1 && y==1))
  29.                color(195);
  30.            else if (x==0 || y==0 || x==TAMX-2 || y==TAMY-1)
  31.                color(125);
  32.            else if (mapa[y][x]=='0')
  33.                color(175);
  34.            else if (mapa[y][x]=='X'){
  35.              mapa[y][x]='2';
  36.              color(7);
  37.            }
  38.            else if (mapa[y][x]=='1'){
  39.              mapa[y][x]='1';
  40.              color(215);
  41.            }
  42.            else
  43.              color(7);
  44.            printf("%c ",mapa[y][x]);
  45.            fflush(stdout);
  46.  
  47.     //Sleep(5);
  48.     }
  49.     color(7);
  50.     putchar('\n');
  51.     //Sleep(5);
  52.     }
  53.  x=1,y=1;
  54.  while  (1){
  55.    Sleep(250);
  56.    if (y==TAMY-2 && x==TAMX-3 ){
  57.      gotoxy (2*x,y);
  58.      mapa[y][x]='1';
  59.      printf("%c ",'X');
  60.      break;
  61.    }
  62.    else if (mapa[y+1][x]=='2' && y<TAMY){
  63.      color(215);
  64.      gotoxy (2*x,y);
  65.      mapa[y][x]='1';
  66.      printf("%c ",'X');y++;
  67.    }
  68.    else if (mapa[y][x+1]=='2' && x<TAMX){
  69.      color(215);
  70.      mapa[y][x]='1';
  71.      gotoxy (2*(x),y);
  72.      printf("%c ",'X');x++;
  73.    }
  74.    else if (mapa[y-1][x]=='2' && y>0){
  75.      color(215);
  76.      mapa[y][x]='1';
  77.      gotoxy (2*(x),y);
  78.      printf("%c ",'X');y--;
  79.    }
  80.    else if (mapa[y][x-1]=='2' && x>0){
  81.      color(215);
  82.      mapa[y][x]='1';
  83.      gotoxy (2*x,y);
  84.      printf(" %c ",'X');x--;
  85.    }
  86.  }
  87.    color(55);
  88.    gotoxy (45,33);
  89.    printf ("\n\t¡¡¡FINAL!!!\t\t\n\n");
  90.    color(7);
  91.    system ("pause");
  92. }
  93.  
  94.  int rand4 (){
  95. int n = (0 + rand() % 4);
  96. return n;
  97. }
  98.  
  99. void go_up ( char mapa[TAMY][TAMX], int &x , int &y ){
  100. po = '1';
  101. y--;
  102. po = 'X';
  103. }
  104.  
  105. void go_le ( char mapa[TAMY][TAMX], int &x , int &y ){
  106. po = '1';
  107. x--;
  108. po = 'X';
  109. }
  110.  
  111. void go_ri ( char mapa[TAMY][TAMX], int &x , int &y ){
  112. po = '1';
  113. x++;
  114. po = 'X';
  115. }
  116.  
  117. void go_do ( char mapa[TAMY][TAMX], int &x , int &y ){
  118. po = '1';
  119. y++;
  120. po = 'X';
  121. }
  122.  
  123.  
  124. int main (){
  125. //variables iniciales
  126. srand(time(NULL));
  127. system ("pause");
  128. int pasos = 0;
  129. bool nodir = true;
  130. bool fin = true;
  131. int x = 1; //posicion x inicial
  132. int y = 1; //posicion y inicial
  133. int rand;
  134. char mapa[TAMY][TAMX]={
  135.   //0123456789012345678901234567
  136. "000000000000000000000000000",//0
  137. "020222222222222222222222220",//1
  138. "020200000000000000000000020",//2
  139. "020222222222222200000000020",//3
  140. "020200000000000000000000020",//4
  141. "020222222222222200022222220",//5
  142. "020000000000000200020000020",//6
  143. "020222222222200200000000020",//7
  144. "020200000000200222222222020",//8
  145. "020222222200200000000002020",//9
  146. "020000000200222222222222020",//10
  147. "022222220200000000000000020",//11
  148. "000000020200222222222222220",//12
  149. "000000022200200000000000000",//13
  150. "000000000000200222222222220",//14
  151. "022222222222200200000000020",//15
  152. "020000000000000222222202020",//16
  153. "020000000000000200000202020",//17
  154. "022222222222222200000202020",//18
  155. "000000000000000000000202220",//19
  156. "022222222222222222222200000",//20
  157. "020000000000000000000000000",//21
  158. "0222222222222222222222222F0",//22
  159. "000000000000000000000000000" //23
  160.  
  161. };
  162. //obtenr cantidad maxima de pasos pocibles.
  163. for ( int fory = 0; fory <= TAMY; fory++  ){
  164. for ( int forx = 0; forx <= TAMX; forx++  ){
  165. if ( mapa[fory][forx] == '2' )
  166. pasos++;
  167. }
  168. }
  169. int xbackup[pasos];
  170. int ybackup[pasos];
  171.  
  172.  
  173. while ( fin ){
  174. while ( udir == '1' || ldir == '1' || rdir == '1' || ddir == '1' ){
  175. if ( udir == '2' || ldir == '2' || rdir == '2' || ddir == '2' ){
  176. break;
  177. }
  178.  
  179. contapasos--;
  180. mapa[y][x]='0';
  181. x = xbackup[contapasos];
  182. y = ybackup[contapasos];
  183. mapa[y][x]='X';
  184. mostrar( mapa );
  185. //Sleep ( 100 );
  186. }
  187.  
  188. contapasos++;
  189. xbackup[contapasos]= x;
  190. ybackup[contapasos]= y;
  191.  
  192. if( udir == '2' || ldir == '2' || rdir == '2' || ddir == '2' ){
  193.  
  194. do{
  195.  
  196. rand = rand4();
  197.  
  198.  
  199. if ( udir == '2' && ldir != '2' && rdir != '2' && ddir != '2' ){
  200. go_up( mapa, x, y );
  201. break;
  202. }
  203. else if ( udir != '2' && ldir == '2' && rdir != '2' && ddir != '2' ){
  204. go_le( mapa, x, y );
  205. break;
  206. }
  207. else if ( udir != '2' && ldir != '2' && rdir == '2' && ddir != '2' ){
  208. go_ri( mapa, x, y );
  209. break;
  210. }
  211. else if ( udir != '2' && ldir != '2' && rdir != '2' && ddir == '2' ){
  212. go_do( mapa, x, y );
  213. break;
  214. }
  215.  
  216. else if ( rand == 0 ){
  217. if ( udir == '0' || udir == '1' ){
  218. nodir = true;
  219. break;
  220. }
  221. else {
  222. go_up( mapa, x, y );
  223. nodir = false;
  224. }
  225.  
  226. }
  227. else if ( rand == 1 ){
  228. if ( ldir == '0' || ldir == '1' ){
  229. nodir = true;
  230. break;
  231. }
  232. else {
  233. go_le( mapa, x, y );
  234. nodir = false;
  235. }
  236.  
  237. }
  238. else if ( rand == 2 ){
  239. if ( rdir == '0' || rdir == '1' ){
  240. nodir = true;
  241. break;
  242.  
  243. }
  244. else {
  245. go_ri( mapa, x, y );
  246. nodir = false;
  247. }
  248.  
  249. }
  250. else if ( rand == 3 ){
  251. if ( ddir == '0' || ddir == '1' ){
  252. nodir = true;
  253. break;
  254. }
  255. else {
  256. go_do( mapa, x, y );
  257. nodir = false;
  258. }
  259.  
  260. }
  261.  
  262. }while( nodir );//FIN DOWHILE
  263.  
  264. }//FIN IF
  265. mostrar( mapa );
  266. Sleep ( 100 );
  267. }//FIN DEL LOOP
  268.  
  269. }
  270. void color (int n)
  271. {
  272.        SetConsoleTextAttribute(GetStdHandle (STD_OUTPUT_HANDLE), n );
  273. }
  274.  
  275. int gotoxy(int x, int y)
  276. {
  277.   COORD coord;
  278.   HANDLE h_stdout;
  279.  
  280.   coord.X = x;
  281.   coord.Y = y;
  282.  
  283.   if ((h_stdout = GetStdHandle(STD_OUTPUT_HANDLE)) == INVALID_HANDLE_VALUE)
  284.      return 0;
  285.  
  286.   if (SetConsoleCursorPosition(h_stdout, coord) == 0)
  287.      return 0;
  288.  
  289.   return 1;
  290. }
  291.  

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:


VksBgSA54Zg

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4. #include <windows.h>
  5. #define COL 28
  6. #define FIL 27
  7.  
  8. void mostrar(char a[][COL],char *msg);
  9. void rellenar_laberinto (char  a[][COL], char b[][COL]);
  10. void color (int n);
  11. int gotoxy(int x, int y);
  12. void mostrar_despacio(char a[][COL],char b[][COL],char *msg);
  13.  
  14. int main (){
  15.  char a[FIL][COL],b[FIL][COL];
  16.  int i,j,x,y,incre_i,incre_j,cont=0,peso=0,c_peso=0,peso_i,flag=0;
  17.  srand((unsigned) time(NULL));
  18.  while (flag==0){
  19.  for( i=0;i<FIL;i++) {
  20.    for( j=0;j<COL-1;j++) {
  21.      if (i==0 || j==0 || i==FIL || j==COL-2)
  22.        a[i][j]=b[i][j]='*';
  23.      else
  24.        a[i][j]=b[i][j]='0';
  25.    }
  26.  }
  27.  a[1][1]='I';
  28.  a[FIL-2][COL-3]='F';
  29.  i=1,j=1;peso=12 ,c_peso=9,peso_i=3;
  30.  while (1){
  31.    x=rand()%peso;
  32.    if (x<peso_i)
  33.      incre_i=-1;
  34.    else if (x>=peso_i && x<c_peso)
  35.      incre_i=1;
  36.    else if (x>=c_peso && x<peso)
  37.      incre_i=0;
  38.    y=rand()%peso;
  39.      if (y<peso_i)
  40.        incre_j=-1;
  41.      else if (y>=peso_i && y<c_peso)
  42.        incre_j=1;
  43.      else if (y>=c_peso && y<peso)
  44.        incre_j=0;
  45.      if (((incre_i!=incre_j) && (incre_i!=-incre_j))  &&(a[i+incre_i][j+incre_j]=='0'  )
  46.        && (i>0 && i<FIL+1 && j>0  && j<COL-2)){
  47.        if ((i+incre_i>0) && (j+incre_j>0) && (i+incre_i<FIL) && (j+incre_j<COL-1)){
  48.          i+=incre_i;
  49.          j+=incre_j;
  50.        if ((i==FIL-1 && j==COL-2)||(i==FIL-3 && j==COL-3)){
  51.            a[i][j]='X';
  52.            flag++;
  53.            break;
  54.          }
  55.        else if ((i==2 && j==1) || (i==1 && j==2))
  56.          a[i][j]='X';
  57.        else if ((a[i][j]=='0' &&
  58.          (a[i+1][j]=='0' && a[i-1][j]=='0' && a[i][j+1]=='0' ) ||
  59.          (a[i+1][j]=='0' && a[i-1][j]=='0' && a[i][j-1]=='0' ) ||
  60.          (a[i][j+1]=='0' && a[i][j-1]=='0' && a[i+1][j]=='0' ) ||
  61.          (a[i][j+1]=='0' && a[i][j-1]=='0' && a[i-1][j]=='0' ))){
  62.            a[i][j]='X';
  63.            cont=0;
  64.          }
  65.        else {
  66.          i-=incre_i;
  67.          j-=incre_j;
  68.          cont++;
  69.          if (cont == 10)
  70.          break;
  71.          }
  72.        }
  73.      }
  74.    }
  75.  }
  76.  rellenar_laberinto (a, b);
  77.  //mostrar(b,"LABERINTO COLOR: ***ESTO ES OTRA COSA***");
  78.  for( i=0;i<FIL;i++)
  79.    for( j=0;j<COL-1;j++)
  80.      if (a[i][j]=='X')
  81.        b[i][j]='X';
  82.  //mostrar(b,"\tUNA SOLUCION");
  83.  system ("pause");
  84.  mostrar_despacio(a,b,"DESPACITO");
  85.  return 0;
  86. }
  87.  
  88. void rellenar_laberinto (char  a[][COL], char b[][COL]){
  89.  int i,j,x,peso=6 ,c_peso=3;
  90.  for( i=0;i<FIL;i++) {
  91.    for( j=0;j<COL-1;j++) {
  92.      if (i==0 || j==0 || i==FIL-1 || j==COL-2)
  93.        b[i][j]='*';
  94.      else if (a[i][j]=='X')
  95.        b[i][j]='2';
  96.      else {
  97.        x=rand()%peso;
  98.        if (x<peso-c_peso && x>=0)
  99.          b[i][j]='0';
  100.        else if (x>=peso-c_peso && x<peso)
  101.        b[i][j]='2';
  102.        b[1][1]='I';
  103.        b[FIL-2][COL-3]='F';
  104.      }
  105.    }
  106.  }
  107.  b[1][1]='I';
  108.  b[FIL-2][COL-3]='F';
  109. }
  110.  
  111. void mostrar(char mat[][COL],char *msg){
  112.  int i,j;
  113.  system ("cls");
  114.  system ("pause");
  115.  for( i=0;i<FIL;i++) {
  116.    for( j=0;j<COL-1;j++) {
  117.      if ((i==FIL-2 && j==COL-3) ||(i==1 && j==1))
  118.        color(195);
  119.      else if (i==0 || j==0 || i==FIL-1 || j==COL-2)
  120.        color(125);
  121.      else if (mat[i][j]=='0')
  122.        color(175);
  123.      else if (mat[i][j]=='X')
  124.        color(215);
  125.      else
  126.        color(7);
  127.      printf("%c ",mat[i][j]);
  128.      fflush(stdout);
  129.    }
  130.    putchar('\n');
  131.  }
  132.  color(55);
  133.  printf ("\n\n\nt%s\t\t\n\n",msg);
  134.  color(7);
  135.  system ("pause");
  136. }
  137.  
  138. void mostrar_despacio(char a[][COL],char b[][COL],char *msg){
  139.  int i,j,fil,col;
  140.  a[1][1]='X',a[FIL-2][COL-3]='X';
  141.  system ("cls");
  142.  for( i=0;i<FIL;i++)
  143.    for( j=0;j<COL-1;j++)
  144.      if (a[i][j]=='X')
  145.        b[i][j]='2';
  146.      else continue;
  147.  //mostrar(b,"\tcon doses");
  148.  system ("cls");
  149.  for( i=0;i<FIL;i++) {
  150.    for( j=0;j<COL-1;j++) {
  151.      if ((i==FIL-2 && j==COL-3) ||(i==1 && j==1))
  152.          color(195);
  153.      else if (i==0 || j==0 || i==FIL-1 || j==COL-2)
  154.        color(125);
  155.      else if (b[i][j]=='0')
  156.        color(175);
  157.      else if (a[i][j]=='X'){
  158.        b[i][j]='2';
  159.        color(7);
  160.      }
  161.      else
  162.        color(7);
  163.        printf("%c ",b[i][j]);
  164.        fflush(stdout);
  165.      }
  166.      putchar('\n');
  167.    }
  168.  
  169.  fil=1,col=1;
  170.  while  (1){
  171.    Sleep(1000);
  172.    if (fil==FIL-2 && col==COL-3 ){
  173.      gotoxy (2*col,fil);
  174.      a[fil][col]='0';
  175.      printf("%c ",'X');
  176.      break;
  177.    }
  178.    else if (a[fil+1][col]=='X' && fil<FIL){
  179.      color(215);
  180.      gotoxy (2*col,fil);
  181.      a[fil][col]='0';
  182.      printf("%c ",'X');fil++;
  183.    }
  184.    else if (a[fil][col+1]=='X' && col<COL){
  185.      color(215);
  186.      a[fil][col]='0';
  187.      gotoxy (2*(col),fil);
  188.      printf("%c ",'X');col++;
  189.    }
  190.    else if (a[fil-1][col]=='X' && fil>0){
  191.      color(215);
  192.      a[fil][col]='0';
  193.      gotoxy (2*(col),fil);
  194.      printf("%c ",'X');fil--;
  195.    }
  196.    else if (a[fil][col-1]=='X' && col>0){
  197.      color(215);
  198.      a[fil][col]='0';
  199.      gotoxy (2*col,fil);
  200.      printf(" %c ",'X');col--;
  201.    }
  202.  }
  203.  color(55);
  204.  gotoxy (45,28);
  205.  printf ("\n\t%s\t\t\n\n",msg);
  206.  color(7);
  207.  system ("pause");
  208. }
  209.  
  210.  
  211. void color (int n){
  212.  SetConsoleTextAttribute(GetStdHandle (STD_OUTPUT_HANDLE), n );
  213. }
  214.  
  215. int gotoxy(int x, int y){
  216.  COORD coord;
  217.  HANDLE h_stdout;
  218.  coord.X = x;
  219.  coord.Y = y;
  220.  if ((h_stdout = GetStdHandle(STD_OUTPUT_HANDLE)) == INVALID_HANDLE_VALUE)
  221.    return 0;
  222.  if (SetConsoleCursorPosition(h_stdout, coord) == 0)
  223.    return 0;
  224.  return 1;
  225. }
  226.  

Espero les haya gustado las observaciones y aportaciones.

Todo ha sido con ánimo constructivo, insisto. Nada de críticas, sólo observaciones.

Y espero que no decaiga el ánimo en el tema y sigamos juntos aprendiendo cositas.


¡¡¡¡ Saluditos! ..... !!!!


(http://st.forocoches.com/foro/images/smilies/aaaaa.gif)


Título: Re: Ayuda con programa urgente!
Publicado por: vangodp en 14 Enero 2014, 15:10 pm
joe leo! Que laburo te has pillao jeje.
Voy a por las gafas para echar un ojo ^^  ;-)


Título: Re: Ayuda con programa urgente!
Publicado por: vangodp en 14 Enero 2014, 15:31 pm
eh leído así por encima ya que en el código necesito tiempo.
Pero eso ya es la caña jejeej.
Uso x/y por las coordenadas de sdl XDD
Estoy acostumbrado con el sistema de coordenadas de esta librería  :rolleyes:
Me ha gustado la solucion del parpadeo.
No tengo experiencia con la api de Window$ XD
Pero me ha gustado bastante :D.
A lo mejor cuando tenga algo mas de experiencia le hacemos un 2d con un editor de mapas y to.
Me gusto bastante el post, lo guardo ^^.  ;-) ;-) ;-)