SoloCodigo

bueno, estoy haciendo una practica de las torres de hanoi en la que un brazo robotico tiene que solucionarlo.

Pero tengo un problemalla con el algoritmo recursivo. (Perdonad que este en catalan pero creo q lo entendereis sin problemas)

if ((torre1->nom == 'A' || torre1->nom == 'B') && (torre2->nom == 'A' || torre2->nom == 'B'))
      torreAux=&torreC;
   else if((torre1->nom == 'A' || torre1->nom == 'C') && (torre2->nom == 'A' || torre2->nom == 'C'))
      torreAux=&torreB;
   else
      torreAux=&torreA;

   if(npeces!=1){
      MourePeces(torre1, torreAux, npeces-1);
      printf("n1er: Canviar la peça de la torre %c a la torre %c", torre1->nom, torre2->nom);
      CanviarPeca(torre1, torre2);
      MourePeces(torreAux, torre2, npeces-1);
   }
   else{
      printf("n2n: Canviar la peça de la torre %c a la torre %c", torre1->nom, torre2->nom);
      CanviarPeca(torre1, torre2);
   }
}

Esto me funciona para cuando el numero de piezas es par. Pero cuando el numero de piezas es impar las torres hay que cambiarlas.

Es decir. Si yo tengo 2 piezas muevo la primera a la torre auxiliar, la segunda al destino y la primera a destino. Y se acabo.
Si yo tengo 3 piezas la primera tiene que ir a destino, la segunda a auxiliar, la primera a auxiliar, la tercera a destino, etc...

Como veis el primer movimiento varia para torre auxiliar y destino.

Podeis darme algo de luz al problema?? me estoy volviendo loco !!!  

Muy buenas. Estoy haciendo una practica en la que un brazo robotico va a hacer el juego de las torres de hanoi.
Un compañero y yo estamos liados y no entendemos del todo estos trozos de codigo, q algunos nos los facilita el profesor.
 
void CalculaTorreC(Ttorre *torre1, Ttorre *torre2){
   torreC.pos[X]=(torre1->pos[X]+torre2->pos[X])/2;
   torreC.pos[Y]=(torre1->pos[Y]+torre2->pos[Y])/2;
   torreC.pos[YAW]= 0.F; //(float)atan2(torreC.pos[Y], torreC.pos[X]);
   torreC.pos[PITCH]= 90.F*GRAD2PI;
   torreC.pos[ROLL]= 0.F*GRAD2PI;
}

aqui lo q esta haciendo es determinar la posicion exacta de la torre C verdad?
pero porejemplo en [X] q hace? coge el valor de la [X] de torre uno y le suma la de torre 2 y la divide por 2? simplemente eso?

y este?

void PuntIntermedi(Ttorre *torrex, float puntintermedi[]){
   puntintermedi[X]= torrex->pos[X];
   puntintermedi[Y]= torrex->pos[Y];
   puntintermedi[Z]= z0 + 80;//z0 + (torrex->peces * 10) + 60;
   puntintermedi[YAW]= 0.F; //(float)atan2(puntintermedi[Y], puntintermedi[X]);
   puntintermedi[PITCH]= 90.F*GRAD2PI;
   puntintermedi[ROLL]=0.F*GRAD2PI;

GRAD2PI es esto "#define GRAD2PI (3.1415926535F/180.F)" pero no entiendo que representa q es "torrex", una variable??

y por ultimo... demomento xD

#define X 0
#define Y 1
#define Z 2
#define YAW 3
#define PITCH 4
#define ROLL 5

esto q pone arriba quiere decir q la X tendra valor 0 o q cuando escriba 0 entendera q es una X ??

bueno, a ver si me podeis hechar un cablecillo, soy bastante noob en esto  

mil gracias !!!!

muy buenas !!!

soy muy novato en el tema de la programacion en C++ y os pido ayuda para que me ayudaeis a interpretar un algoritmo.
Tengo que hacer el juego de las torres de Hanoi con un brazo robotico. El robot usara idioma RAPL-II

El profesor nos ha pasado esto:
-------------------------------------------------------------------------------------------------------------------------
Las Torres de Hanoi (RECURSIVA).
Esta practica trata de implementar el problema de las Torres de Hanoi de
manera recursiva. Se parte de unas condiciones iniciales conocidas (p. ex. Hay 6
piezas en una de las torres y las otras dos estan vacias) y el programa tiene que aceptar
reproducir acciones del tipo: “Mueve n piezas de la torre A a la torre B”. El algoritmo
recursivo que mueve N piezas de la Torre_A a la Torre_B, es el siguiente:


Mover_Piezas(Torre_A, Torre_B, Npiezas)
{

Torre_C= Otra_Torre(Torre_A, Torre_B)                       // Busca la torre auxiliar

Si (n!=1)
{
       Mover_Piezas(Torre_A, Torre_C, Npiezas-1);
       Cambiar_Pieza(Torre_A, Torre_B);                               // Mueve solo la pieza superior
       Mover_Piezas(Torre_C, Torre_B, Npiezas-1);
}

sinó
       Cambiar_Pieza(Torre_A, Torre_B);                               // Mueve solo la pieza superior


el tema esta en si me podrias explicar como funciona este algoritmo ya q no entiendo como trabaja.
Podrias decirme que variables deberia declarar?
"Mover_Piezas" , "Cambiar_Piezas" es una variable de estructura?

muchas gracias por adelnatado !!!!

P.D: si alguien tiene otro algoritmo donde crea q lo entenderia mejor...