Pour savoir ce qu'est la tour de Hanoi, recherchez-la sur Google ou regardez sur la page Wikipedia .

Votre code devrait pouvoir faire 2 choses, et ce sont les suivantes:

• Acceptez l'entrée utilisateur qui spécifie le nombre de disques au point de départ de la tour de Hanoi
• Créez une sortie de la manière de votre choix (tant qu'elle est en quelque sorte logique) pour montrer la solution au puzzle de la tour.

Un exemple de sortie logique serait le suivant (en utilisant un démarrage à 4 disques):

L1L2C1L1R-2R-1L1L2C1C-1R-2C1L1L2C1

Lreprésente la cheville gauche, Creprésente la cheville centrale et Rreprésente la cheville droite et les nombres indiquent jusqu'où déplacer le disque sur cette cheville et dans quelle direction. Les nombres positifs représentent le nombre de chevilles se déplaçant vers la cheville la plus à droite (car les disques commencent sur la cheville la plus à gauche).

Les règles de la tour de Hanoi sont simples:

• Un seul disque peut être déplacé à la fois.
• Chaque mouvement consiste à prendre le disque supérieur de l'un des piquets et à le faire glisser sur un autre piquet, au-dessus des autres disques qui peuvent déjà être présents sur ce piquet.
• Aucun disque ne peut être placé au-dessus d'un disque plus petit.

Les disques commencent sur la cheville la plus à gauche, le plus grand en bas, le plus petit en haut, naturellement.

Husk , 5 octets

↑≠⁰İr

Essayez-le en ligne!
Chacun ndans la sortie représente le déplacement du disque nvers la prochaine cheville disponible (encapsulation cyclique).

Explication

   İr   The ruler sequence [0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, ...]
↑       Take while...
 ≠⁰     ... not equal to the input.

Python, 76 caractères

def S(n,a,b):
 if n:S(n-1,a,6-a-b);print n,a,b;S(n-1,6-a-b,b)
S(input(),1,3)

Par exemple, pour N = 3, il renvoie:

1 1 3  (move disk 1 from peg 1 to peg 3)
2 1 2  (move disk 2 from peg 1 to peg 2)
1 3 2  (move disk 1 from peg 3 to peg 2)
3 1 3  ...
1 2 1
2 2 3
1 1 3

Perl - 54 caractères

for(2..1<<<>){$_--;$x=$_&-$_;say(($_-$x)%3,($_+$x)%3)}

Exécutez avec perl -M5.010et entrez le nombre de disques sur stdin.

Format de sortie:

Une ligne par coup, le premier chiffre provient du piquet, le deuxième chiffre est du piquet (à partir de 0)

Exemple:

02 -- move from peg 0 to peg 2
01
21
02
10
12
02

GolfScript ( 31 25 24 caractères)

])~{{~3%}%.{)3%}%2,@++}*

Merci à Ilmari Karonen d'avoir souligné que mes trpermutations originales pourraient être raccourcies de 6 caractères. En les décomposant comme un produit de deux permutations, j'ai réussi à en sauver une de plus.

Notez que la prise en compte de la 3%longueur augmente d'un caractère:

])~{{~}%.{)}%2,@++}*{3%}%

Certaines personnes ont des formats de sortie vraiment compliqués. Cela émet la cheville déplacée (numérotée 0, 1, 2) et la cheville déplacée vers. La spécification ne dit pas vers quelle cheville déplacer, elle se déplace donc vers la cheville 1.

Par exemple

$ golfscript hanoi.gs <<<"3"
01021201202101

Perl, 75 79 caractères

Volant totalement le format de sortie de Keith Randall:

sub h{my($n,$p,$q)=@_;h($n,$p^$q^h($n,$p,$p^$q),$q*say"@_")if$n--}h pop,1,3

Appelez avec -M5.010pour le say.

