Jump to content
darkobscuro

Ajuda com Trabalho

Recommended Posts

darkobscuro

Olá, preciso fazer uma torre de Hanoi em java. A questão é que preciso coletar 10 numeros em VetorA, depois organiza-lo e então fazer a logica de Hanoi utilizando os Vetores B como pilar de apoio e C como pilar de origem. Eu já entendi a logica da torre de Hanoi, porem estou com dificuldades para fazer esse exercício de maneira recursiva. Abaixo como está o código até o momento.

 

import javax.swing.JOptionPane;

public class Trabalho1 {

    static int a[] = new int[10]; // Números desordenados/origem
    static int b[] = new int[10]; //pilar de trabalho
    static int c[] = new int[10]; //pilar destino
    static int qtda;
    static int qtdb;
    static int qtdc;

    public static void main(String[] args) {

        // recebe os números digitados pelo usuário  
        for (int i = 0; i < a.length; i++) {
            a[i] = Integer.parseInt(JOptionPane.showInputDialog("Digite os números: "));
qtda++;
        }
        organizaA();
        resolvehanoi();
    }

    public static void organizaA() {
//organiza o pilar origem

        int aux;

        for (int i = 0; i < a.length; i++) {
            for (int j = 1; j < a.length; j++) {
                if (a[j - 1] < a[j]) {
                    aux = a[j];
                    a[j] = a[j - 1];
                    a[j - 1] = aux;

                }
            }
        }
    }

    public static void resolvehanoi() {
//executa a logica da torre de hanoi.

        if ((qtda == 0) && (qtdb == 0)) {
            exibir();
        }

        if ((a[qtda - 1] > 0) && (a[qtda - 1] < b[qtdb -1])) {
            a[qtda - 1] = b[qtdb];
            qtda--;
            qtdb++;
        } else {
            a[qtda - 1] = c[qtdc];
        }
        if (b[qtdb - 1] > 0 && b[qtdb - 1] < c[qtdc - 1]) {
            b[qtdb - 1] = c[qtdc];
            qtdb--;
            qtdc++;
        } else {
            a[qtda - 1] = b[qtdb];
            qtda--;
            qtdb++;
        }
        if (c[qtdc - 1] > 0 && c[qtdc - 1] < a[qtda - 1]) {
            c[qtdc - 1] = a[qtda];
            qtdc--;
            qtda++;
        } else {
            c[qtdc - 1] = b[qtdb];
            qtdc--;
            qtdb++;
        }
        //if(){
          //      b[qtdb-1] = a[qtda];
            //    qtdb--;
              //              qtda++;
                //}
    }

    public static void exibir() {
        for (int i = 0; i > c.length; i++) {
            System.out.println("Os números em C São: " + c[i]);
        }
    }
}

 

 

Lembrando que sou iniciante em Java, então gostaria de ajuda e compreensão de vocês pois imagino que deva ter diversos erros. Obrigado!

Share this post


Link to post
Share on other sites
HappyHippyHippo

este algo que parece estranho nessa implementação, podes apresentar o enunciado ?


IRC : sim, é algo que ainda existe >> #p@p

Share this post


Link to post
Share on other sites
darkobscuro

O enunciado é o seguinte:

Citação

Faça um programa em Java com 3 vetores (A,B,C) no qual será inserido pelo usuário 10 valores no vetor A desordenadamente, você deve ordenar o vetor A de forma crescente e mover os valores para o vetor C de forma que os números sempre esteja ordenados.

 

Share this post


Link to post
Share on other sites
darkobscuro

Olá, o fato de precisar mover os números de A pra C devem seguir a logica de uma torre de Hanoi.

Share this post


Link to post
Share on other sites
HappyHippyHippo

nesse caso toma estes pontos:

- ordenar um array de inteiros : Array.sort(o_meu_array)

- cria uma função que move uma peca de A para B

- cria uma função que move uma peca de A para C

- cria uma função que move uma peca de B para A

- cria uma função que move uma peca de B para C

- cria uma função que move uma peca de C para A

- cria uma função que move uma peca de C para B

- implementa a lógica do problema de torres de hanoi com o auxilio das funções ciradas

 

nota : no teu código qual o valor de qtda no início da tua função resolvehanoi ?


IRC : sim, é algo que ainda existe >> #p@p

Share this post


Link to post
Share on other sites
darkobscuro

