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)