Towers of Hanoi: Difference between revisions

 

=={{header|ActionScript}}==

{

if (n > 0)

move(n - 1, via, to, from);

}

 

=={{header|Ada}}==

 

procedure Towers is

begin

Hanoi(4);

 

=={{header|Agena}}==

if n > 0 then

move(n - 1, src, via, dst)

end

 

 

=={{header|ALGOL 68}}==

IF n > 0 THEN

move(n - 1, from, via, to);

main: (

move(4, 1,2,3)

 

=={{header|AmigaE}}==

IF n > 0

move(n-1, from, via, to)

PROC main()

move(4, 1,2,3)

 

=={{header|AppleScript}}==

 

end if

=={{header|AutoHotkey}}==

{

if (n = 1)

}

}

 

=={{header|AutoIt}}==

If ($n = 1) Then

ConsoleWrite(StringFormat("Move disk from pole "&$from&" To pole "&$to&"\n"))

EndFunc

 

 

=={{header|AWK}}==

{{trans|Logo}}

{{out}}

<pre>left -> right

{{works with|FreeBASIC}}

{{works with|RapidQ}}

IF n>0 THEN

move n-1, fromPeg, viaPeg, toPeg

END SUB

 

 

===Using <code>GOSUB</code>s===

Here's an example of implementing recursion in an old BASIC that only has global variables:

{{works with|Applesoft BASIC}}

{{works with|Commodore BASIC}}

100 IF N(SP) = 0 THEN RETURN

120 SP = SP + 1: REM INCREMENT STACK POINTER

130 N(SP) = N(OS) - 1: REM MOVE N-1 DISCS

240 GOSUB 100

250 SP = SP - 1 : REM RESTORE STACK POINTER FOR CALLER

 

print "Towers of Hanoi puzzle completed!"

end

call move(n-1, viaPeg, toPeg, fromPeg)

end if

 

{{out}}

Towers of Hanoi puzzle completed!

</pre>

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

FOR disc% = 1 TO 13

Disc$(disc%) = STRING$(disc%," ")+STR$disc%+STRING$(disc%," ")

Size%(peg%) = Size%(peg%)-1

PRINTTAB(13+26*(peg%-1)-disc%,20-Size%(peg%))STRING$(2*disc%+1," ");

 

=={{header|Bracmat}}==

= n from to via

. !arg:(?n,?from,?to,?via)

)

& move$(4,1,2,3)

<pre>Move disk from pole 1 to pole 3

Move disk from pole 1 to pole 2

Move disk from pole 1 to pole 2

Move disk from pole 3 to pole 2</pre>

 

=={{header|C}}==

 

{

printf("Move disk from pole %d to pole %d\n", from, to);

}

}

move(4, 1,2,3);

return 0;

 

#include <stdlib.h>

#include <unistd.h>

text(1, 0, 1, "\n");

return 0;

 

