Ayuda con programa urgente!

Iniciado por Albertocn, 8 Diciembre 2013, 17:52 PM

0 Miembros y 2 Visitantes están viendo este tema.

Imprimir
Ir Abajo Páginas1 2 3 4 5 6
Acciones del Usuario

Albertocn

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

Albertocn

#1
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();
    }

leosansan

#2
8 Diciembre 2013, 19:54 PM Ultima modificación: 8 Diciembre 2013, 21:22 PM por leosansan
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! ..... !!!!        

Albertocn

#3
9 Diciembre 2013, 03:11 AM
Gracias por el dato...a ver si ya sale mejor.
Código (cpp) [Seleccionar]
#include <stdio.h>
#include <conio.h>
#include <dos.h>
main()
{
clrscr();
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[x][y]);
delay(10);
}
printf("\n");
delay(12);
}
for(x=0;x<25;x++)
{
for(y=0;y<25;y++)
{
I
}
}
getch();
}

vangodp

#4
9 Diciembre 2013, 04:29 AM Ultima modificación: 9 Diciembre 2013, 04:35 AM por vangodp
Código (cpp) [Seleccionar]


int MAXCOL = 10;
int MAXFIL = 10;


char mapa[MAXCOL][MAXFIL]={
"XXXXXXXXXX",
"X00P00000X",
"XXXXXXXX0X",
"X00000000X",
"XXX0XXXXXX",
"X0000X000X",
"X0XX000X0X",
"X0XX0XXX0X",
"X0000XXX0F",//<-Aqui la 'F' de final XD
"XXXXXXXXXX",
};

// Dado lo de arriba sabemos que 0 esta por descubrir  
// y lo que ya hemos caminado es 1, pero aun no caminamos nada.
// Las X nunca deben cambiar ;) o romperíamos una pared XDD
// La 'F' es de final si la queremos, en tu caso quieres recorrer el mapa completo pero
//ya veremos como XD
// Sabemos que el personaje aparece en un determinado punto del array mapa.
// Ese punto es mapa [1][3]¿no? Desde este punto deberemos realizar nuestro calculo de recorrido.
// Veamos como podemos hacer:
// Antes que nada hay que tener claro como se va mover el personaje.
// En mi caso se va mover de izquierda a derecha y al contrario de derecha a izquierda.
// Y también lo va hacer hacia arriba y hacia abajo.
// Eso en cálculos seria mas o menos así:
// Si se mueve a la derecha aumenta, si se mueve a la izquierda disminuye ¿ok?
// Entonces hacemos así:
// Usaremos coordenadas X y coordenadas Y, muy usadas para hacer un videojuego :D
// Como funciona?

// Declaramos 2 variables para representar la posición del tipo entero.
// Le damos el valor inicial del mapa de arriba para que inicie donde queremos
int y = 1; //
int x = 3; //

// Eso hace que el personaje inicie en la P del mapa de arriba.
mapa[y][x]

// ahora bien creo que lo vas captando ya la intención:D
// Si aumentamos la coordenada x
// La P pasaría de estar en la casilla 3 para estar en la 4 ¿no?Seria mas o menos así:

// MAXCOL 0 "XXXXXXXXXX",
// MAXCOL 1 "X00P00000X",
//           01234....9
//           |||||_MAXFIL 4->Aquí se va poner la P si le sumamos +1:D
//           ||||__MAXFIL 3->Aquí esta la P ahora
//           |||___MAXFIL 2
//           ||____MAXFIL 1
//           |_____MAXFIL 0

//Una vez incrementada la x así se queda
// MAXCOL 0 "XXXXXXXXXX",
// MAXCOL 1 "X000P0000X",
//           01234....9
//           |||||_MAXFIL 4->Aquí se va poner la P si le sumamos +1:D
//           ||||__MAXFIL 3->Aquí estaba la P Y nuestro personaje ya estuvo aquí, tenia que ser 1
//           |||___MAXFIL 2
//           ||____MAXFIL 1
//           |_____MAXFIL 0