qtda é o valor que existe de números no vetor A, estou usando a logica de pilhas nesse caso.

Sobre essas funções ao quais você citou, tento fazer isso nos "ifs", ele testa se o número que está em topo de A é maior que o numero no topo de B, se não ele move a peça para C. Porem essa logica não está funcionando corretamente.

Share this post


Link to post
Share on other sites
HappyHippyHippo

Qual a instrução do código que indica que qtda tem o número de valores na pilha A no início da execução? 


IRC : sim, é algo que ainda existe >> #p@p

Share this post


Link to post
Share on other sites
darkobscuro

a variavel "qtda".

Fiz um novo codigo como você me informou colocando comentarios. Porem na linha 105 quando o B está sem valor o código para. O correto era o código retirar de C e colocar em A.



 


import javax.swing.JOptionPane;

public class Trabalho1 {

    static int a[] = new int[10]; // Números desordenados/origem
    static int b[] = new int[10]; //pilar de trabalho
    static int c[] = new int[10]; //pilar destino
    static int qtda; //Contador de quantos numeros tem em A.
    static int qtdb; //Contador de quantos numeros tem em B.
    static int qtdc; //Contador de quantos numeros tem em C.

    public static void main(String[] args) {

        // recebe os números digitados pelo usuário  
        for (int i = 0; i < a.length; i++) {
            a[i] = Integer.parseInt(JOptionPane.showInputDialog("Digite os números: "));
            qtda++;
        }
//Chama as rotinas de organizar o Vetor A, distribuir o topo de A para B e C, depois resolve o problema de Hanoi.
        organizaA();
        DistribuiBeC();
        resolvehanoi();

    }

    public static void organizaA() {
//organiza o pilar origem

        int aux;

        for (int i = 0; i < a.length; i++) {
            for (int j = 1; j < a.length; j++) {
                if (a[j - 1] < a[j]) {
                    aux = a[j];
                    a[j] = a[j - 1];
                    a[j - 1] = aux;

                }
            }
        }
    }

    public static void DistribuiBeC() {
        //O pilar B e C recebem quem está no topo do Pilar A
        b[qtdb] = a[qtda - 1];
        qtdb++;
        qtda--;

        c[qtdc] = a[qtda - 1];
        qtdc++;
        qtda--;
    }

    public static void AtoB() {
        //Topo de A vai para B
        b[qtdb] = a[qtda - 1];
        qtdb++;
        qtda--;
    }

    public static void AtoC() {
        //Topo de A vai para C
        c[qtdc] = a[qtda - 1];
        qtdc++;
        qtda--;
    }

    public static void BtoC() {
        //Topo de B vai para C
        c[qtdc] = b[qtdb - 1];
        qtdc++;
        qtdb--;
    }

    public static void BtoA() {
        //Topo de B vai para A
        b[qtdb] = a[qtda - 1];
        qtdb++;
        qtda--;
    }

    public static void CtoA() {
        //Topo de C vai para A
        a[qtda] = c[qtdc - 1];
        qtda++;
        qtdc--;
    }

    public static void CtoB() {
        //Topo de C vai para B
        b[qtdb] = c[qtdc - 1];
        qtdb++;
        qtdc--;
    }

    public static void resolvehanoi() {
//executa a logica da torre de hanoi. Se um numero da Pilha "X" for maior que o numero da pilha "Y" ele envia quem está no topo para pilha "Z" e vice versa.
//Se a Pilha A e a Pilha B chegarem a 0, ele chama o metodo para exibir os dados que se encontram em C.

        if ((qtda == 0) && (qtdb == 0)) {
            exibir();
        }

        if (a[qtda - 1] < b[qtdb - 1]) {
            AtoB();
        }
        if ((a[qtda - 1] > b[qtdb - 1]) && (a[qtda - 1] < c[qtdc - 1])) {
            AtoC();
        }

        if ((b[qtdb - 1] > 0) && (b[qtdb - 1] < c[qtdc - 1])) {
            BtoC();
        }
        if ((b[qtdb - 1] > 0) && (b[qtdb - 1] > c[qtdc - 1]) && (b[qtdb - 1] < a[qtda - 1])) {
            BtoA();
        }

        if ((c[qtdc - 1] > 0) && (c[qtdc - 1] < a[qtda - 1])) {
            CtoA();
        } else {
            CtoB();
        }

    }

    public static void exibir() {
        //Exibi os dados na pilha C.
        for (int i = 0; i < c.length; i++) {
            System.out.println("Os números em C São: " + c[i] + " A " + a[i] + " B " + c[i]);
        }
    }
}

 

Share this post


Link to post
Share on other sites
HappyHippyHippo

estive a rever o problema e já me lembro de como resolver isso atraves de forma recursiva.

estas muito longe do problema (tambem eu estava, pois quando fiz isso foi à mais de 10 anos ...)

na realidade só necessitas de uma função (podes ter uma auxiliar para trocar um "disco" de uma pilha para outra)

 

começando pelo início:

- uma única função recursiva

caso das torres terem somente um disco : como escreverias o código ?

 


IRC : sim, é algo que ainda existe >> #p@p

Share this post


Link to post
Share on other sites
darkobscuro

Porém como citado a cima o problema é para resolver 10 números. Então não estou fazendo com outras possibilidades realmente, pois essa é a única maneira que penso em fazer. Cheguei a ver outros métodos, porem eles só informam os movimentos do disco. O que preciso é que de fato sejam passados os números em A para C e depois o C seja exibido com os números (os números representam os discos).

 

Share this post


Link to post
Share on other sites
HappyHippyHippo

não interessa se sejam 2,10 ou 100 ... o código é o mesmo !!!

se te estou a dizer para seguires as indicações, por favor, segue-as

 

novamente, escreve uma função que dados as torres, move um disco da origem deste para o destino


IRC : sim, é algo que ainda existe >> #p@p

Share this post


Link to post
Share on other sites
HappyHippyHippo

bem ... parece que o criador do código entrou em hiato, e como tal fica a solução como referência

 

public class Game {
    // tower height
    private static final int TOWER_SIZE = 10;

    // auxiliary tower nested class to handle a single tower stack
    protected class Tower
    {
        int values[] = new int[Game.TOWER_SIZE];
        int count = 0;
    }

    // Hanoi game 3 towers
    private Tower A;
    private Tower B;
    private Tower C;

    // application entry point
    public static void main(String[] args)
    {
        // create the game
        Game game = new Game();

        // init the game
        game.init();
        game.print();

        // run hanoi solving algorithm
        game.hanoi();
        game.print();
    }

    // game constructor
    public Game()
    {
        A = new Tower();
        B = new Tower();
        C = new Tower();
    }

    // initialize the game
    public void init()
    {
        for (int i = 0; i < Game.TOWER_SIZE; ++i)
            A.values[i] = Game.TOWER_SIZE - i;
        A.count = Game.TOWER_SIZE;
    }

    // run the hanoi solving algorithm
    public void hanoi()
    {
        hanoi(A.count, A, C, B);
    }

    // print the game/towers state
    public void print()
    {
        System.out.println();
        for (int i = Game.TOWER_SIZE - 1; i >= 0; --i)
        {
            System.out.print(" ");
            System.out.printf((A.values[i] != 0 ? "   %02d    " : "    |    "), A.values[i]);
            System.out.printf((B.values[i] != 0 ? "   %02d    " : "    |    "), B.values[i]);
            System.out.printf((C.values[i] != 0 ? "   %02d    " : "    |    "), C.values[i]);
            System.out.println();
        }
        System.out.print("+--------+--------+--------+");
        System.out.println();
        System.out.print("|");
        System.out.printf("   %02d   |", A.count);
        System.out.printf("   %02d   |", B.count);
        System.out.printf("   %02d   |", C.count);
        System.out.println();
        System.out.print("+--------+--------+--------+");
        System.out.println();
    }

    // recursive hanoi game solving algorithm
    private void hanoi(int disc, Tower src, Tower dest, Tower aux)
    {
        if (disc == 0)
            return;

        hanoi(disc - 1, src, aux, dest);
        move(src, dest);
        hanoi(disc - 1, aux, dest, src);
    }

    // auxiliary function : move a disc from a source to a destination tower
    private void move(Tower src, Tower dest)
    {
        dest.values[dest.count] = src.values[src.count - 1];
        src.values[src.count - 1] = 0;
        dest.count++;
        src.count--;
    }
}

 


IRC : sim, é algo que ainda existe >> #p@p

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

×
×
  • Create New...

Important Information

By using this site you accept our Terms of Use and Privacy Policy. We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.