Torre de hanoi

Programação Java
#1

ae…

alguem ai ja fez um jogo de torre de hanoi??? se alguem ja fez…pode postar o codigo aki pra eu ter nocao de como se faz???

flww

#2

Eu num fiz jogo assim… gráfico nem nada… só fiz o algoritmo… mas é mto facinho… acho q num é isso q vc qh né:?:

#3

vc pode criar usar um int representando o tamanho da peca, eu aconselho a por tudo numero de 2 na potencia n (ex 1, 2, 4, 8, 16, 32, 64, 128, etc…), pq dai vc pdoe saber todas as pecas q tao em um local com apenas um int. e vc pode armazenar em uma int todas as pecas q tao em cada local, dai pra mostrar na tela eh soh ver quais pecas estao em cada local e fazer um quicksort (jah q as menores sempre vao estar em cima),e pra mover eh soh ver a q esta em cima…

#4

pode ser o algoritimo sim!!! da pra vc postar aki???

#5

Tá aqui um codigozinho básico, com interface no DOS mesmo, não tá completo, mas tem o necessário, que é as torres e o movimento das peças.

[code]/**

  • Classe Hanoi.
  • Esta classe que permita jogar o conhecido jogo das torres de hanói.
  • O objetivo do jogador é mover todos os discos inicialmente colocados no pino 1
  • para o pino 3, no menor número de jogadas possível. A entrada e saída funciona
  • com base em três comandos: novojogo, move e solucao.
  • O comando novojogo recebe como parâmetro o número de discos (de 1 a 9) usados no
  • jogo e inicializar um novo jogo com todos os discos no pino 1.
  • O comando move recebe os números dos pinos entre os quais um disco deve ser movido.
  • Movimentos proibidos não sao executados, nem contabilizados. Nesse caso, a saída e
  • “erro: jogada invalida”.
  • O comando solucao imprime na saída os movimentos necessários para resolver o problema
  • a partir do estado atual no menor número de movimentos possível.
  • A cada comando, o estado do jogo é impresso na saída em uma única linha.
  • O formato é o seguinte: número dos discos no pino 1 (de cima para baixo) + "| " +
  • discos no pino 2 + "| " + discos no pino 3.
  • Os discos são numerados de 1 a n, do menor para o maior, onde n é o número de discos do
  • jogo.
  • Ao final do jogo, também é impresso o total de movimentos realizados, bem como o número
  • de movimentos errados (acima do número necessário). O formato de saída corresponde aos
  • Um exemplo de entrada e saída é expresso na tabela a seguir.
  • Entrada Saída
  • novojogo 3 1 2 3 | |
  • move 1 3 2 3 | | 1
  • move 2 3 erro: jogada invalida
  • move 1 2 3 | 2 | 1
  • move 3 2 3 | 1 2 |
  • move 1 3 | 1 2 | 3
  • move 2 1 1 | 2 | 3
  • move 2 3 1 | | 2 3
  • move 1 3 | | 1 2 3 : 7 : 0
  • novojogo 2 1 2 | |
  • solucao 1 2 + 1 3 + 2 3
    */

// pacotes de nucleo de Java
import java.util.;
import java.io.;

