Torre de Hani

cerdotes so monges. O templo ou mosteiro pode estar

em diferentes partes do mundo - incluindo Hani, Vietn,
e pode ser associado a qualquer religio. Em algumas
verses, so introduzidos outros elementos, tais como o
facto de a torre foi criado no incio do mundo, ou que os
padres ou monges podem fazer apenas uma mudana por
dia.
Um Modelo das Torres de Hanoi

2 Solues

Torre de Hani um "quebra-cabea" que consiste em

uma base contendo trs pinos, em um dos quais so dispostos alguns discos uns sobre os outros, em ordem crescente de dimetro, de cima para baixo. O problema consiste em passar todos os discos de um pino para outro
qualquer, usando um dos pinos como auxiliar, de maneira
que um disco maior nunca que em cima de outro menor
em nenhuma situao. O nmero de discos pode variar
sendo que o mais simples contm apenas trs.
A Torre de Hani tem sido tradicionalmente considerada Soluo do problema com uma torre de quatro discos.
como um procedimento para avaliao da capacidade de
memria de trabalho, e principalmente de planejamento interessante observar que o nmero mnimo de movimentos para conseguir transferir todos os discos da prie soluo de problemas.
meira estaca terceira 2n 1, sendo n o nmero de discos. Logo:

Origens

Para solucionar um Hani de 4 discos, so necessrios 15

movimentos

O quebra-cabea foi inventado pelo matemtico francs

douard Lucas. Ele teve inspirao de uma lenda para
construir o jogo das Torres de Hani em 1883[1] . J seu
nome foi inspirado na torre smbolo da cidade de Hani,
no Vietn[2] .

Para solucionar um Hani de 7 discos, so necessrios

127 movimentos

Existem vrias lendas a respeito da origem do jogo, a

mais conhecida diz respeito a um templo Hindu, situado no centro do universo. Diz-se que Brahma supostamente havia criado uma torre com 64 discos de ouro
e mais duas estacas equilibradas sobre uma plataforma.
Brahma ordenara-lhes que movessem todos os discos de
uma estaca para outra segundo as suas instrues. As regras eram simples: apenas um disco poderia ser movido
por vez e nunca um disco maior deveria car por cima
de um disco menor. Segundo a lenda, quando todos os
discos fossem transferidos de uma estaca para a outra, o
templo desmoronar-se-ia e o mundo desapareceria. No
claro se Lucas inventou essa lenda ou foi inspirado por
ele.

Para solucionar um Hani de 64 discos, como diz a lenda,

so necessrios 18.446.744.073.709.551.615 movimentos.

Para solucionar um Hani de 15 discos, so necessrios

32.767 movimentos

Para mover o primeiro disco da torre original, 1 movimento gasto. Para mover o segundo da torre original,
sendo que o primeiro j foi movido e ser construda uma
torre com os 2 menores discos, so gastos 2 movimentos.
Para deslocar o terceiro disco formando nova torre com
os trs menores discos, tendo a torre com os dois menores
j formada, so gastos 7 movimentos.

Assim se sucede com os prximos discos at que o ensimo disco (o ltimo) seja deslocado compondo uma
torre com os outros discos tendo uma torre com o penltimo disco e os demais juntos j formada. A sucesExistem muitas variaes sobre esta lenda. Por exemplo, so formada pela soma dos movimentos uma sucesso
em algumas narrativas, o templo um mosteiro e os sa- (1, 2, 4, 8...2n )
1

SOLUES

A frmula 2n 1 provinda da soma de uma progresso h.hanoi(); Collections.sort(h.arrayDiscos); for (Disco

geomtrica.
d :
h.arrayDiscos) { System.out.println(execute:
"+d.index+"
"+d.movimento); } } }
Sabe-se que em uma progresso geomtrica a soma de
seus termos equivale a [a (q n 1)]/q 1 , onde a
o primeiro termo e q a razo.
J que a razo 2 e o primeiro termo 1 temos que [a 2.2 C
(q n 1)]/q 1 = [1 (2n 1)]/2 1 = 2n 1
Uma soluo iterativa em Java para as Torres de Hanoi. 2.2.1 Implementao do Algortimo Iterativo
A letra A representa o primeiro pino mais esquerda,
a letra C o pino central e a letra B representa o ltimo /** * Resoluo do problema clssico das Torres de Hapino para o qual todos os Disco devem estar no nal do ni via algortimo iterativo. * * Exemplo de compilao
e execuo no Linux: * * prompt> gcc hanoi.c -o hanoi
algoritmo.
* prompt> ./hanoi QUANTIDADE_DE_DISCOS * *
Nota: Imprime (2^QUANTIDADE_DE_DISCOS)1
linhas de texto na sada padro. */ #include <stdio.h>
2.1 JAVA
#include <stdlib.h> /** * Core da resoluo com impresso da sequncia tima de movimentos. * * @param
import java.util.ArrayList; import java.util.Collections; QTD_DISCOS Quantidade de discos a movimentar
import java.util.InputMismatchException;
import entre as 3 pilhas. */ void solve(const int QTD_DISCOS)
java.util.List; import java.util.Scanner; class Disco { /* * array dos arrays de duplas, isto ; movimentos,
implements Comparable<Disco>{ Integer index; para acesso conforme * paridade (vide cdigo) tal que
String movimento; Disco(int index,String movi- o primeiro componente de cada dupla o * nmero
mento){ this.index=index; this.movimento=movimento; de uma torre origem e o segundo o nmero de uma
} public int compareTo(Disco o) { return in- torre destino */ const int ALPHA[2][3][2] = { { { 1, 3
dex.compareTo(o.index); } } public class HanoiIterativo }, { 3, 2 }, { 2, 1 } }, /* PARES */ { { 1, 2 }, { 2, 3
{ private int qtDiscos; private String sequenciaImpa- }, { 3, 1 } } /* MPARES */ }; /* calcula o limitante
res[] = {"A-->C, C-->B, B-->A"};//para impares do nmero de iteraes = 2 ^ QTD_DISCOS */ const
private String sequenciaPares [] = {"A-->B, B-->C, int MAX_ITER = 1 << QTD_DISCOS; /* lista de
C-->A"};//para pares private List<Disco> arrayDiscos movimentos com capacidade tima */ int **lista =
= new ArrayList<Disco>(); public void lerDados() { malloc( (MAX_ITER - 1) * sizeof(*lista) ); int start,
System.out.println(Digite a quantidade de discos); gap, disco, k, rank; /* * loop de preenchimento no
Scanner rc = new Scanner(System.in); try{ qtDis- sequencial da lista de movimentos */ for (start = 1, gap
cos = rc.nextInt(); }catch(InputMismatchException = 2, disco = 1; disco <= QTD_DISCOS; ++disco, start
e){ System.out.println(Amigo!
fcil!
Digite <<= 1, gap <<= 1) { /* valor ajustado do limitante */
o nmero de discos por favor!"); lerDados(); } } int R = MAX_ITER + (disco % 2); /* estabelece acesso
public void hanoi() { int maxP=(int) Math.pow(2, direto a um dos arrays de duplas */ int **duplas = (int
qtDiscos); int y = 1; int pos =1; while(y <= qtDis- **) &ALPHA[(QTD_DISCOS + disco) % 2]; for (k =
cos ){ int ctPulos = (int) Math.pow(2, y); pos*=2; 0, rank = start; rank < R; rank += gap, ++k) { lista[rank if(y==1){ pos=1; } if(qtDiscos%2==0){ populaAr- 1] = (int *) &duplas[k % 3]; } } /* imprime a sequncia
rayPares(pos,ctPulos,maxP,y); }else{ populaArrayIm- tima de movimentos que resolvem o problema */ for
pares(pos,ctPulos,maxP,y); } y++; } } private void (rank = 0; rank < (MAX_ITER - 1); ++rank) { char oripopulaArrayPares(int pos,int intervalos, int maxP,int gem = lista[rank][0] + 64; char destino = lista[rank][1]
y){ int index = 0; if(y%2==0){ for (int i = pos; i + 64; printf("%4d ) %c --> %c\n, (rank + 1), origem,
<= maxP; i+=intervalos) { Disco d = new Disco(i, destino); } free(lista); } /** * Invoca o core da resoluo
sequenciaPares[index]); arrayDiscos.add(d); index++; com o parmetro fornecido na linha de comando. * *
if(index>2){ index=0; } } }else{ for (int i = pos; @param Quantidade de discos a movimentar entre as
i < maxP; i+=intervalos) { Disco d = new Disco(i, 3 pilhas. */ int main(int argc, char **argv) { int d =
sequenciaImpares[index]); arrayDiscos.add(d); index++; atoi(argv[1]); solve(d); return 0; }
if(index>2){ index=0; } } } } private void populaArrayImpares(int pos,int intervalos, int maxP,int y){ int
index = 0; if(y%2==0){ for (int i = pos; i < maxP;
i+=intervalos) { Disco d = new Disco(i, sequenciaImpa- 2.2.2 Implementao do Algortimo Recursivo
res[index]); arrayDiscos.add(d); index++; if(index>2){
index=0; } } }else{ for (int i = pos; i <= maxP; /** * Resoluo do problema clssico das Torres de Saii+=intervalos) { Disco d = new Disco(i, sequenciaPa- gon via algortimo recursivo. * * Exemplo de compilao
res[index]); arrayDiscos.add(d); index++; if(index>2){ e execuo no Linux: * * prompt> gcc saigon.c -o saigon
index=0; } } } } public static void main(String[] args) { * prompt> ./saigon QUANTIDADE_DE_DISCOS * *
HanoiIterativo h = new HanoiIterativo(); h.lerDados(); Nota: Imprime (2^QUANTIDADE_DE_DISCOS)1

3
linhas de texto na sada padro. */ #include <stdio.h>
#include <stdlib.h> /** * Core da resoluo com
impresso da sequncia tima de movimentos. * *
@param QTD_DISCOS Quantidade de discos a movimentar. * @param origem Nmero da torre origem. *
@param destino Nmero da torre destino. * @param
temp Nmero da torre temporria. */ void solve(int
QTD_DISCOS, int origem, int destino, int temp) { /**
Nmero de ordem de cada movimento na sequncia de
resoluo. */ static int rank = 0; if (QTD_DISCOS >
0) { solve(QTD_DISCOS-1, origem, temp, destino);
printf("%4d ) %c --> %c\n, ++rank, '@' + origem,
'@' + destino); solve(QTD_DISCOS-1, temp, destino,
origem); } } /** * Invoca o core da resoluo com o
parmetro fornecido na linha de comando e * constantes
que caracterizam o problema. * * @param Quantidade
de discos a movimentar entre as 3 pilhas. */ int main(int
argc, char **argv) { int d = atoi(argv[1]); solve(d, 1, 3,
2); return 0; }

A resoluo Iterativa utiliza alguns ciclos (estruturas) de

repetio (for, whiles) que podem ser chamados de laos,
existe ainda a possibilidade de algumas estruturas adicionais (mais complexas) as quais tornam o algoritmo mais
rpido.
fato que todo algoritmo recursivo possui um algoritmo
iterativo equivalente; Dependendo apenas da sua complexidade de construo.

5 Referncias
[1] www.realidadevirtual.com.br, acesso em 28-08-2011.
[2] Jogos de Desao, Vol. 1. Editorial Salvat, Barcelona,
2005.

6 Ligaes externas
Veja torre de Hanoi implementada em java.

Aplicao

A Torre de Hani pode ser trabalhada em nveis de desenvolvimento com crianas. Na pr-escola, com regras
simples de separao de cores e tamanhos, a torre de Hani ajuda em questes de coordenao motora, identicao de formas, ordem crescente e decrescente, entre
outras formas de aprendizado.
De uma maneira mais ampla, o jogo pode ser usado para
o estabelecimento de estratgias de transferncia das peas, como a contagem dos movimentos e raciocnio.
Iniciando com um nmero menor de peas, ou seja, resolvendo problemas mais simples, teremos oportunidade
de experimentar uma das mais importantes formas de raciocnio matemtico.
O jogo trabalha o desenvolvimento da lgica e do raciocnio matemtico. usado para desenvolver as crianas.

Concluso

A Torre de Hani consiste em passar todos os discos de

uma extremidade a outra sem que um disco maior que
em cima de um menor.
As suas aplicaes so basicamente usadas em escolas
para que os professores possam melhorar e desenvolver o
cognitivo das crianas, alm do trabalho em grupo. Sendo
este aplicado em pequenos grupos ou individualmente.
A Torre de Hani possui vrias formas de resoluo. Uma
delas a resoluo recursiva a qual podemos dizer que
a mais limitada quanto ao tempo de realizao, j que sua
execuo depender de alguns fatores para tornar-se mais
ecaz.

Veja torre de Hani implementada em C# ou C

sharp.
Verso eletrnica do jogo A Torre de Hanoi
torres de hani com licena GPL, com capacidade de auto-resolucao, em C++, usando wxWidgets como gui

Fontes, contribuidores e licenas de texto e imagem

7.1

FONTES, CONTRIBUIDORES E LICENAS DE TEXTO E IMAGEM

Texto

Torre de Hani Fonte: http://pt.wikipedia.org/wiki/Torre%20de%20Han%C3%B3i?oldid=40423106 Contribuidores: Paul Beppler, Mschlindwein, Juntas, Nuno Tavares, Rei-artur, Leslie, Jcmo, 333, YurikBot, Luisf silva, Fernando S. Aldado, SallesNeto BR, Ciacchi, Bigs,
Leonardo.stabile, LijeBot, Mastermorfeu, RodrigoSampaioPrimo, Rodrigozanatta, Refry, Horacio pizzolante, Shogun Luis, Thijs!bot,
Rei-bot, Joozinho, Delemon, CommonsDelinker, Jack Bauer00, Bot-Schafter, Luckas Blade, Carlos28, TXiKiBoT, Tumnus, VolkovBot, SieBot, Lechatjaune, Slomp, BotMultichill, AlleborgoBot, Zdtrlik, GOE, Crazyaboutlost, PequijanFAP, Fabiogomesdelimalho,
Beria, Elcio9708, BOTarate, Ruy Pugliesi, Pietro Roveri, !Silent, Vitor Mazuco, Luckas-bot, LinkFA-Bot, Andressamistica, AlyssonMilanez, MystBot, Nallimbot, CasperBraske, Salebot, XZeroBot, Xqbot, Lpton, Jlfreimam, RibotBOT, HVL, Capito Pirata Bruxo,
EmausBot, HRoestBot, rico Jnior Wouters, Stuckkey, WikiGT, MerlIwBot, Ademar Brasil, DARIO SEVERI, FabioEduardoMoreira,
Prima.philosophia, Legobot, Peralta2305 e Annimo: 97

7.2

Imagens

Ficheiro:NoFonti.svg Fonte: http://upload.wikimedia.org/wikipedia/commons/b/b5/NoFonti.svg Licena: CC BY-SA 2.5 Contribuidores: Image:Emblem-important.svg Artista original: RaminusFalcon
Ficheiro:Tower_of_Hanoi.jpeg Fonte: http://upload.wikimedia.org/wikipedia/commons/0/07/Tower_of_Hanoi.jpeg Licena: CC-BYSA-3.0 Contribuidores: ? Artista original: ?
Ficheiro:Tower_of_Hanoi_4.gif Fonte: http://upload.wikimedia.org/wikipedia/commons/6/60/Tower_of_Hanoi_4.gif Licena: CC
BY-SA 2.5 Contribuidores: Obra do prprio Artista original: Andr Karwath aka Aka

7.3

Licena

Creative Commons Attribution-Share Alike 3.0