=={{header|C sharp|C#}}==

if (n == 1) {

System.Console.WriteLine("Move disk from pole " + from + " to pole " + to);

move(n - 1, via, to, from);

}

 

=={{header|C++}}==

{{works with|g++}}

if (n == 1) {

std::cout << "Move disk from pole " << from << " to pole " << to << std::endl;

move(n - 1, via, to, from);

}

 

=={{header|Clojure}}==

 

=={{header|COBOL}}==

{{trans|C}}

{{works with|OpenCOBOL|2.0}}

IDENTIFICATION DIVISION.

PROGRAM-ID. towers-of-hanoi.

END-IF

.

 

=={{header|CoffeeScript}}==

if ndisks

staging_peg = 1 + 2 + 3 - start_peg - end_peg

hanoi(ndisks-1, staging_peg, end_peg)

 

=={{header|Common Lisp}}==

(cond ((= n 1)

(format t "Move from ~A to ~A.~%" from to))

(move (- n 1) from via to)

(format t "Move from ~A to ~A.~%" from to)

 

=={{header|D}}==

===Recursive Version===

 

void hanoi(in int n, in char from, in char to, in char via) {

void main() {

hanoi(3, 'L', 'M', 'R');

{{out}}

<pre>Move disk 1 from L to M

===Fast Iterative Version===

See: [http://hanoitower.mkolar.org/shortestTHalgo.html The shortest and "mysterious" TH algorithm]

// then some more by M. Kolar (2000).

void main(in string[] args) {

'\n'.putchar;

}

{{out}}

<pre>| 3 2 1

 

=={{header|Dart}}==

moveit(from,to) {

print("move ${from} ---> ${to}");

 

hanoi(3,3,1,2);

 

The same as above, with optional static type annotations and styled according to http://www.dartlang.org/articles/style-guide/

String say(String from, String to) => "$from ---> $to";

 

 

hanoi(3, 3, 1, 2);

 

{{out}}

lrx # run()

</pre>

 

=={{header|E}}==

if (n.aboveZero()) {

move(out, n.previous(), fromPeg, viaPeg, toPeg)

}

 

 

=={{header|Eiffel}}==

APPLICATION

 

end

end

 

=={{header|Emacs Lisp}}==

{{Trans|Common Lisp}}

 

=={{header|Erlang}}==

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

 

 

{{out}}

</pre>

=={{header|Ezhil}}==

# (C) 2013 Ezhil Language Project

# Tower of Hanoi – recursive solution

 

ஹோனாய்(4,”அ”,”ஆ”,0)

 

=={{header|F_Sharp|F#}}==

let rec hanoi num start finish =

match num with

(hanoi 4 1 2) |> List.iter (fun pair -> match pair with

| a, b -> printf "Move disc from %A to %A\n" a b)

 

=={{header|Factor}}==

IN: rosettacode.hanoi

 

from to move

n 1 - other to from hanoi

In the REPL:

<pre>( scratchpad ) 3 1 3 2 hanoi

2->3

1->3</pre>

 

=={{header|Forth}}==

With locals:

CREATE peg2 ," middle "

CREATE peg3 ," right "

1 from to via RECURSE

n 1- via to from RECURSE

Without locals, executable pegs:

: right ." right" ;

: middle ." middle" ;

swap rot ;

: hanoi ( n -- )

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

CALL Move(4, 1, 2, 3)

END SUBROUTINE Move

 

 

=={{header|GAP}}==

local move;

move := function(n, a, b, c) # from, through, to

# B -> A

# B -> C

 

=={{header|Go}}==

 

import "fmt"

func (t *towers) move1(from, to int) {

fmt.Println("move disk from rod", from, "to rod", to)

 

In other words:

 

 

import "fmt"

move(n-1, b, a, c)

}

 

=={{header|Groovy}}==

Unlike most solutions here this solution manipulates more-or-less actual stacks of more-or-less actual rings.

 

final STACK = [A:[],B:[],C:[]].asImmutable()

moveRing(from, to)

moveStack(tail(using, n-1), to, from)

Test program:

S('°'), M('o'), L('O'), XL('( )');

private sym

report()

check(STACK.A)

 

<pre style="height:30ex;overflow:scroll;">A: [( ), O, o, °]

B: []

 

=={{header|Haskell}}==

hanoi 0 _ _ _ = []

One can use this function to produce output, just like the other programs:

hanoiM n = hanoiM' n 1 2 3 where

hanoiM' 0 _ _ _ = return ()

hanoiM' (n-1) a c b

putStrLn $ "Move " ++ show a ++ " to " ++ show b

 

=={{header|Icon}} and {{header|Unicon}}==

The following is based on a solution in the Unicon book.

hanoi(arglist[1]) | stop("Usage: hanoi n\n\rWhere n is the number of disks to move.")

end

}

return

 

 

 

A post is a kind of supporter. A post is always fixed in place.

if a topmost disk (called TD) is enclosed by TP, now D is on TD;

otherwise now D is on TP;

 

=={{header|Io}}==

if (n == 1) then (

writeln("Move from ", from, " to ", to)

hanoi(n - 1, via , to , from)

)

 

=={{header|Ioke}}==

if(n < 2,

"#{f} --> #{t}" println,

hanoi = method(n,

H(n, 1, 2, 3)

 

=={{header|J}}==

'''Solutions'''

{{out|Example use}}

0 2

0 1

1 2

1 0

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> .

Or, using explicit rather than implicit code:

if. y do.

({&0 2 1 , 0 2 , {&1 0 2) H1 y-1

i.0 2

end.

The usage here is the same:

<pre> H1 2

;Alternative solution

If a textual display is desired, similar to some of the other solutions here (counting from 1 instead of 0, tracking which disk is on the top of the stack, and of course formatting the result for a human reader instead of providing a numeric result):

moves=. H y

disks=. $~` ((],[,]) $:@<:) @.* y

('move disk ';' from peg ';' to peg ');@,."1 ":&.>disks,.1+moves

{{out|Demonstration}}

move disk 1 from peg 1 to peg 3

move disk 2 from peg 1 to peg 2

move disk 1 from peg 2 to peg 1

move disk 2 from peg 2 to peg 3

 

=={{header|Java}}==

if (n == 1) {

System.out.println("Move disk from pole " + from + " to pole " + to);

move(n - 1, via, to, from);

}

 

=={{header|JavaScript}}==

}

 

=={{header|Joy}}==

Using it (5 is the number of disks.)

 

=={{header|K}}==

h[4;1;2;3]

1:1->3

1:1->3

2:1->2

The disk to move in the i'th step is the same as the position of the leftmost 1 in the binary representation of 1..2^n.

1 2 1 3 1 2 1 4 1 2 1 3 1 2 1

 

1_{*1+&|x}'a:(2_vs!_2^4)

 

 

=={{header|Lasso}}==

 

define towermove(

}

 

Called from command line:

<pre>Move disk from A to C

Move disk from A to B

Move disk from A to C</pre>

Called from command line:

<pre>Move disk from A to B

Move disk from A to C

=={{header|Liberty BASIC}}==

This looks much better with a GUI interface.

via$ ="B"

target$ ="C"

end sub

 

 

=={{header|Logo}}==

if :n = 0 [stop]

move :n-1 :from :via :to

move :n-1 :via :to :from

end

 

=={{header|Logtalk}}==

 

:- public(run/1).

nl.

 

 

=={{header|Lua}}==

if n > 0 then

move(n - 1, src, via, dst)

end

 

 

 

=={{header|MATLAB}}==

This is a direct translation from the Python example given in the Wikipedia entry for the Tower of Hanoi puzzle.

if (n~=0)

towerOfHanoi(n-1,A,B,C);

towerOfHanoi(n-1,B,C,A);

end

{{out|Sample output}}

Move plate 1 from tower 1 to tower 3

Move plate 2 from tower 1 to tower 2

Move plate 1 from tower 2 to tower 1

Move plate 2 from tower 2 to tower 3

 

=={{header|МК-61/52}}==

3 П3 2 П2 БП 20 3 П2 2 П3

1 П1 ПП 25 КППB ПП 28 КППA ПП 31

ИП2 ИП1 КППC ИП1 ИП2 ИП3 П1 -> П3 ->

П2 В/О 1 0 / + С/П КИП0 ИП0 x=0

 

Instruction: РA = 56; РB = 60; РC = 72; N В/О С/П, where 2 <= N <= 7.

 

=={{header|Modula-3}}==

 

FROM IO IMPORT Put;

BEGIN

doHanoi(4, 1, 2, 3);

 

=={{header|Monte}}==

if (n > 0):

move(n.previous(), fromPeg, viaPeg, toPeg)

move(n.previous(), viaPeg, toPeg, fromPeg)

 

 

=={{header|Nemerle}}==

using System.Console;

 

Hanoi(4)

}

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols binary

 

return

 

method runSample(arg) private static

parse arg discs .

return

 

method move(discs = int 4, towerFrom = int 1, towerTo = int 2, towerVia = int 3, moves = int 0) public static

if discs == 1 then do

end

return moves

{{out}}

<pre>

 

=={{header|NewLISP}}==

(if (> n 0)

(move (- n 1) from via to

(move (- n 1) via to from))))

 

 

if disks != 0:

hanoi(disks - 1, fromTower, viaTower, toTower)

hanoi(disks - 1, viaTower, toTower, fromTower)

{{out}}

<pre>Move disk 1 from 1 to 3

Move disk 2 from 1 to 2

Move disk 1 from 3 to 2</pre>