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

[SOLUCIONADO] Torres de Hanoi gráficas recursivas

 Estas en el tema de Torres de Hanoi gráficas recursivas en el foro de C/C++ en Foros del Web. Lo primero hola, soy nuevo en este foro. Es un poco cutre presentarse y pedir ya ayuda, pero llevo peleandome con este código y necesito ...
  #1 (permalink)  
Antiguo 19/01/2015, 17:55
inazense
Invitado
  
Mensajes: n/a
Puntos:
Pregunta Torres de Hanoi gráficas recursivas
Lo primero hola, soy nuevo en este foro. Es un poco cutre presentarse y pedir ya ayuda, pero llevo peleandome con este código y necesito consejo :)

Estoy haciendo un programa que represente el ejercicio de las torres de hanoi gráficamente. Aún no está acabado, pues sólo los muestra como números y no haciendo torres de mayor a menor y ni siquiera pide al usuario el tamaño de los discos (lo haré una vez seguro de que puedo hacer funcionar bien el programa) y me ha surgido un fallo con la función moverdisco.

Si realizo el movimiento a las torre O (origen) o D (destino) funciona perfectamente, pero de cualquiera de ellas a la A (auxiliar) no empieza por la parte inferior, pone los discos donde le place (o esa sensación da). ¿Podéis guiarme para encontrar donde estoy fallando?

El código es este:

Código c: 
Ver original
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. #define VALOR 4
  5.  
  6. int llenarOrigen(int vector[VALOR]){
  7.     int i;
  8.  
  9.     for (i=0;i<VALOR;i++)
  10.         vector[i]=1;
  11.     
  12. }
  13.  
  14. int llenarResto(int vector[VALOR]){
  15.     int i;
  16.  
  17.     for (i=0;i<VALOR;i++)
  18.         vector[i]=0;
  19. }
  20.  
  21. void imprime (int O[VALOR], int A[VALOR], int D[VALOR]){
  22.     int i;
  23.  
  24.     for (i=VALOR-1;i>=0;i--)
  25.         printf("%i %i %i\n",O[i],A[i],D[i]);    
  26. }
  27.  
  28. int moverDisco(int discos,int O[VALOR],int A[VALOR],int D[VALOR],char o, char d) {
  29.  
  30.     int i,j,salida1=0,salida2=0;
  31.  
  32.     i=VALOR;
  33.     j=-1;
  34.  
  35.     if (o=='o'){
  36.         if (d=='a'){ // Torre origen O, torre destino A
  37.             while (salida1==0) {
  38.                 i--;
  39.                 if (O[i]==1)
  40.                     salida1=1;
  41.                 if (i==0)
  42.                     salida1=1;
  43.             }
  44.             while (salida2==0) {
  45.                 j++;
  46.                 if (A[j]==0)
  47.                     salida2=1;
  48.                 if (j==VALOR-1)
  49.                     salida2=1;
  50.             }
  51.             
  52.             O[i]=0;
  53.             A[i]=1;
  54.         }
  55.         if (d=='d'){ // Torre origen O, torre destino D
  56.             while (salida1==0) {
  57.                 i--;
  58.                 if (O[i]==1)
  59.                     salida1=1;
  60.                 if (i==0)
  61.                     salida1=1;
  62.             }
  63.             while (salida2==0) {
  64.                 j++;
  65.                 if (D[j]==0)
  66.                     salida2=1;
  67.                 if (j==VALOR-1)
  68.                     salida2=1;
  69.             }
  70.  
  71.             O[i]=0;
  72.             D[j]=1;
  73.         }           
  74.     }
  75.     if (o=='a'){
  76.         if (d=='o'){ // Torre origen A, torre destino O
  77.             while (salida1==0) {
  78.                 i--;
  79.                 if (A[i]==1)
  80.                     salida1=1;
  81.                 if (i==0)
  82.                     salida1=1;
  83.             }
  84.             while (salida2==0) {
  85.                 j++;
  86.                 if (O[j]==0)
  87.                     salida2=1;
  88.                 if (j==VALOR-1)
  89.                     salida2=1;
  90.             }
  91.             
  92.             A[i]=0;
  93.             O[j]=1;
  94.         }
  95.         if (d=='d'){ // Torre origen A, torre destino D
  96.             while (salida1==0) {
  97.                 i--;
  98.                 if (A[i]==1)
  99.                     salida1=1;
  100.                 if (i==0)
  101.                     salida1=1;
  102.             }
  103.             while (salida2==0) {
  104.                 j++;
  105.                 if (D[j]==0)
  106.                     salida2=1;
  107.                 if (j==VALOR-1)
  108.                     salida2=1;
  109.             }
  110.             
  111.             A[i]=0;
  112.             D[j]=1;
  113.         }
  114.     }
  115.     if (o=='d'){
  116.         if (d=='a'){ // Torre origen D, torre destino A
  117.             while (salida1==0) {
  118.                 i--;
  119.                 if (D[i]==1)
  120.                     salida1=1;
  121.                 if (i==0)
  122.                     salida1=1;
  123.             }
  124.             while (salida2==0) {
  125.                 j++;
  126.                 if (A[j]==0)
  127.                     salida2=1;
  128.                 if (j==VALOR-1)
  129.                     salida2=1;
  130.             }
  131.             
  132.             D[i]=0;
  133.             A[j]=1;
  134.         }
  135.         if (d=='o'){ // Torre origen D, torre destino O
  136.             while (salida1==0) {
  137.                 i--;
  138.                 if (D[i]==1)
  139.                     salida1=1;
  140.                 if (i==0)
  141.                     salida1=1;
  142.             }
  143.             while (salida2==0) {
  144.                 j++;
  145.                 if (O[j]==0)
  146.                     salida2=1;
  147.                 if (j==VALOR-1)
  148.                     salida2=1;
  149.             }
  150.             
  151.             D[i]=0;
  152.             O[j]=1;
  153.         }
  154.     }
  155.  
  156.     imprime(O,A,D);
  157.     getchar();
  158. }
  159.  
  160. void hanoi(int discos, int O[VALOR], int A[VALOR], int D[VALOR], char o, char a, char d){
  161.  
  162.     if (discos==1) {
  163.         moverDisco(discos,O,A,D,o,d);
  164.     }
  165.     else {
  166.         hanoi(discos-1,O,A,D,o,d,a);
  167.         moverDisco(discos,O,A,D,o,d);
  168.         hanoi(discos-1,O,A,D,a,o,d);
  169.     }
  170. }
  171.  
  172. void main() {
  173.     
  174.     int O[VALOR], A[VALOR], D[VALOR], i;
  175.     int discos=VALOR;
  176.     
  177.     system("clear");
  178.     
  179.     printf("----- Torres de Hanoi -----\n");
  180.     llenarOrigen(O);
  181.     llenarResto(A);
  182.     llenarResto(D);
  183.  
  184.     imprime(O,A,D);
  185.     getchar();
  186.     hanoi(discos,O,A,D,'o','a','d');
  187.     
  188. }
Última edición por inazense; 20/01/2015 a las 02:37
  #2 (permalink)  
Antiguo 20/01/2015, 02:38
inazense
Invitado
  
Mensajes: n/a
Puntos:
Respuesta: Torres de Hanoi gráficas recursivas
Ya lo solucioné, me equivoqué en el movimiento de O a A. Puse A[i]=1 en vez de A[j]=1. De todas formas lo he vuelto a tratar de la siguiente manera la función.

Código C: 
Ver original
  1. int moverDisco(int discos,int O[VALOR],int A[VALOR],int D[VALOR],char o, char d) {
  2.  
  3.     int i,j,salida1=0,salida2=0;
  4.  
  5.     i=VALOR;
  6.     j=-1;
  7.  
  8.     if (o=='o'){
  9.         if (d=='a'){ // Torre origen O, torre destino A
  10.             while (salida1==0) {
  11.                 i--;
  12.                 if (O[i]!=0)
  13.                     salida1=1;
  14.                 if (i==0)
  15.                     salida1=1;
  16.             }
  17.             while (salida2==0) {
  18.                 j++;
  19.                 if (A[j]==0)
  20.                     salida2=1;
  21.                 if (j==VALOR-1)
  22.                     salida2=1;
  23.             }
  24.             A[j]=O[i];
  25.             O[i]=0;
  26.         }
  27.         if (d=='d'){ // Torre origen O, torre destino D
  28.             while (salida1==0) {
  29.                 i--;
  30.                 if (O[i]!=0)
  31.                     salida1=1;
  32.                 if (i==0)
  33.                     salida1=1;
  34.             }
  35.             while (salida2==0) {
  36.                 j++;
  37.                 if (D[j]==0)
  38.                     salida2=1;
  39.                 if (j==VALOR-1)
  40.                     salida2=1;
  41.             }
  42.             D[j]=O[i];
  43.             O[i]=0;
  44.         }
  45.     }
  46.     if (o=='a'){
  47.         if (d=='o'){ // Torre origen A, torre destino O
  48.             while (salida1==0) {
  49.                 i--;
  50.                 if (A[i]!=0)
  51.                     salida1=1;
  52.                 if (i==0)
  53.                     salida1=1;
  54.             }
  55.             while (salida2==0) {
  56.                 j++;
  57.                 if (O[j]==0)
  58.                     salida2=1;
  59.                 if (j==VALOR-1)
  60.                     salida2=1;
  61.             }
  62.             O[j]=A[i];
  63.             A[i]=0;
  64.         }
  65.         if (d=='d'){ // Torre origen A, torre destino D
  66.             while (salida1==0) {
  67.                 i--;
  68.                 if (A[i]!=0)
  69.                     salida1=1;
  70.                 if (i==0)
  71.                     salida1=1;
  72.             }
  73.             while (salida2==0) {
  74.                 j++;
  75.                 if (D[j]==0)
  76.                     salida2=1;
  77.                 if (j==VALOR-1)
  78.                     salida2=1;
  79.             }
  80.  
  81.             D[j]=A[i];
  82.             A[i]=0;
  83.         }
  84.     }
  85.     if (o=='d'){
  86.         if (d=='a'){ // Torre origen D, torre destino A
  87.             while (salida1==0) {
  88.                 i--;
  89.                 if (D[i]!=0)
  90.                     salida1=1;
  91.                 if (i==0)
  92.                     salida1=1;
  93.             }
  94.             while (salida2==0) {
  95.                 j++;
  96.                 if (A[j]==0)
  97.                     salida2=1;
  98.                 if (j==VALOR-1)
  99.                     salida2=1;
  100.             }
  101.  
  102.             A[j]=D[i];
  103.             D[i]=0;
  104.         }
  105.         if (d=='o'){ // Torre origen D, torre destino O
  106.             while (salida1==0) {
  107.                 i--;
  108.                 if (D[i]!=0)
  109.                     salida1=1;
  110.                 if (i==0)
  111.                     salida1=1;
  112.             }
  113.             while (salida2==0) {
  114.                 j++;
  115.                 if (O[j]==0)
  116.                     salida2=1;
  117.                 if (j==VALOR-1)
  118.                     salida2=1;
  119.             }
  120.  
  121.             O[j]=D[i];
  122.             D[i]=0;
  123.         }
  124.     }
  125.  
  126.     imprime(O,A,D);
  127.     getchar();
  128. }

Etiquetas: grafico, recursividad
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 09:16.