Rosetta Code

Towers of Hanoi: Difference between revisions

Page Discussion

Towers of Hanoi (view source)

Revision as of 15:12, 22 November 2009

134 bytes removed ,  14 years ago
m
Fixed lang tags.
(Perl 5: Changed to permit calling with one argument. Perl 6: Added.)
m (Fixed lang tags.)
Line 2:
 
=={{header|ActionScript}}==
<lang actionscript>public function move(n:int, from:int, to:int, via:int):void
public function move(n:int, from:int, to:int, via:int):void
{
if (n > 0)
Line 11 ⟶ 10:
move(n - 1, via, to, from);
}
}</lang>
}
</lang>
 
=={{header|Ada}}==
<lang ada>with Ada.Text_Io; use Ada.Text_Io;
 
with Ada.Text_Io; use Ada.Text_Io;
procedure Towers is
type Pegs is (Left, Center, Right);
procedure Towers is
procedure Hanoi (Ndisks : Natural; Start_Peg : Pegs := Left; End_Peg : Pegs := Right; Via_Peg : Pegs := Center) is
type Pegs is (Left, Center, Right);
begin
procedure Hanoi (Ndisks : Natural; Start_Peg : Pegs := Left; End_Peg : Pegs := Right; Via_Peg : Pegs := Center) is
if Ndisks > 0 then
begin
if Hanoi(Ndisks >- 1, Start_Peg, 0Via_Peg, thenEnd_Peg);
Put_Line("Move disk" & HanoiNatural'Image(Ndisks) -& 1," Start_Peg,from Via_Peg," End_Peg& Pegs'Image(Start_Peg); & " to " &
Put_Line("Move disk" & Natural'Image(Ndisks) & " from " & Pegs'Image(Start_PegEnd_Peg) & " to " &);
Hanoi(Ndisks - 1, Via_Peg, Pegs'Image(End_Peg), Start_Peg);
end if;
Hanoi(Ndisks - 1, Via_Peg, End_Peg, Start_Peg);
end ifHanoi;
begin
end Hanoi;
Hanoi(4);
begin
end Towers;</lang>
Hanoi(4);
end Towers;
</lang>
 
=={{header|ALGOL 68}}==
<lang algol68>PROC move = (INT n, from, to, via) VOID:
IF n > 0 THEN
move(n - 1, from, via, to);
printf(($"Move disk from pole "g" to pole "gl$, from, to));
move(n - 1, via, to, from)
FI
;
 
main: (
move(4, 1,2,3)
)</lang>
)
 
=={{header|AmigaE}}==
Line 61 ⟶ 57:
 
=={{header|AppleScript}}==
<lang applescript> global moves --this is so the handler 'hanoi' can see the 'moves' variable
set moves to ""
hanoi(4, "peg A", "peg C", "peg B")
 
on hanoi(ndisks, fromPeg, toPeg, withPeg)
if ndisks is greater than 0 then
hanoi(ndisks - 1, fromPeg, withPeg, toPeg)
set moves to moves & "Move disk " & ndisks & " from " & fromPeg & " to " & toPeg & return
hanoi(ndisks - 1, withPeg, toPeg, fromPeg)
end if
return moves
end hanoi</lang>
 
=={{header|AutoHotkey}}==
<lang AutoHotkey>move(n, from, to, via) ;n = # of disks, from = start pole, to = end pole, via = remaining pole
<lang AutoHotkey>
{
move(n, from, to, via) ;n = # of disks, from = start pole, to = end pole, via = remaining pole
if (n = 1)
{
{
if (n = 1)
msgbox , Move disk from pole %from% to pole %to%
{
}
msgbox , Move disk from pole %from% to pole %to%
}else
else{
move(n-1, from, via, to)
{
move(n-1, from, viato, tovia)
move(n-1, fromvia, to, viafrom)
}
move(n-1, via, to, from)
}</lang>
}
}
</lang>
 
=={{header|AWK}}==
{{trans|Logo}}
<lang AWK>$ awk 'func hanoi(n,f,t,v){if(n>0){hanoi(n-1,f,v,t);print(f,"->",t);hanoi(n-1,v,t,f)}}
<lang AWK>
$ awk 'func hanoi(n,f,t,v){if(n>0){hanoi(n-1,f,v,t);print(f,"->",t);hanoi(n-1,v,t,f)}}
BEGIN{hanoi(4,"left","middle","right")}'
left -> right
Line 110 ⟶ 103:
left -> right
left -> middle
right -> middle</lang>
</lang>
 
=={{header|BASIC}}==
Line 129 ⟶ 121:
 
=={{header|C}}==
<lang c>#include <stdio.h>
 
#include <stdio.h>
void move(int n, int from, int to, int via)
{
void move(int n, int from, int to, int via)
if (n > 0) {
{
if move(n >- 0)1, {from, via, to);
moveprintf(n"Move - 1,disk from pole %d to pole %d\n", viafrom, to);
printfmove("Moven disk- from1, pole %dvia, to pole %d\n", from, to);
}
move(n - 1, via, to, from);
}
int main()
}
{
int main()
move(4, 1,2,3);
{
return 0;
move(4, 1,2,3);
}</lang>
return 0;
}
</lang>
 
=={{header|C sharp|C#}}==
Line 160 ⟶ 150:
=={{header|C++}}==
{{works with|g++}}
<lang cpp> void move(int n, int from, int to, int via) {
if (n == 1) {
std::cout << "Move disk from pole " << from << " to pole " << to << std::endl;
} else {
move(n - 1, from, via, to);
move(1, from, to, via);
move(n - 1, via, to, from);
}
}</lang>
 
=={{header|Clojure}}==
 
<lang lisp>(defn towers-of-hanoi [n from to via]
(if (= n 1)
(println (format "Move from %s to %s" from to))
(do
(towers-of-hanoi (dec n) from via to)
(println (format "Move from %s to %s" from to))
(recur (dec n) via to from))))</lang>
 
=={{header|Common Lisp}}==
 
<lang lisp> (defun move (n from to via)
(cond ((= n 1)
(format t "Move from ~A to ~A.~%" from to))
(t
(move (- n 1) from via to)
(format t "Move from ~A to ~A.~%" from to)
(move (- n 1) via to from))))</lang>
 
=={{header|D}}==
Line 258 ⟶ 248:
]sM
[ # code block <lang ddc>
ln # push n
lf # push from
Line 317 ⟶ 307:
=={{header|E}}==
 
<lang e> def move(out, n, fromPeg, toPeg, viaPeg) {
if (n.aboveZero()) {
move(out, n.previous(), fromPeg, viaPeg, toPeg)
out.println(`Move disk $n from $fromPeg to $toPeg.`)
move(out, n.previous(), viaPeg, toPeg, fromPeg)
}
}
 
move(stdout, 4, def left {}, def right {}, def middle {})</lang>
 
=={{header|Erlang}}==
<lang erlang>move(1, F, T, _V) ->
io:format("Move from ~p to ~p~n", [F, T]);
move(N, F, T, V) ->
move(N-1, F, V, T),
move(1 , F, T, V),
move(N-1, V, T, F).</lang>
 
=={{header|FALSE}}==
<lang false>["Move disk from "$!\" to "$!\"
"]p: { to from }
[n;0>[n;1-n: @\ h;! @\ p;! \@ h;! \@ n;1+n:]?]h: { via to from }
4n:["right"]["middle"]["left"]h;!%%%</lang>
 
=={{header|Forth}}==
With locals:
 
<lang forth>CREATE peg1 ," left "
CREATE peg2 ," middle "
CREATE peg3 ," right "
 
: .$ COUNT TYPE ;
: MOVE-DISK
LOCALS| via to from n |
n 1 =
IF CR ." Move disk from " from .$ ." to " to .$
ELSE n 1- from via to RECURSE
1 from to via RECURSE
n 1- via to from RECURSE
THEN ;</lang>
 
Without locals, executable pegs:
 
<lang forth>: left ." left" ;
: right ." right" ;
: middle ." middle" ;
 
: move-disk ( v t f n -- v t f )
dup 0= if drop exit then
1- >R
rot swap R@ ( t v f n-1 ) recurse
rot swap
2dup cr ." Move disk from " execute ." to " execute
swap rot R> ( f t v n-1 ) recurse
swap rot ;
: hanoi ( n -- )
1 max >R ['] right ['] middle ['] left R> move-disk drop drop drop ;</lang>
 
=={{header|Fortran}}==
{{works with|Fortran|90 and later}}
<lang fortran> PROGRAM TOWER
CALL Move(4, 1, 2, 3)
CONTAINS
 
RECURSIVE SUBROUTINE Move(ndisks, from, to, via)
INTEGER, INTENT (IN) :: ndisks, from, to, via
IF (ndisks == 1) THEN
WRITE(*, "(A,I1,A,I1)") "Move disk from pole ", from, " to pole ", to
ELSE
CALL Move(ndisks-1, from, via, to)
CALL Move(1, from, to, via)
CALL Move(ndisks-1, via, to, from)
END IF
END SUBROUTINE Move
 
END PROGRAM TOWER</lang>
 
=={{header|Haskell}}==
Line 401 ⟶ 391:
Most of the programs on this page use an imperative approach (i.e., print out movements as side effects during program execution). Haskell favors a purely functional approach, where you would for example return a (lazy) list of movements from a to b via c:
 
<lang haskell> hanoi :: Integer -> a -> a -> a -> [(a, a)]
hanoi 0 _ _ _ = []
hanoi n a b c = hanoi (n-1) a c b ++ [(a,b)] ++ hanoi (n-1) c b a</lang>
 
One can use this function to produce output, just like the other programs:
 
<lang haskell> hanoiIO n = mapM_ f $ hanoi n 1 2 3 where
f (x,y) = putStrLn $ "Move " ++ show x ++ " to " ++ show y</lang>
 
Or, instead one can of course also program imperatively, using the IO monad directly:
 
<lang haskell> hanoiM :: Integer -> IO ()
hanoiM n = hanoiM' n 1 2 3 where
hanoiM' 0 _ _ _ = return ()
hanoiM' n a b c = do
hanoiM' (n-1) a c b
putStrLn $ "Move " ++ show a ++ " to " ++ show b
hanoiM' (n-1) c b a</lang>
 
=={{header|Io}}==
<lang io>hanoi := method(n, from, to, via,
if (n == 1) then (
writeln("Move from ", from, " to ", to)
) else (
hanoi(n - 1, from, via, to )
hanoi(1 , from, to , via )
hanoi(n - 1, via , to , from)
)
)</lang>
)
 
=={{header|J}}==
<lang j>H =: i.@(,&2) ` (({&0 2 1,0 2,{&1 0 2)@$:@<:) @. *
<lang j>
H =: i.@(,&2) ` (({&0 2 1,0 2,{&1 0 2)@$:@<:) @. *
 
H1=: monad define
Line 441 ⟶ 430:
i.0 2
end.
)</lang>
)
</lang>
<tt>H</tt> employs anonymous recursion; <tt>H1</tt> is an "explicit" statement of the same computation. For example:
<lang j> H 3
H 3
0 2
0 1
Line 452 ⟶ 439:
1 2
1 0
2 0</lang>
</lang>
The result is a 2-column table; a row <tt>i,j</tt> is interpreted as: move a disk (the top disk) from peg <tt>i</tt> to peg<tt> j</tt> .
 
=={{header|Java}}==
 
<lang java> public void move(int n, int from, int to, int via) {
if (n == 1) {
System.out.println("Move disk from pole " + from + " to pole " + to);
} else {
move(n - 1, from, via, to);
move(1, from, to, via);
move(n - 1, via, to, from);
}
}</lang>
 
=={{header|JavaScript}}==
<lang javascript> function move(n, from, to, via) {
if (n > 0) {
move(n-1, from, via, to)
print("Move disk from " + from + " to " + to)
move(n-1, via, to, from)
}
}
move(4, "left", "middle", "right")</lang>
 
=={{header|Joy}}==
From [http://www.latrobe.edu.au/philosophy/phimvt/joy/jp-nestrec.html here]
<lang joy>DEFINE hanoi == [[rolldown] infra] dip
DEFINE hanoi == [[rolldown] infra] dip
[ [ [null] [pop pop] ]
[ [dup2 [[rotate] infra] dip pred]
Line 487 ⟶ 472:
[[swap] infra] dip pred ]
[] ] ]
condnestrec.</lang>
</lang>
Using it (5 is the number of disks.)
<lang joy>[source destination temp] 5 hanoi.</lang>
<lang joy>
[source destination temp] 5 hanoi.
</lang>
 
=={{header|Logo}}==
<lang logo>to move :n :from :to :via
if :n = 0 [stop]
move :n-1 :from :via :to
(print [Move disk from] :from [to] :to)
move :n-1 :via :to :from
end
move 4 "left "middle "right</lang>
 
=={{header|Mathematica}}==
<lang mathematica>Hanoi[0, from_, to_, via_] := Null
Hanoi[n_Integer, from_, to_, via_] :=
(Hanoi[n-1, from, via, to];
Print["Move dist from pole ", from, " to ", to, "."];
Hanoi[n-1, via, from, to])</lang>
 
=={{header|Modula-3}}==
Line 536 ⟶ 518:
 
The Interface - TowersOfHanoi.h:
<lang objc>#import <Foundation/NSObject.h>
#import <Foundation/NSObject.h>
 
@interface TowersOfHanoi: NSObject {
Line 548 ⟶ 529:
-(void) setPegFrom: (int) from andSetPegTo: (int) to andSetPegVia: (int) via andSetNumDisks: (int) disks;
-(void) movePegFrom: (int) from andMovePegTo: (int) to andMovePegVia: (int) via andWithNumDisks: (int) disks;
@end</lang>
</lang>
 
The Implementation - TowersOfHanoi.m:
 
<lang objc>#import "TowersOfHanoi.h"
#import "TowersOfHanoi.h"
@implementation TowersOfHanoi
 
Line 574 ⟶ 553:
}
 
@end</lang>
</lang>
 
Test code: TowersTest.m:
 
<lang objc>#import <stdio.h>
#import <stdio.h>
#import "TowersOfHanoi.h"
 
Line 598 ⟶ 575:
 
return 0;
}</lang>
}
</lang>
 
=={{header|OCaml}}==
Line 633 ⟶ 609:
I think it is standard pascal, except for the constant array "strPole". I am not sure if constant arrays are part of the standard. However, as far as I know, they are a "de facto" standard in every compiler.
 
<lang pascal> program Hanoi;
type
TPole = (tpLeft, tpCenter, tpRight);
const
strPole:array[TPole] of string[6]=('left','center','right');
 
procedure MoveStack (const Ndisks : integer; const Origin,Destination,Auxiliary:TPole);
begin
if Ndisks >0 then begin
MoveStack(Ndisks - 1, Origin,Auxiliary, Destination );
Writeln('Move disk ',Ndisks ,' from ',strPole[Origin],' to ',strPole[Destination]);
MoveStack(Ndisks - 1, Auxiliary, Destination, origin);
end;
end;
 
begin
MoveStack(4,tpLeft,tpCenter,tpRight);
end.</lang>
 
A little longer, but clearer for my taste
<lang pascal> program Hanoi;
type
TPole = (tpLeft, tpCenter, tpRight);
const
strPole:array[TPole] of string[6]=('left','center','right');
 
procedure MoveOneDisk(const DiskNum:integer; const Origin,Destination:TPole);
begin
Writeln('Move disk ',DiskNum,' from ',strPole[Origin],' to ',strPole[Destination]);
end;
 
procedure MoveStack (const Ndisks : integer; const Origin,Destination,Auxiliary:TPole);
begin
if Ndisks =1 then
MoveOneDisk(1,origin,Destination)
else begin
MoveStack(Ndisks - 1, Origin,Auxiliary, Destination );
MoveOneDisk(Ndisks,origin,Destination);
MoveStack(Ndisks - 1, Auxiliary, Destination, origin);
end;
end;
 
begin
MoveStack(4,tpLeft,tpCenter,tpRight);
end.</lang>
 
=={{header|Perl}}==
Line 706 ⟶ 682:
=={{header|PHP}}==
{{trans|Java}}
<lang php>function move($n,$from,$to,$via) {
function move($n,$from,$to,$via) {
if ($n === 1) {
print("Move disk from pole $from to pole $to");
Line 715 ⟶ 690:
move(n-1,$via,$to,From);
}
}</lang>
}
</lang>
 
=={{header|Pop11}}==
 
<lang pop11>define hanoi(n, src, dst, via);
if n > 0 then
hanoi(n - 1, src, via, dst);
'Move disk ' >< n >< ' from ' >< src >< ' to ' >< dst >< '.' =>
hanoi(n - 1, via, dst, src);
endif;
enddefine;
 
hanoi(4, "left", "middle", "right");</lang>
 
=={{header|Python}}==
Line 792 ⟶ 766:
=={{header|Seed7}}==
 
<lang seed7>const proc: hanoi (in integer: disk, in string: source, in string: dest, in string: via) is func
begin
if disk > 0 then
hanoi(pred(disk), source, via, dest);
writeln("Move disk " <& disk <& " from " <& source <& " to " <& dest);
hanoi(pred(disk), via, dest, source);
end if;
end func;</lang>
 
=={{header|Tcl}}==
Line 837 ⟶ 811:
=={{header|Toka}}==
 
<lang toka>value| sa sb sc n |
[ to sc to sb to sa to n ] is vars!
[ ( num from to via -- )
vars!
n 0 <>
[
n sa sb sc
n 1- sa sc sb recurse
vars!
." Move a ring from " sa . ." to " sb . cr
n 1- sc sb sa recurse
] ifTrue
] is hanoi</lang>
 
=={{header|UNIX Shell}}==
Line 855 ⟶ 829:
{{works with|bash}}
 
<lang bash>#!/bin/bash
#!/bin/bash
 
move()
Line 875 ⟶ 848:
}
move $1 $2 $3 $4</lang>
</lang>
 
=={{header|Ursala}}==
<lang Ursala>#import nat
#import nat
 
move = ~&al^& ^rlPlrrPCT/~&arhthPX ^|W/~& ^|G/predecessor ^/~&htxPC ~&zyxPC
Line 886 ⟶ 857:
#show+
 
main = ^|T(~&,' -> '--)* move/4 <'start','end','middle'></lang>
</lang>
output:
<pre>start -> middle
Line 907 ⟶ 877:
=={{header|Vedit macro language}}==
This implementation outputs the results in current edit buffer.
<lang vedit>#1=1; #2=2; #3=3; #4=4 // move 4 disks from 1 to 2
<lang vedit>
#1=1; #2=2; #3=3; #4=4 // move 4 disks from 1 to 2
Call("MOVE_DISKS")
Return
Line 932 ⟶ 901:
Num_Pop(1,4)
}
Return</lang>
</lang>
 
=={{header|Visual Basic .NET}}==
Line 949 ⟶ 917:
MoveTowerDisks(4, 1, 2, 3)
End Sub
End Module</lang>
</lang>
 
=={{header|XSLT}}==
<lang xml><xsl:template name="hanoi">
<xsl:param name="n"/>
<xsl:param name="from">left</xsl:param>
<xsl:param name="to">middle</xsl:param>
<xsl:param name="via">right</xsl:param>
<xsl:if test="$n &amp;gt; 0">
<xsl:call-template name="hanoi">
<xsl:with-param name="n" select="$n - 1"/>
<xsl:with-param name="from" select="$from"/>
<xsl:with-param name="to" select="$via"/>
<xsl:with-param name="via" select="$to"/>
</xsl:call-template>
<fo:block>
<xsl:text>Move disk from </xsl:text>
<xsl:value-of select="$from"/>
<xsl:text> to </xsl:text>
<xsl:value-of select="$to"/>
</fo:block>
<xsl:call-template name="hanoi">
<xsl:with-param name="n" select="$n - 1"/>
<xsl:with-param name="from" select="$via"/>
<xsl:with-param name="to" select="$to"/>
<xsl:with-param name="via" select="$from"/>
</xsl:call-template>
</xsl:if>
</xsl:template></lang>
 
<xsl:call-template name="hanoi"><xsl:with-param name="n" select="4"/></xsl:call-template>
Anonymous user
Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/14194"