public class Hanoi {
// atributos
private LinkedList[] torre;
private int jogadas;

/**
  * Construtor de Hanoi.
  * O construtor cria os 3 pinos e inicializa o contador de jogadas
  *
  * @param O numero de discos do jogo
  */ 
public Hanoi() {
   torre = new LinkedList[3];
   for(int i = 0; i < torre.length; i++)
      torre[i] = new LinkedList();
   jogadas = 0;
}

/**
  * Inicializa o jogo, colocando os discos no primeiro pino.
  * 
  * @param O numero de discos do jogo
  */
private void novoJogo(int nDiscos) {
   for(int i = nDiscos; i > 0; i--) {
      String disco = String.valueOf(i);
      torre[0].addFirst(disco);
   }
   jogadas = 0;
}

/**
  * Move o disco de um pino para outro.
  * 
  * @param O pino de onde deve sair o disco (1 a 3).
  * @param O pino onde o disco sera colocado (1 a 3).
  * @throws Mensagem "erro: jogada invalida" caso o pino de destino tenha um disco menor que o disco movido.
  */ 
public void move(int deSaida, int deDestino) throws Exception {
   deSaida--;
   deDestino--;
   
   int discoASerMovido = Integer.parseInt((String)torre[deSaida].getFirst());
   if((torre[deDestino].size() == 0) || 
      (discoASerMovido < Integer.parseInt((String)torre[deDestino].getFirst()))) {
      String disco = String.valueOf(torre[deSaida].getFirst());
      torre[deDestino].addFirst(disco);
      torre[deSaida].removeFirst();
      
      jogadas++;   	   
   } else throw new Exception("erro: jogada invalida");
}

// FALTA FAZER
public void solucao() {}

/**
  * Apaga todos os discos dos pinos para comecar um novo jogo.
  */ 
public void clear() {
   for(int i = 0; i < torre.length; i++)
      torre[i].clear();
}

/**
  * Imprime a saida do jogo, deve ser chamado a cada movimento dos discos.
  * Caso o jogador venca, tambem e impresso o numero de jogadas e de jogadas erradas.
  */
public String toString() {
   String jogo = "";
   for(int i = 0; i < torre.length; i++) {
      Iterator buscador = torre[i].iterator();
      while(buscador.hasNext())
         jogo += String.valueOf(buscador.next());
      
      if(i != torre.length - 1)
         if(!buscador.hasNext()) jogo += "|";
      
   }
   if((torre[0].size() == 0) && (torre[1].size() == 0)) {
      jogo += " : " + jogadas + " : ";
   }
   return jogo;   
}

/**
  * Analiza o comando de entrada do usuario para executar o metodo adequado.
  *
  * @param O comando de entrada do usuario.
  * @param O objeto hanoi onde sera executado o jogo.
  * @return Uma linha de saida com o resultado do comando, de acordo com a situacao do jogo.
  */   
private String analizarComando(String out, Hanoi hanoi) {
   StringTokenizer entrada = new StringTokenizer(out);
   String comando = entrada.nextToken();
   
   if(comando.equals("novojogo")) {
      int nDiscos = Integer.parseInt((String)entrada.nextToken());
      hanoi.clear();
      hanoi.novoJogo(nDiscos);
   } 
   else if(comando.equals("move")) {
      int torreSaida = Integer.parseInt((String)entrada.nextToken());
      int torreDestino = Integer.parseInt((String)entrada.nextToken());
      try {
         hanoi.move(torreSaida, torreDestino);
      } catch(Exception e) {
         return e.getMessage();
      }
   }
   else if(comando.equals("solucao")) {
      hanoi.solucao();
      return "FALTA FAZER";
   } 
   
   return hanoi.toString();	   
}


// Main.
public static void main(String[] args) {
   BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
   Hanoi hanoi = new Hanoi();
   
   String out = "";
   try {
      while((out = in.readLine()) != null) {
         System.out.println(hanoi.analizarComando(out, hanoi));
      }
   } catch(Exception e) {
      e.getMessage();
      System.exit(1);
   }	   

}

} // fim da classe Hanoi[/code]

[size=“11”][color=“green”][color=yellow]utilize a tag CODE do bbcode em seus códigos - matheus[/color][/color][/size]

#6

Eu tive qe implementar esse codigo em assembly no mes passado, mas ta ai um rascunho que eu fiz.
A ideia eh mover os discos de cima pra torre auxiliar, depois mover o maior disco para o destino e em seguida levar os discos que estao na torre auxiliar para a torre destino, soh que isso feito recursivamente.
Espero que ajude
Hanoi(n, orig, aux, dest)
{
if(n>0)
{
Hanoi(n-1, orig, dest, aux);
Hanoi(1, orig, aux, dest);
Hanoi(n-1, aux, orig, dest);
}
}

#7