// Una vez desplazado el personaje la posición anterior debería quedar en 1
// Antes personaje estaba en mapa[1][3]...ahora esta en mapa[1][4]
// Y la posición mapa[1][3] antigua ahora queda así mapa[1][3]=1
// Bueno mas o menos lo pillamos ¿no?

// Ahora que sabemos como nos movemos pues queda ver los casos que podemos movernos.
// Ejemplo: si nos movemos solo de arriba abajo y de un lado a otro pues
//si quiero ir a la izquierda antes tengo que ver si en esa izquierda esta la X (pared) o
//si ya hemos estado ahí antes, o sea 1.

// Algo así en código:

// Digamos que estamos en la posición mapa[1][4] con el incremento del ejemplo anterior
// Para saber si nos podemos ir a mapa[1][5](Derecha) una forma puede ser:

if ( mapa[1][5] == 0 )
  x++;
 
// si queremos ir hacia abajo

if ( mapa[2][4] == 0 )
  y++;
 
// El 1(campo ya explorado) en realidad el 1 no imposibilita atravesar-lo.
// Imagine que llegues a un punto como este y salimos de la V:
//     XXXXXXXXXXXX
//     XV11111111PX
//     XXXXXX0XXXXX
//     X000000XXXXX

// Como ves la única forma de salir es volver hacia donde ya hemos pasado hasta llegar aquí:
//     XXXXXXXXXXXX
//     X11111P1111X
//     XXXXXX0XXXXX
//     X000000XXXXX

// Pues aquí el personaje puede ir hacia 3 direcciones, pero solo una es la buena
// Debes de hacer que prefiera la 0 envés de 1, pero si no hay remedio pues que pase
// por 1 hasta llegar a otro 0 :D

// Bien solo nos queda lo del final 'F'
// si lo que quieres es que encuentre el F antes de terminar bien caso contrario puedes
//poner una validación de si no encontrado todos los 0 no puedes salir
// O simplemente si todo los ceros se terminaron pues FIN XD
// Eso es un poco de lógica de videojuegos.
// No se si te sirve pero es algo :D


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

Albertocn

#5
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....

vangodp

#6
9 Diciembre 2013, 05:48 AM
Que es eso:
for(y=0;y<25;y++)
{
I   //Eso me da error
}

vangodp

#7
9 Diciembre 2013, 06:01 AM
Código (cpp) [Seleccionar]

    #include <stdio.h>
    #include <conio.h>
    #include <dos.h>
    #include <windows.h>
    main()
    {
system("cls");
    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[x][y]);
    Sleep(50);
    }
    printf("\n");
    Sleep(50);
    }
   
   
system("pause");

}


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?

vangodp

#8
9 Diciembre 2013, 10:25 AM
Código (cpp) [Seleccionar]

#include <stdio.h>
#include <conio.h>
#include <dos.h>
#include <windows.h>

#define t Sleep(200)


void mostrar(char mapa[26][26]){
system ("cls");

    for(int y=0;y<25;y++)
    {
    for(int x=0;x<25;x++)
    {
    printf("%c",mapa[y][x]);
    //Sleep(1);
    }
    printf("\n");
    //Sleep(1);
    }
   
}

