elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Los 10 CVE más críticos (peligrosos) de 2020


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  Ayuda con programa urgente!		0 Usuarios y 1 Visitante están viendo este tema.
Páginas: 1 [2] 3 4 5 6 Ir Abajo Respuesta Imprimir
Autor Tema: Ayuda con programa urgente!  (Leído 26,644 veces)
ivancea96


Desconectado Desconectado

Mensajes: 3.412


ASMático


Ver Perfil WWW
Re: Ayuda con programa urgente!
« Respuesta #10 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
En línea
Code0x66 - Blog de hacking & programación
vangodp


Desconectado Desconectado

Mensajes: 455



Ver Perfil
Re: Ayuda con programa urgente!
« Respuesta #11 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
En línea
Albertocn

Desconectado Desconectado

Mensajes: 11


Ver Perfil
Re: Ayuda con programa urgente!
« Respuesta #12 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. }
« Última modificación: 10 Diciembre 2013, 03:58 am por Albertocn » En línea
Albertocn

Desconectado Desconectado

Mensajes: 11


Ver Perfil
Re: Ayuda con programa urgente!
« Respuesta #13 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. }
En línea
vangodp


Desconectado Desconectado

Mensajes: 455



Ver Perfil
Re: Ayuda con programa urgente!
« Respuesta #14 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.  
« Última modificación: 10 Diciembre 2013, 13:02 pm por vangodp » En línea
leosansan


Desconectado Desconectado

Mensajes: 1.314


Ver Perfil
Re: Ayuda con programa urgente!
« Respuesta #15 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! ..... !!!!        
« Última modificación: 30 Diciembre 2013, 15:42 pm por leosansan » En línea
vangodp


Desconectado Desconectado

Mensajes: 455



Ver Perfil
Re: Ayuda con programa urgente!
« Respuesta #16 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
En línea
leosansan


Desconectado Desconectado

Mensajes: 1.314


Ver Perfil
Re: Ayuda con programa urgente!
« Respuesta #17 en: 10 Diciembre 2013, 19:57 pm »
Cita de: 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

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.

Cita de: vangodp en 10 Diciembre 2013, 18:18 pm
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! ..... !!!!        
« Última modificación: 10 Diciembre 2013, 21:46 pm por leosansan » En línea
vangodp


Desconectado Desconectado

Mensajes: 455



Ver Perfil
Re: Ayuda con programa urgente!
« Respuesta #18 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.
« Última modificación: 16 Diciembre 2013, 16:13 pm por vangodp » En línea
ivancea96


Desconectado Desconectado

Mensajes: 3.412


ASMático


Ver Perfil WWW
Re: Ayuda con programa urgente!
« Respuesta #19 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.
En línea
Code0x66 - Blog de hacking & programación
Páginas: 1 [2] 3 4 5 6 Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
AYUDA CON PROGRAMA EN PASCAL, ES UN URGENTE
Ejercicios 		juanf03 0 3,738 Último mensaje 15 Noviembre 2006, 01:25 am
por juanf03
Programa perdido y ayuda urgente
Dudas Generales 		Diaf96 6 3,441 Último mensaje 24 Abril 2011, 21:33 pm
por Diaf96
PROGRAMA EN PYTHON AYUDA URGENTE
Scripting 		viki_297 1 3,186 Último mensaje 15 Junio 2012, 03:22 am
por criskapunk
AYUDA URGENTE CON UN PROGRAMA C++
Programación C/C++ 		Ruth_cu 1 2,005 Último mensaje 12 Enero 2015, 04:16 am
por MCKSys Argentina
Ayuda urgente pls | Busco un programa con el que ganar siempre
Programación General 		!BART 0 2,399 Último mensaje 1 Marzo 2021, 23:55 pm
por !BART
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines