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

 

 


Tema destacado: Usando Git para manipular el directorio de trabajo, el índice y commits (segunda parte)


+  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 20,293 veces)
Albertocn

Desconectado Desconectado

Mensajes: 11


Ver Perfil
Ayuda con programa urgente!
« 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



En línea

Albertocn

Desconectado Desconectado

Mensajes: 11


Ver Perfil
Re: Ayuda con programa urgente!
« Respuesta #1 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();
}


En línea

leosansan


Desconectado Desconectado

Mensajes: 1.314


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

Albertocn

Desconectado Desconectado

Mensajes: 11


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

vangodp


Desconectado Desconectado

Mensajes: 455



Ver Perfil
Re: Ayuda con programa urgente!
« Respuesta #4 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
« Última modificación: 9 Diciembre 2013, 04:35 am por vangodp » En línea

Albertocn

Desconectado Desconectado

Mensajes: 11


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

vangodp


Desconectado Desconectado

Mensajes: 455



Ver Perfil
Re: Ayuda con programa urgente!
« Respuesta #6 en: 9 Diciembre 2013, 05:48 am »

Que es eso:
for(y=0;y<25;y++)
{
I   //Eso me da error
}
En línea

vangodp


Desconectado Desconectado

Mensajes: 455



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

vangodp


Desconectado Desconectado

Mensajes: 455



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

Albertocn

Desconectado Desconectado

Mensajes: 11


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

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 2,779 Último mensaje 15 Noviembre 2006, 01:25 am
por juanf03
Programa perdido y ayuda urgente
Dudas Generales
Diaf96 6 2,429 Último mensaje 24 Abril 2011, 21:33 pm
por Diaf96
PROGRAMA EN PYTHON AYUDA URGENTE
Scripting
viki_297 1 2,483 Último mensaje 15 Junio 2012, 03:22 am
por criskapunk
AYUDA URGENTE CON UN PROGRAMA C++
Programación C/C++
Ruth_cu 1 1,373 Ú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 1,063 Último mensaje 1 Marzo 2021, 23:55 pm
por !BART
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines