Foros del Web » Programación para mayores de 30 ;) » C/C++ »

Torres de hanoi

 Estas en el tema de Torres de hanoi en el foro de C/C++ en Foros del Web. Saludos, Esto actualmente es mi proyecto en la uni, No deseo que me lo hagan, Solo necesito que me asesoren que es lo que tengo ...
  #1 (permalink)  
Antiguo 17/07/2011, 07:00
 
Fecha de Ingreso: enero-2011
Mensajes: 33
Antigüedad: 13 años, 3 meses
Puntos: 0
Torres de hanoi
Saludos, Esto actualmente es mi proyecto en la uni, No deseo que me lo hagan, Solo necesito que me asesoren que es lo que tengo que hacer ya que no entiendo como implementar el juego para que el usuario lo use, Saludos!... Los codigos que he encontrado son Complicados... Tiene que ser recursivo...
  #2 (permalink)  
Antiguo 17/07/2011, 09:24
 
Fecha de Ingreso: enero-2011
Mensajes: 33
Antigüedad: 13 años, 3 meses
Puntos: 0
Respuesta: Torres de hanoi
Actualmente esto es lo que tengo:


Código C: 
Ver original
  1. struct HANOI{
  2.   int tope;
  3.   int disco[10];
  4. };
  5. //-----------------------------------------------------------------------------
  6. //                                  INICIALIZAR PILA
  7. //-----------------------------------------------------------------------------
  8. void inicializar(struct HANOI *pila)
  9. {
  10. int i;
  11. pila->tope = 0;
  12. for (i=0 ; i<11 ; i++)
  13. pila->disco[i]=0;
  14. }
  15. //-----------------------------------------------------------------------------
  16. //                                      EMPEZAR
  17. //-----------------------------------------------------------------------------
  18. void empezar(int n, struct HANOI *pila)
  19. {
  20. int y;
  21. int i;
  22. y=n;
  23.  for(i=0 ; i<n ; i++ )
  24.  {
  25.  pila->disco[pila->tope] = y; pila->tope++;y--;
  26.  }
  27. }
  28. //-----------------------------------------------------------------------------
  29. void imprimir(int n,struct HANOI *pila1 , struct HANOI *pila2, struct HANOI *pila3)
  30. {
  31. clrscr();
  32. int y=17;
  33. int cont1=0;
  34. int cont2=0;
  35. int cont3=0;
  36. char a=219;
  37. int x1=5;
  38. int x2=30;
  39. int x3=55;
  40. int i;
  41. int k;
  42. int m;
  43. int r;
  44.   for (i=0; i<n ; i++)
  45.     {
  46.      gotoxy(x1,y);
  47.  
  48.      for(k=0 ; k < pila1->disco[cont1] ; k++)
  49.       { printf("%c",a);
  50.  
  51.     printf("%c",a);
  52.       }
  53.      cont1++;
  54.      x1++;
  55.  
  56.  
  57.      gotoxy(x2,y);
  58.      for(m=0 ; m < pila2->disco[cont2] ; m++)
  59.       {
  60.     printf("%c", a);
  61.       }
  62.      cont2++;
  63.      x2++;
  64.  
  65.      gotoxy(x3,y);
  66.      for(r=0 ; r < pila3->disco[cont3] ; r++)
  67.       {
  68.     printf("%c", a);
  69.       }
  70.      cont3++;
  71.      x3++;
  72.  
  73.      y--;
  74.  
  75.     gotoxy(x1,(y-2));
  76.   }
  77.  
  78.   getch();
  79. }
  80.  
  81.  
  82. //-----------------------------------------------------------------------------
  83. //                                      HANOI
  84. //-----------------------------------------------------------------------------
  85. void funcion_hanoi(int n, struct HANOI *pila1 , struct HANOI *pila2 , struct HANOI *pila3)
  86. {
  87. int vacio,mayor,menor;
  88. int cuenta_mov=0;
  89. if (n % 2 == 0 )
  90. {
  91.  char x='1';
  92.   do
  93.   {
  94.    switch(x)
  95.      {
  96.        case '1':
  97.           pila2->disco[pila2->tope]=pila1->disco[(pila1->tope)-1];
  98.           pila1->disco[(pila1->tope)-1]=0;
  99.           pila2->tope=(pila2->tope)+1;
  100.           pila1->tope=(pila1->tope)-1;
  101.           x='2';
  102.           imprimir(n,pila1,pila2,pila3);
  103.           cuenta_mov++;
  104.           break;
  105.  
  106.        case '2':
  107.           pila3->disco[pila3->tope]=pila2->disco[(pila2->tope)-1];
  108.           pila2->disco[(pila2->tope)-1]=0;
  109.           pila3->tope=(pila3->tope)+1;
  110.           pila2->tope=(pila2->tope)-1;
  111.           x='3';
  112.           imprimir(n,pila1,pila2,pila3);
  113.           cuenta_mov++;
  114.           if ( pila3->tope == n )
  115.           {
  116.            gotoxy(37,20);printf("Listo!");
  117.            gotoxy(33,21);printf("MOVIMIENTOS: %d", cuenta_mov);
  118.            getch();
  119.            exit(1);
  120.           }
  121.  
  122.           break;
  123.        case '3':
  124.           pila1->disco[pila1->tope]=pila3->disco[(pila3->tope)-1];
  125.           pila3->disco[(pila3->tope)-1]=0;
  126.           pila1->tope=(pila1->tope)+1;
  127.           pila3->tope=(pila3->tope)-1;
  128.           x='1';
  129.           imprimir(n,pila1,pila2,pila3);
  130.           cuenta_mov++;
  131.           break;
  132.      };
  133.   char aux=x;
  134.      switch(aux)
  135.      {
  136.        case '1':
  137.  
  138.           if((pila2->disco[(pila2->tope)-1] < pila3->disco[(pila3->tope)-1]) || pila3->tope == 0)
  139.           {
  140.            pila3->disco[pila3->tope]=pila2->disco[(pila2->tope)-1];
  141.            pila2->disco[(pila2->tope)-1]=0;
  142.            pila3->tope=(pila3->tope)+1;
  143.            pila2->tope=(pila2->tope)-1;
  144.  
  145.           }
  146.           else
  147.           {
  148.            pila2->disco[pila2->tope]=pila3->disco[(pila3->tope)-1];
  149.            pila3->disco[(pila3->tope)-1]=0;
  150.            pila3->tope=(pila3->tope)-1;
  151.            pila2->tope=(pila2->tope)+1;
  152.           }
  153.           imprimir(n,pila1,pila2,pila3);
  154.           cuenta_mov++;
  155.           break;
  156.       case '2':
  157.           if((pila1->disco[(pila1->tope)-1] < pila3->disco[(pila3->tope)-1]) || pila3->tope == 0)
  158.           {
  159.            pila3->disco[pila3->tope]=pila1->disco[(pila1->tope)-1];
  160.            pila1->disco[(pila1->tope)-1]=0;
  161.            pila3->tope=(pila3->tope)+1;
  162.            pila1->tope=(pila1->tope)-1;
  163.           }
  164.           else
  165.           {
  166.            pila1->disco[pila1->tope]=pila3->disco[(pila3->tope)-1];
  167.            pila3->disco[(pila3->tope)-1]=0;
  168.            pila1->tope=(pila1->tope)+1;
  169.            pila3->tope=(pila3->tope)-1;
  170.           }
  171.           cuenta_mov++;
  172.           imprimir(n,pila1,pila2,pila3);
  173.           break;
  174.  
  175.        case '3':
  176.           if(((pila1->disco[(pila1->tope)-1] < pila2->disco[(pila2->tope)-1]) && pila1->tope!=0) || pila2->tope == 0)
  177.           {
  178.            pila2->disco[pila2->tope]=pila1->disco[(pila1->tope)-1];
  179.            pila1->disco[(pila1->tope)-1]=0;
  180.            pila2->tope=(pila2->tope)+1;
  181.            pila1->tope=(pila1->tope)-1;
  182.           }
  183.           else
  184.           {
  185.            pila1->disco[pila1->tope]=pila2->disco[(pila2->tope)-1];
  186.            pila2->disco[(pila2->tope)-1]=0;
  187.            pila1->tope=(pila1->tope)+1;
  188.            pila2->tope=(pila2->tope)-1;
  189.           }
  190.           imprimir(n,pila1,pila2,pila3);
  191.           cuenta_mov++;
  192.           break;
  193.  
  194.      };
  195.  
  196.   }while(pila3->tope != n );
  197. }
  198. else
  199. {
  200.  char x='1';
  201.   while(pila3->tope != n )
  202.   {
  203.    switch(x)
  204.      {
  205.        case '1':
  206.           pila3->disco[pila3->tope]=pila1->disco[(pila1->tope)-1];
  207.           pila1->disco[(pila1->tope)-1]=0;
  208.           pila3->tope=(pila3->tope)+1;
  209.           pila1->tope=(pila1->tope)-1;
  210.           x='3';
  211.           imprimir(n,pila1,pila2,pila3);
  212.           cuenta_mov++;
  213.           if ( pila3->tope == n )
  214.           {
  215.            gotoxy(37,20);printf("Listo!");
  216.            gotoxy(33,21);printf("MOVIMIENTOS: %d", cuenta_mov);
  217.            getch();
  218.            exit(1);
  219.           }
  220.  
  221.           break;
  222.  
  223.        case '2':
  224.           pila1->disco[pila1->tope]=pila2->disco[(pila2->tope)-1];
  225.           pila2->disco[(pila2->tope)-1]=0;
  226.           pila1->tope=(pila1->tope)+1;
  227.           pila2->tope=(pila2->tope)-1;
  228.           x='1';
  229.           imprimir(n,pila1,pila2,pila3);
  230.           cuenta_mov++;
  231.           break;
  232.        case '3':
  233.           pila2->disco[pila2->tope]=pila3->disco[(pila3->tope)-1];
  234.           pila3->disco[(pila3->tope)-1]=0;
  235.           pila2->tope=(pila2->tope)+1;
  236.           pila3->tope=(pila3->tope)-1;
  237.           x='2';
  238.           imprimir(n,pila1,pila2,pila3);
  239.           cuenta_mov++;
  240.           break;
  241.      };
  242.   char aux=x;
  243.      switch(aux)
  244.      {
  245.        case '1':
  246.  
  247.           if((pila2->disco[(pila2->tope)-1] < pila3->disco[(pila3->tope)-1]) || pila3->tope == 0)
  248.           {
  249.            pila3->disco[pila3->tope]=pila2->disco[(pila2->tope)-1];
  250.            pila2->disco[(pila2->tope)-1]=0;
  251.            pila3->tope=(pila3->tope)+1;
  252.            pila2->tope=(pila2->tope)-1;
  253.           }
  254.           else
  255.           {
  256.            pila2->disco[pila2->tope]=pila3->disco[(pila3->tope)-1];
  257.            pila3->disco[(pila3->tope)-1]=0;
  258.            pila3->tope=(pila3->tope)-1;
  259.            pila2->tope=(pila2->tope)+1;
  260.           }
  261.           cuenta_mov++;
  262.           imprimir(n,pila1,pila2,pila3);
  263.           break;
  264.       case '2':
  265.           if((pila1->disco[(pila1->tope)-1] < pila3->disco[(pila3->tope)-1]) || pila3->tope == 0)
  266.           {
  267.            pila3->disco[pila3->tope]=pila1->disco[(pila1->tope)-1];
  268.            pila1->disco[(pila1->tope)-1]=0;
  269.            pila3->tope=(pila3->tope)+1;
  270.            pila1->tope=(pila1->tope)-1;
  271.           }
  272.           else
  273.           {
  274.            pila1->disco[pila1->tope]=pila3->disco[(pila3->tope)-1];
  275.            pila3->disco[(pila3->tope)-1]=0;
  276.            pila1->tope=(pila1->tope)+1;
  277.            pila3->tope=(pila3->tope)-1;
  278.           }
  279.           cuenta_mov++;
  280.           imprimir(n,pila1,pila2,pila3);
  281.           break;
  282.  
  283.        case '3':
  284.           if(((pila1->disco[(pila1->tope)-1] < pila2->disco[(pila2->tope)-1]) && pila1->tope!=0) || pila2->tope == 0)
  285.           {
  286.            pila2->disco[pila2->tope]=pila1->disco[(pila1->tope)-1];
  287.            pila1->disco[(pila1->tope)-1]=0;
  288.            pila2->tope=(pila2->tope)+1;
  289.            pila1->tope=(pila1->tope)-1;
  290.           }
  291.           else
  292.           {
  293.            pila1->disco[pila1->tope]=pila2->disco[(pila2->tope)-1];
  294.            pila2->disco[(pila2->tope)-1]=0;
  295.            pila1->tope=(pila1->tope)+1;
  296.            pila2->tope=(pila2->tope)-1;
  297.           }
  298.           cuenta_mov++;
  299.           imprimir(n,pila1,pila2,pila3);
  300.           break;
  301.  
  302.      };
  303.  
  304.   }
  305. }
  306. }