(Je pense que cela peut être amélioré si vous pouvez trouver un moyen d'utiliser la valeur de retour de la fonction au lieu de simplement la supprimer.)

SML, 63

fun f(0,_,_)=[]|f(n,s,t)=f(n-1,s,6-s-t)@[n,s,t]@f(n-1,6-s-t,t);

fonction d'appel f(n,s,t)avec:

• n nombre de disques
• s point de départ
• point de but

Bash (64 caractères)

t(){ tr 2$1 $12 <<<$s;};for((i=$1;i--;))do s=`t 1`01`t 0`;done;t

Publier celui-ci en dépit d'être plus de deux fois plus long que celui de GolfScript parce que j'aime la réutilisation de tpour servir de echo $s.

Scala, 92 88 87 caractères

def?(n:Int,a:Int,b:Int){if(n>0){?(n-1,a,a^b)
print(n,a,b);?(n-1,a^b,b)}};?(readInt,1,3)

Format de sortie

Dites alors nombre de disque = 3,

(1,1,3)(2,1,2)(1,3,2)(3,1,3)(1,2,1)(2,2,3)(1,1,3) (disk number,from peg, to peg)
                                                   \---------------------------/       
                                                            Move 1              ... Move n

C, 98 92 87 caractères

Implémente l'algorithme le plus trivial.
La sortie est sous la forme ab ab aboù chaque paire signifie "déplacer le disque supérieur de la cheville a vers la cheville b".
EDIT : les mouvements sont maintenant encodés en hexadécimal - 0x12 signifie passer de la cheville 1 à la cheville 2. Sauvegardé quelques caractères.
EDIT : lit le nombre depuis stdin, plutôt que le paramètre. Plus court.
Exemple:
% echo 3 | ./hanoi
13 12 32 13 21 23 13

n;
h(d){n--&&h(d^d%16*16,printf("%02x ",d,h(d^d/16))),n++;}
main(){scanf("%d",&n);h(19);}

Gelée , 5 octets

2*Ṗọ2

Essayez-le en ligne!

0déplacer le plus petit disque d'un espace vers la droite (retour au début si nécessaire)
1déplacer le deuxième plus petit disque vers la seule autre colonne légale
2déplacer le troisième plus petit disque vers la seule autre colonne légale,
etc.

Algorithme

Nous pouvons voir la solution du problème des tours de Hanoi récursivement; pour déplacer une pile de taille n de A à B , déplacer une pile de taille n -1 à partir de A à C , le disque de taille n de A à B , puis déplacer une pile de taille n -1 à partir de B à C . Cela produit un modèle de la forme suivante (dans le format de sortie utilisé par ce programme):

0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2 …

Nous pouvons observer que cette séquence est A007814 sur l'OEIS. Une autre définition possible de la séquence est "l' élément k ème (basé sur 1) de la séquence est le nombre de zéros à la fin du nombre k lorsqu'il est écrit en binaire". Et c'est ce que le programme calcule ici.

Explication

Tout d'abord, nous calculons le nombre de mouvements dans la solution, 2 ⁿ -1. Il s'avère être le plus court pour réellement calculer un coup supplémentaire et le jeter plus tard, c'est-à- 2*dire 2 à la puissance de quelque chose. (La seule entrée que nous avons prise jusqu'à présent est l'argument de ligne de commande, de sorte qu'il est utilisé par défaut.)

Ensuite, nous utilisons la fonction intégrée de Jelly pour calculer le nombre de zéros à la fin d'un nombre dans la base b ; c'est . Comme nous calculons en binaire, c'est . Tout ce que nous devons faire est d'appliquer ce code intégré aux nombres de 1 à 2 ⁿ -1 inclus.ọbọ2

