Torre de hanoi

/**
  * 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

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);

}

}