您的位置:

python实现汉诺塔程序的简单介绍

本文目录一览:

python利用递归解决汉诺塔问题,求大神解释一下代码

这是一个典型的递归程序

当只有一层的时候,直接把x放到z上结束

当大于1层的时候,先把x和z放到y上,然后继续递归

把y放到x上,然后放到z上,结束处理

python解决汉诺塔问题?

解汉诺塔最简单的做法就是递归:

类似如何将大象装进冰箱:1)将冰箱门打开;2)把大大象放进去;3)把冰箱门关上……

我们将所有的盘都在同一个杆上从大到小排列视为【完美状态】,那么,目标就是将最大盘片为n的完美状态从a杆移到b杆,套用装大象的思路,这个问题同样是三步:

1)把n-1的完美状态移到另一个杆上;

2)把n移到目标杆上;

3)把n-1的完美状态移到目标杆上。

如下:

标题:用Python编码描述汉诺塔步骤

#-*- coding:utf-8 -*-

count = 0

def hano():

    

    def hanoi(n,x,y,z):

        global count

        count += 1

        if n == 1:

            print('Monving %d' % n, 'from ',x,'to',z)

        else:

            hanoi(n-1,x,z,y)

            print('Monving %d' % n,  'from ',x,'to',z)

            hanoi(n-1,y,x,z)

    return hanoi

n = int(input("请输入汉诺塔的层数 :"))

hano()(n,'source','helper','target')

print("The total number of steps required is: ",str(count))

-----------分-割-线-是-我----------------

复制分割线以上的代码,保存为hannoi.py,在python 3 下运行,得到结果如题所示。

【python】汉诺塔递归

系统自带的演示代码,可以研究一下

#!/usr/bin/env python3

"""       turtle-example-suite:

         tdemo_minimal_hanoi.py

A minimal 'Towers of Hanoi' animation:

A tower of 6 discs is transferred from the

left to the right peg.

An imho quite elegant and concise

implementation using a tower class, which

is derived from the built-in type list.

Discs are turtles with shape "square", but

stretched to rectangles by shapesize()

 ---------------------------------------

       To exit press STOP button

 ---------------------------------------

"""

from turtle import *

class Disc(Turtle):

    def __init__(self, n):

        Turtle.__init__(self, shape="square", visible=False)

        self.pu()

        self.shapesize(1.5, n*1.5, 2) # square--rectangle

        self.fillcolor(n/6., 0, 1-n/6.)

        self.st()

class Tower(list):

    "Hanoi tower, a subclass of built-in type list"

    def __init__(self, x):

        "create an empty tower. x is x-position of peg"

        self.x = x

    def push(self, d):

        d.setx(self.x)

        d.sety(-150+34*len(self))

        self.append(d)

    def pop(self):

        d = list.pop(self)

        d.sety(150)

        return d

def hanoi(n, from_, with_, to_):

    if n  0:

        hanoi(n-1, from_, to_, with_)

        to_.push(from_.pop())

        hanoi(n-1, with_, from_, to_)

def play():

    onkey(None,"space")

    clear()

    try:

        hanoi(6, t1, t2, t3)

        write("press STOP button to exit",

              align="center", font=("Courier", 16, "bold"))

    except Terminator:

        pass  # turtledemo user pressed STOP

def main():

    global t1, t2, t3

    ht(); penup(); goto(0, -225)   # writer turtle

    t1 = Tower(-250)

    t2 = Tower(0)

    t3 = Tower(250)

    # make tower of 6 discs

    for i in range(6,0,-1):

        t1.push(Disc(i))

    # prepare spartanic user interface ;-)

    write("press spacebar to start game",

          align="center", font=("Courier", 16, "bold"))

    onkey(play, "space")

    listen()

    return "EVENTLOOP"

if __name__=="__main__":

    msg = main()

    print(msg)

    mainloop()

Python 中关于汉诺塔的问题,这个程序,给定参数n的数值,怎么在程序里运行

有a,b,c 三个柱子,有n个从大到小的盘子,大盘子必须一直放在小盘子的下面,借助柱子b将n个盘子从a移到c

这个问题可以分解成下面的子题

先借助柱子c,将n-1个盘子从a移到b: hanoi(n-1,a,c,b)

将第n个盘子从a移到c :print(a,'--',c)

然后借柱子 a将已经移致b上的n-1个盘子移到c上:hanoi(n-1,b,a,c)

这样就移好了,将原问题分解成规模更小同样的子问题,递归解决,

求python大神帮忙解释一下 这个汉诺塔程序的步骤

def my_print(args):

print args

def move(n, a, b, c):

my_print ((a, '--', c)) if n==1 else (move(n-1,a,c,b) or move(1,a,b,c) or move(n-1,b,a,c))

注释:汉诺塔模型输入move (n, 'a', 'b', 'c')

例如n=3

move(2,a,c,b)自循环

move(1,a,b,c)

move(2,b,a,c) 自循环

循环完毕,输出

你这段代码也是类似自循环