int main (){

char mapa[26][26]={
"0000000000000000000000000",
"1111110000000000000000000",
"0000010000000000000000000",
"0000010000000000000000000",
"0000011100000000000000000",
"0000000100000000000000000",
"0000000100000000000000000",
"0000000110000000000000000",
"0000000011111100000000000",
"0000000000000100000000000",
"0000011111111100000000000",
"0000010000000000000000000",
"0000010000000000000000000",
"1111110000000000000000000",
"1000000000000000000000000",
"1000000000000000000000000",
"1111111111111111000000000",
"0000000000000001000000000",
"0000000000000001111100000",
"0000000000000000000100000",
"0000000000000000111100000",
"0000000001111111100000000",
"0000000001000000000000000",
"0000000001000000011111110",
"0000000001111111110000000",
};


mapa[1][0]='X';//1.0 hacia la 1.5
mostrar(mapa);
t;


mapa[1][1]='X';//1.1
mostrar(mapa);
t;


mapa[1][2]='X';//1.2
mostrar(mapa);
t;


mapa[1][3]='X';//1.3
mostrar(mapa);
t;


mapa[1][4]='X';//1.4
mostrar(mapa);
t;


mapa[1][5]='X';//1.5 hacia la 4.5
mostrar(mapa);
t;

mapa[2][5]='X';//2.5
mostrar(mapa);
t;

mapa[3][5]='X';//3.5
mostrar(mapa);
t;

mapa[4][5]='X';//4.5 Hacia 4.7
mostrar(mapa);
t;

mapa[4][6]='X';//4.6
mostrar(mapa);
t;

mapa[4][7]='X';//4.7 hacia 7.7
mostrar(mapa);
t;

mapa[5][7]='X';//5.7
mostrar(mapa);
t;

mapa[6][7]='X';//6.7
mostrar(mapa);
t;

mapa[7][7]='X';//7.7 hacia 7.8
mostrar(mapa);
t;

mapa[7][8]='X';//7.8 hacia 8.8
mostrar(mapa);
t;

mapa[8][8]='X';//8.8 hacia 8.13
mostrar(mapa);
t;

mapa[8][9]='X';//8.9
mostrar(mapa);
t;

mapa[8][10]='X';//8.10
mostrar(mapa);
t;

mapa[8][11]='X';//8.11
mostrar(mapa);
t;

mapa[8][12]='X';//8.12
mostrar(mapa);
t;

mapa[8][13]='X';//8.13 hacia 10.13
mostrar(mapa);
t;

mapa[9][13]='X';//9.13
mostrar(mapa);
t;

mapa[10][13]='X';//10.13 hacia 10.5
mostrar(mapa);
t;

mapa[10][12]='X';//10.12
mostrar(mapa);
t;

mapa[10][11]='X';//10.11
mostrar(mapa);
t;

mapa[10][10]='X';//10.10
mostrar(mapa);
t;

mapa[10][9]='X';//10.9
mostrar(mapa);
t;

mapa[10][8]='X';//10.8
mostrar(mapa);
t;

mapa[10][7]='X';//10.7
mostrar(mapa);
t;

mapa[10][6]='X';//10.6
mostrar(mapa);
t;

mapa[10][5]='X';//10.5 hacia 13.5
mostrar(mapa);
t;

mapa[11][5]='X';//11.5
mostrar(mapa);
t;

mapa[12][5]='X';//12.5
mostrar(mapa);
t;

mapa[13][5]='X';//13.5 hacia 13.0
mostrar(mapa);
t;

mapa[13][4]='X';//13.4
mostrar(mapa);
t;

mapa[13][3]='X';//13.3
mostrar(mapa);
t;

mapa[13][2]='X';//13.2
mostrar(mapa);
t;

mapa[13][1]='X';//13.1
mostrar(mapa);
t;

mapa[13][0]='X';//13.0 hacia 16.0
mostrar(mapa);
t;

mapa[14][0]='X';//14.0
mostrar(mapa);
t;

mapa[15][0]='X';//15.0
mostrar(mapa);
t;

mapa[16][0]='X';//16.0 // hacia 16.15
mostrar(mapa);
t;

mapa[16][1]='X';//16.1
mostrar(mapa);
t;

mapa[16][2]='X';//16.2
mostrar(mapa);
t;

mapa[16][3]='X';//16.3
mostrar(mapa);
t;

mapa[16][4]='X';//16.4
mostrar(mapa);
t;

mapa[16][5]='X';//16.5
mostrar(mapa);
t;

mapa[16][6]='X';//16.6
mostrar(mapa);
t;

mapa[16][7]='X';//16.7
mostrar(mapa);
t;

mapa[16][8]='X';//16.8
mostrar(mapa);
t;

mapa[16][9]='X';//16.9
mostrar(mapa);
t;

mapa[16][10]='X';//16.10
mostrar(mapa);
t;

mapa[16][11]='X';//16.11
mostrar(mapa);
t;

mapa[16][12]='X';//16.12
mostrar(mapa);
t;

mapa[16][13]='X';//16.13
mostrar(mapa);
t;

mapa[16][14]='X';//16.14
mostrar(mapa);
t;

mapa[16][15]='X';//16.15 hacia 18.15
mostrar(mapa);
t;

mapa[17][15]='X';//17.15
mostrar(mapa);
t;

mapa[18][15]='X';//18.15 hacia 18.19
mostrar(mapa);
t;

mapa[18][16]='X';//18.16
mostrar(mapa);
t;

mapa[18][17]='X';//18.17
mostrar(mapa);
t;

mapa[18][18]='X';//18.18
mostrar(mapa);
t;

mapa[18][19]='X';//18.19 hacia 20.19
mostrar(mapa);
t;

mapa[19][19]='X';//19.19
mostrar(mapa);
t;

mapa[20][19]='X';//20.19 hacia 20.16
mostrar(mapa);
t;

mapa[20][18]='X';//20.18
mostrar(mapa);
t;

mapa[20][17]='X';//20.17
mostrar(mapa);
t;

mapa[20][16]='X';//20.16 hacia 21.16
mostrar(mapa);
t;

mapa[21][16]='X';//21.16 hacia 21.9
mostrar(mapa);
t;

mapa[21][15]='X';//21.15
mostrar(mapa);
t;

mapa[21][14]='X';//21.14
mostrar(mapa);
t;

mapa[21][13]='X';//21.13
mostrar(mapa);
t;

mapa[21][12]='X';//21.12
mostrar(mapa);
t;

mapa[21][11]='X';//21.11
mostrar(mapa);
t;

mapa[21][10]='X';//21.10
mostrar(mapa);
t;

mapa[21][9]='X';//21.9 hacia 24.9
mostrar(mapa);
t;

mapa[22][9]='X';//22.9
mostrar(mapa);
t;

mapa[23][9]='X';//23.9
mostrar(mapa);
t;

mapa[24][9]='X';//24.9 hacia 24.17*
mostrar(mapa);
t;

mapa[24][10]='X';//24.10
mostrar(mapa);
t;

mapa[24][11]='X';//24.11
mostrar(mapa);
t;

mapa[24][12]='X';//24.12
mostrar(mapa);
t;

mapa[24][13]='X';//24.13
mostrar(mapa);
t;

mapa[24][14]='X';//24.14
mostrar(mapa);
t;

mapa[24][15]='X';//24.15
mostrar(mapa);
t;

mapa[24][16]='X';//24.16
mostrar(mapa);
t;

mapa[24][17]='X';//24.17 hacia 23.17
mostrar(mapa);
t;

mapa[23][17]='X';//23.17 hacia 23.24
mostrar(mapa);
t;

mapa[23][18]='X';//23.18
mostrar(mapa);
t;

mapa[23][19]='X';//23.19
mostrar(mapa);
t;

mapa[23][20]='X';//23.20
mostrar(mapa);
t;

mapa[23][21]='X';//23.21
mostrar(mapa);
t;

mapa[23][22]='X';//23.22
mostrar(mapa);
t;

mapa[23][23]='X';//23.23
mostrar(mapa);
t;

mapa[23][24]='X';//23.24 Fin
mostrar(mapa);
t;

}


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

Albertocn

#9
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....
Imprimir
Ir Arriba Páginas1 2 3 4 5 6
Acciones del Usuario