Il existe deux façons simples d'itérer sur une plage de nombres dans Jelly, €et R, et mes tentatives précédentes sur ce problème en ont utilisé une. Cependant, dans ce cas, il est possible d'aller un peu plus court :, Ṗlorsque vous donnez un nombre en entrée, vous permettra de faire une itération qui arrête un élément court (en général, Ṗest une fonction intégrée utilisée pour traiter tout sauf un élément de quelque chose). C'est exactement ce que nous voulons dans ce cas (car il 2*génère un trop grand nombre d'éléments), donc l'utiliser pour établir un lien 2*et ọ2entrer 2*Ṗọ2nous donne une solution de 5 octets au problème.

Awk, 72 caractères

function t(n,a,b){if(n){t(n-1,a,a^b);print n,a,b;t(n-1,a^b,b)}}t($0,1,3)

Le format de sortie est le même que celui de Keith Randall .

awk -f tower.awk <<< "3"    
1 1 1
2 1 1
1 1 1
3 1 3
1 1 1
2 1 3
1 1 3

Script bash, 100 96 caractères

t(){ [[ $1<1 ]] && return
t $(($1-1)) $2 $(($2^$3))
echo $@
t $(($1-1)) $(($2^$3)) $3
}
t $1 1 3

Le format de sortie est le même que celui de Keith Randall .

1 1 3
2 1 2
1 3 2
3 1 3
1 2 1
2 2 3
1 1 3

Modifier : Saved 4 caractères par peter commentaire s.

J, 23 octets

solution de nombres binaires

2&(+/@:~:/\)@#:@i.@^~&2

Cette solution utilise la méthode de comptage binaire décrite dans cette vidéo .

C'est-à-dire que je génère les chiffres binaires de 1jusqu'à 2^n, puis prends des infixes de longueur 2 et compare chaque bit au bit correspondant du nombre précédent, et vérifie s'ils sont inégaux. Le nombre de bits inégaux est la sortie de ce mouvement.

Sortie, par exemple, pour 3 disques, où le plus petit disque est étiqueté 1:

1 2 1 3 1 2 1

1 signifie "déplacer le plus petit disque d'une cheville vers la droite, en rebouclant sur la première cheville si nécessaire"

n, pour tous les autres n, signifie "déplacer le disque nvers une cheville légale" (il y en aura toujours exactement un)

Essayez-le en ligne!

solution récursive

((],[,])$:@<:)`]@.(1=])

Même sortie que la solution ci-dessus, mais la logique ici rend la nature récursive du problème plus claire.

Le visualiser sous forme d'arbre souligne également ce point:

              4
             / \
            /   \
           /     \
          /       \
         /         \
        /           \
       /             \
      3               3      
     / \             / \    
    /   \           /   \
   /     \         /     \ 
  2       2       2       2  
 / \     / \     / \     / \
1   1   1   1   1   1   1   1

Essayez-le en ligne!

APL (Dyalog Classic) , 19 octets

3|(-⍪0 1⍪2∘-)⍣⎕,⍨⍪⍬

Essayez-le en ligne!

la sortie est une matrice à deux colonnes d'entiers en {0,1,2} - de la cheville à la cheville

K (ngn / k) , 23 octets

{3!x{-x,(,0 2),1+x}/()}

Essayez-le en ligne!

R , 73 octets

Mettre R sur la carte. Inspiré de [la réponse de Keith Randall] [1] avec une entrée simplifiée, n'imprimez que la fin et le début du rattachement pour économiser 2 octets. Également des chevilles indexées 0.

f=function(n,s=0,e=2){if(n){f(n-1,s,3-s-e)
print(c(s,e))
f(n-1,3-s-e,e)}}

Essayez-le en ligne!

JavaScript (ES6), 45b

h=(n,f,a,t)=>n?h(--n,f,t,a)+f+t+h(n,a,f,t):''

Par exemple, appeler h(4, 'A', 'B', 'C')(déplacer 4 disques du piquet A au piquet C en utilisant le piquet auxiliaire B)

Retour 'ABACBCABCACBABACBCBACABCABACBC' (déplacer un disque du piquet A au piquet B, déplacer un disque du piquet A au piquet C, déplacer un disque du piquet B au piquet C, etc.)