Lo que quisiera saber es si no hay una manera mas "Simple"... De que el programa muestre los movimientos a realizar de las torres, ya que esto lo tengo que defender... y con todas esas pilas no entiendo nada....
  #3 (permalink)  
Antiguo 17/07/2011, 12:55
 
Fecha de Ingreso: junio-2008
Ubicación: Seattle, USA
Mensajes: 733
Antigüedad: 15 años, 10 meses
Puntos: 61
Respuesta: Torres de hanoi
Pediste que no te lo hagan y que te asesoren, aqui va mi asesoria:

Si los n aros estan en la pila A ( siendo las pilas A, B y C), y se desean mover todos ellos a la pila B, entonces bastaria con mover los n-1 aros de arriba a la pila C, luego mover el unico aro que queda a la pila B y luego mover los n-1 aros desde la pila C a la B,
osea para resolver el problema con tamaño n, hay que resolverlo 2 veces con tamaño n-1 y 1 vez con tamaño 1.

En definitiva, si existiera una funcion recursiva que supiera lo que hay que hacer con n aros, ella en realidad solo sabria:
- como mover 1 aro desde un lugar a otro (facil)
- como mover n aros, desde un lugar a otro ( invocandose a si misma 3 veces )

Una funcion que resuelve el problema de las torres de hanoi seria tan corto como estas 4 instrucciones, encerradas en un if-else, que discrimina entre el caso facil y el no facil.

Etiquetas: Ninguno
Atención: Estás leyendo un tema que no tiene actividad desde hace más de 6 MESES, te recomendamos abrir un Nuevo tema en lugar de responder al actual.
Respuesta


« Tema Anterior | Próximo Tema »


La zona horaria es GMT -6. Ahora son las 19:56.