[ansi c] torres de hanoi

[razpeitia]

Yo se regex.

Código C:

#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
 
/// 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;
}