Mensajes

bump

Si es recursivo no hay que hacer tanto.

El algoritmo para mover torres de un poste A a un poste C es el siguiente:

Simplementa hay que implementarlo al pie de la letra:

Código (cpp) [Seleccionar] Expandir

void Mover(char Inicial,char Auxiliar,char Destino,int N)
{
  if (N == 1)
      printf ("Moviendo disco %c al poste %c",Inicial,Destino);
  else
 {
    Mover(Inicial,Destino,Auxiliar,n-1); // Mover todos los discos -1 al auxiliar
    printf("Moviendo disco %c al poste %c",Inicial,Destino); // Moviendo el grande al final
   Mover(Auxiliar,Destino,Inicial,n-1); // Moviendo los discos desde el auxiliar al final
 }
}


Ponle de nombre a los postes A,B,C y haz la prueba.

Se me olvido especificar que la version que debo hacer es la que presenta los
movimientos de los discos y no la narrada.
Lo que quiero decir es que la version que tengo  es un paso previo a esto:

[youtube=640,360]http://www.youtube.com/watch?feature=player_embedded&v=xXTle8JYhys[/youtube]

Estoy trabajando con las torres de hanoi. Quisiera que me ayudaran a descifrar
por qué mi código no funciona como debería. Debo hacerla mediante funciones
recursivas y no puedo utilizar métodos iterativos.

Las funciones donde probablemente tenga el error son la g_MoverDiscos o g_TorreDeHanoiRecursiva.

En mi programa utilicé 3 arreglos unidimensionales para la "torres".
Uno que se llama Origen que se imprime a la izquierda, otro que se
llama intermedio que se imprime en el centro y el final se llama destino.

Dados 3 discos este debería ser el output del programa

1  0  0      0  0  0     0  0  0     0  0  0     0  0  0    0  0  0    0  0  0   0  0  1         
2  0  0      2  0  0     0  0  0     0  1  0     0  1  0    0  0  0    0  0  2   0  0  2
3  0  0      3  0  1     3  2  1     3  2  0     0  2  3    1  2  3    1  0  3   0  0  3
Inicio       paso 1      paso 2   paso 3     paso 4    paso 5    paso 6    paso 7

Esto es lo que me está imprimiendo
1  0  0      0  0  0     0  0  0     0  0  0     0  0  0    0  0  0    0  0  0   0  0  1         
2  0  0      2  0  0     0  0  0     0  0  1     0  0  1    0  0  0    0  2  0   0  0  2
3  0  0      3  0  1     3  2  1     0  3  2     0  3  2    2  3  1    0  3  1   0  0  3
Inicio       paso 1      paso 2   paso 3     paso 4    paso 5    paso 6    paso 7
                                           Error1       Error2     Error3    Error4     Correcto

Mientras escribia esto note que los errores  parecen de impresion. .
Cualquier ayuda es útil muchas gracias.

Aqui debajo pondre las funciones donde creo que tengo el problema

Código [Seleccionar] Expandir


#define kMAX 30
void g_MoverDiscos(int liFilas,int liNDiscos,
                   int liTorreOrigen[kMAX],int liTorreDestino[kMAX])
{
    int liPosOrigen =0;
    int liPosDestino=liFilas-1;

    //Busqueda de la posicio del menor disco en el origen
    while(liTorreOrigen[liPosOrigen]==0 && liPosOrigen<liFilas-1)
    {
        liPosOrigen++;
    }

    //Busqueda de la posicion del tope de la torre destino
    while(liTorreDestino[liPosDestino]!=0 && liPosDestino>0)//Menor o igual
    {
        liPosDestino--;
    }
    liTorreDestino[liPosDestino]=liTorreOrigen[liPosOrigen];//Transferencia del disco
    liTorreOrigen[liPosOrigen]=0;//Al moverse el disco esta posicion se hace cero.
}


void g_TorreDeHanoiRecursivo(int liFilas, int liNDiscos,int liTorreOrigen[kMAX],
                             int liTorreIntermedia[kMAX],int liTorreDestino[kMAX])
{

    if(liNDiscos==1)
    {

        g_MoverDiscos(liFilas, liNDiscos, liTorreOrigen, liTorreDestino);
        system("cls");
        g_ImprimirDiscos(liFilas, liTorreOrigen,
                         liTorreIntermedia, liTorreDestino);

    }//END if
    else
    {
        g_TorreDeHanoiRecursivo(liFilas, liNDiscos-1,liTorreOrigen,
                                liTorreDestino,liTorreIntermedia);

        g_MoverDiscos(liFilas, liNDiscos, liTorreOrigen, liTorreDestino);
        system("cls");
        g_ImprimirDiscos(liFilas, liTorreOrigen,
                          liTorreDestino,liTorreIntermedia);


        g_TorreDeHanoiRecursivo(liFilas, liNDiscos-1,liTorreIntermedia,
                                liTorreOrigen,liTorreDestino);
    }//END else
}//END g_TorreDeHanoiRecursivo




///
/// Estas son las demás funciones de mi programa (todas estas están bien)
///

Código [Seleccionar] Expandir


/// Esta es para leer los discos
int giLeerDiscos(void)
{
    int liN;
    do
    {
        printf("\nIndique la cantidad de discos: ");
        scanf("%d",&liN);
        if(liN<1||liN>kMAX_DISCOS)
        {
            system("cls");
            printf("ERROR.OPCION NO ES VALIDA. VUELVA A INTENTAR\n\n");
        }
    }while(liN<1||liN>kMAX_DISCOS);
    return liN;
}


//Funcion incializa los arreglos a la condicion  que deben tener antes de jugar
void g_CondicionInicialHanoi(int liNDiscos,int liTorreOrigen[kMAX],
                             int liTorreIntermedia[kMAX],int liTorreDestino[kMAX])
{
    int i;
    for (i=0;i<liNDiscos;i++)
    {
        liTorreOrigen[i]=i+1;       //Se colocan los discos desde el 1 en manera ascendente
        liTorreIntermedia[i]=0;     //Se hace cero
        liTorreDestino[i]=0;        //Se hace cero
    }
}


void g_ImprimirDiscos(int liFilas,int liTorreOrigen[kMAX],
                        int liTorreIntermedia[kMAX],int liTorreDestino[kMAX])
{
    int i;

    for (i=0;i<liFilas;i++)
    {

        printf("%d\t",liTorreOrigen[i]);
        printf("%d\t",liTorreIntermedia[i]);
        printf("%d\t",liTorreDestino[i]);
        printf("\n");
    }
}

int  main()
{
    int liTorreOrigen[kMAX];
    int liTorreIntermedia[kMAX];
    int liTorreDestino[kMAX];
    int liNDiscos;
    int liFilas; // Es igual al numero inicial de discos. Define el espacio
                 // de juego.


    liNDiscos=giLeerDiscos();
    liFilas=liNDiscos;
    //Condicion inicial del juego
    g_CondicionInicialHanoi(liNDiscos,liTorreOrigen,
                            liTorreIntermedia,liTorreDestino);

    //Imprimir condicion inicial del juego
    system("cls");
    g_ImprimirDiscos(liNDiscos,liTorreOrigen,
                     liTorreIntermedia,liTorreDestino);
    g_TorreDeHanoiRecursivo(liFilas, liNDiscos,liTorreOrigen,
                            liTorreIntermedia,liTorreDestino);
    printf("\n");
return 0;
}