汉诺塔难点,卡拉奇之塔

写在后面:笔记全套是接着导师一齐敲的代码,近日Computer沃特t了,所以只好用老爷机的日记本记下老师上课讲的事物,但本人运维不了

规则

  1. 老是运动3个市场价格
  2. 汉诺塔难点,卡拉奇之塔。其余时候大盘子在上边,小盘子在上头
  • 递归函数

卡塔尔多哈之塔(Towers of
Hanoi)是瑞典人M.克劳斯(Lucas)于18八三年从泰王国带至高卢鸡的,蒙特利尔为越南战争时北越的新加坡市,即未来的汉堡;188三年法兰西地军事学家艾德ouard
Lucas曾谈起这些传说,故事创世

特别多谢的是xx大学的的刘先生,作者都以边看她的课,边学他协同敲代码,然后晚上友雅观,自身精通,多谢老师。

方法

假设共n个盘子

  • 当n=1时:
    1. 直白把A上的1个盘子移动到C上(A->C)
  • 当n=2时:
    1. 把小盘子从A放到B上(A->B)此处伊始选用参数,rsc源地址=A,dst目标地点=B
    2. 把大盘子从A放到C上( A->C)rsc=A, dst=C
    3. 把小盘子从B放到C上(B->C)rsc=B, dst=C
  • 当n=3时:
    1. 把A上的多个盘子,通过C移动到B上去,
      调用递归完结(A-C->B)rsc=A, trans中转=C, dst=B
    2. 把A上剩下的3个最大盘子移动到C上(A->C)rsc=A, dst=C
    3. 把B上七个盘子,借助于A,挪到C上去, 调用递归(B-A->C)rsc=B,
      trans=A, dst=C
  • 当n=n时:

    1. 把A上的n-3个盘子,借助于C,移动到B上去,调用递归(A-C->B)rsc=A,
      trans=C, dst=B

    2. 把A上的最大学一年级个盘子,移动到C上(A->C)rsc=A, dst=C

    3. 把B上n-三个盘子,借助于A,移动到C上,
      调用递归(B-A->C)rsc=B, trans=A, dst=C

每一回都是先将其它圆盘移到赞助柱子上,再将最上面包车型地铁移到C,然后再把原本柱子作为增加援救柱子,重复

Python对递归的吃水有限制,当先即会报错。所以断定一要注意跳出条件。

纪时Benares有一座Polo教塔,是由3支钻石棒(Pag)所协理,开首时神在首先根棒上放置陆十七个由上至下依由小至大排列的金盘(Disc),并指令僧侣将有所的金盘从第2根石棒移至第2根

 

代码实现

def move(n, a, b, c):
'''
汉诺塔的递归实现
n:代表几个盘子
a:代表第一个塔,rsc
b:代表第二个塔,trans
c:代表第三个塔, dst
'''
    if n == 1:
        print(a, '=>', c)
    else:
        move(n-1, a, c, b)
        print(a, '=>', c)
        move(n-1, b, a, c)
#斐波拉契数列
#一个数列,第一个数是1,第二个数也是1,从第三个数开始,每一个数是前两个数之和
#公式:f(1) =1, f(2) = 1, f(3) = f(1) + f(2), ..., f(n) = f(n-2) + f(n-1)
#例如:1, 2, 3, 5, 8, 13, 21...

def fib(n):
    if n == 1:
        return 1
    elif n == 2:
        return 1
    else:
        return fib(n-2) + fib(n-1)

print(fib(6))

石棒,且搬运进度中服从大盘子在小盘子之下的规则,若每天仅搬二个盘子,则当盘子全部搬运完成之时,此塔将损坏,而也正是世界末日来临之时。

汉诺塔难点
– 规则
壹、每趟运动3个市场价格
二、任曾几何时候大盘子在底下,小盘子在上头

检索钦定目录下的有着文件:

咱俩来把这一个传说形成二个算法:

  • 方法
    1、n=一:间接把A上的一个盘子移动到C上,A-》C
    2、n=2:
    壹、把小盘子从A放到B上,A->B
    二、把大盘子从A放到C上,A->C
    三、把小盘子从B放到C上,B->C
    3、n=3:
import os

def readfiles(filepath, n):
    files = os.listdir(filepath) #获取当前文件夹中的所有文件
    for fi in files: #遍历文件夹中的文件,这里获取的只是本层文件名
        fi_d = os.path.join(filepath,fi) #加入文件夹,获取到文件夹+文件,即将filepath和fi拼接,组成该文件/文件夹的绝对路径
        if os.path.isdir(fi_d): #如果该路径下的文件是文件夹
            print("*"*n)
            readfiles(fi_d,n+1)
        else:
            print("@"*n,fi)

readfiles("d:/my_dir/",0)

 把多个柱子标为ABC
假若唯有三个市场价格时,将它一直搬到c,当有五个盘子,就将B做为帮忙。假使盘数超越一个,将第多个以下的盘子遮起来,就很简短了,每一遍管理五个盘子,也正是

壹、把A上的七个盘子,通过C移动到B上,调用递归落成

 汉诺塔
    n = 1
        1. 一向把盘子从A挪到C,A->C
    n = 2
        壹. 把小盘子从A挪到B,A->B
        二. 把大盘子从A挪到C,A->C
        叁. 把小盘子从B挪到C,B->C
    n = 3
        一. 把A上的四个盘子,借助C挪到B,调用递归达成
        二. 把A上剩余的大盘子挪到C,A->C
        3. 把B上的四个盘子,借助A挪到C,调用递归达成
    n = n
        1. 把A上的n-3个盘子,借助C挪到B,调用递归落成
        二. 把A上剩余的大盘子,挪到C,A->C
        三. 把B上的n-一个盘子,借助A挪到C,调用递归达成

A->B  A->C
B->C那多少个步骤,而被遮住的有个别是2个递归管理。如若有n个盘子,则运动落成所需的次数为贰^n-一。

二、把A上剩下的八个最大盘子移动到C上,A->C

def hano(n, a, b, c):
    if n == 1:
        print(a,"--->",c)
    elif n == 2:
        print(a, "--->", b)
        print(a, "--->", c)
        print(b, "--->", c)
    else:
        hano(n-1, a, c, b)
        print(a, "--->", c)
        hano(n-1, b, a, c)

hano(5,"A","B","C") # 塔A上的5个盘子,挪到塔C

看一下图,代码小编会用c#和c++二种语言给出算法,然后作者会把算法详细解释给大家

叁、把B上四个盘子,借助于A,移动到C上去,调用递归
4、n=n:

  • 无名函数

    #无名氏函数,总计n的n次方
    f = lambda n:n**n
    print(f(二)) #输出结果为4print(f(三)) #输出结果为二7

亚洲必赢官网 1

1、把A上的n-3个大盘子,借助于C,移动到B上去,调用递归

语法:函数名= lambda 参数1,参数2,参数3:返回值

c++代码

二、把A上的最大盘子,也是唯一贰个,移动到C上去,A->C

注意:

?

叁、把B上n-三个盘子,借助于A,移动到C上去,调用递归

  一.函数的参数能够有三个,两个参数之间用逗号隔开分离

void hanoi(int n,char A,char B,char C)
{
    if(n==1)
    {
        cout<<"Move "<<n<<" from "<<A<<"  to "<< C <<endl;
    }
    else
    {
        hanoi(n-1,A,C,B); //把A柱子上第N-1个盘子通过C放到B柱子上
        cout<<"Move "<< n<<" from "<< A <<" to "<< C <<endl;
        hanoi(n-1,B,A,C); //把B上所有盘子通过A放到C上
    }
}
  
  
int main()
{
    cout<<"请输入盘子数量"<<endl;
    int n;
    cin>>n;
    hanoi(n,'A','B','C');
    return 0;
}
 1 def hano(n,a,b,c):
 2     '''
 3     汉诺塔的递归实现
 4     n:代表几个盘子
 5     a:代表第一个塔,开始的塔
 6     b:代表第二个塔,中间过度的塔
 7     c:代表第三个塔,目标塔
 8     '''
 9     if n==1:
10         print(a, "-->", b)
11     if n==2:
12         print(a, "-->", b)
13         print(a, "-->", c)
14         print(b, "-->", c)
15         return None
16     #把n-1个盘子,从a塔借助于c塔,挪到b塔上去
17     hano(n-1,a,c,b)
18     print(a,"-->",c)
19     #把n-1个盘子,从b塔,借助于a塔,挪到c塔上去
20     hano(n-1,b,a,c)
21 
22 a="A"
23 b="B"
24 c="C"
25 n=1
26 hano(n,a,b,c)
27 n=2
28 hano(n,a,b,c)
29 n=3
30 hano(n,a,b,c)
31 n=5
32 hano(n,a,b,c)

  二.无名氏函数不管多复杂,只可以写一行,且逻辑结束后一贯回到数据

c#代码

List(列表)

del:删除命令,如果使del之后,id的值和删除前不平等,则印证生成了二个新的list

a=[1,2,3,4,5,6]
prin(id(a))
del a(2)
print(id(a))

del二个变量后无法接二连三选拔此变量

del a
print(a) 
报错

 

列表运算

  • 运用加号链接五个列表

    a=[1,2,3,4,5]
    b=[5,6,7,8,9]
    d=[‘a’,’b’,’c’]
    c=a+b+d
    print(c)

-使用乘号操作列表
列表直接跟二个整数相乘
亚洲必赢官网,也正是把N个列表接在协同

a=[1,2,3,4,5]
b=a*3
print(b)

-成员资格运算
-正是剖断叁个成分是或不是在list里面

a=[1,2,3,4,5]
b=8
#c是一个布尔值
c= b in a 
print(c)
b=4
print(b in a )

#  not in
a=[1,2,3,4,5]
b=9
print(b not in a )

 

链表的遍历

- for
- while
# for in list
a=[1,2,3,4,5]
#挨个打印出来里面的元素
for i in a:
    print(i)

b=["i love zhangsiqi"]
for i in b:
    print(i)

range
in 前面包车型客车变量需求是可迭代的内容

for i in range(1,10):
    print(i)
print(tyoe(range(1,10)))

while循环访问list(但一般不要while遍历list)

a=[1,2,3,4,5,6]
length = len(a)
#index表示的是list的下标
index = 0
while index < length:
    print(a[index])
    index += 1

 

双层列表循环
-a为嵌套列表,也许叫做双层列表

a = [["one,1"],["two",2],["three",3]]
for k,v in a :
    print(k."---",v)

双层列表循环变异1
-a为嵌套列表,或许叫做双层列表

a = [["one",1,"eins"],["two",2],["three",3,4,5,6,7]]
for k,v in a :
    print(k."---",v)
报错

双层列表循环变异2
a为嵌套列表,可能叫做双层列表

a = [["one",1,"eins"],["two",2,"zwei"],["three",3,"drei"]]
#这个例子说明,k,v,w的个数应该跟解包出来的变量个数一致
for k,v ,win a :
    print(k."---",v,"--",w)

 

列表内涵:list content

  • 通过简单方法创立列表
  • for创建

    a = [“a”,”b”,”c”]
    #用list a创设3个list b
    #上面代码的意义是,对于全体a中的成分,每个放入新列表b中
    b = [i for i in a ]
    print(b)

-对a中保有因素乘以10,生成2个新的list

a = [1,2,3,4,5,6]
#用list a创建一个list b
#下面代码的含义是,对于所有a中的元素,逐个放入新列表b中
b = [i*10 for i in a ]
print(b)

-还足以过滤原来list中的内容并放入新列表中

-举个例子原有裂变a,须求把全数a中的偶数生成新的列表b

a = [x for x in range(1,35)] #生成一个从1到34的一个列表
#把a中所有偶数生成一个新列表b
b = [m for m in a if m%2 ==0]
print(b)

-列表生成式能够嵌套

三个列表a,b

a = [i for i in range(1,10)] #生成list a
print(a)
b = [i for i in range(100,400) if i%100 == 0]#求偶数
print(b)

#列表生成可以嵌套,此时等于两个for循环嵌套
c = [m+n for m in a for n in b]
print(c)

#上面代码跟下面代码等价
for m in a :
    for n in b:
        print(m+n,end=" ")
print()

#嵌套的列表生成式也可以用条件表达式
c = [m+n for m in a for n in b if m+n<250]
print(c)

至于列表的常用函数

#len:求列表的长度
a = [x for x in range(1,100)]
print(len(a))

#max:求列表中的最大值
#min:同理
print(max(a))

b = ["man","female","python"]
print(max(a))

#list:将其他格式的数据转换成list
a = [1,2,3]
print(list(a))

s = "i love zhangsiqi"
print(list(s))

#把range产生的内容转换成list
print(list(range(12,19)))

 

  叁.重返值和正规的函数一样,能够是不管3柒二10一数据类型

?

  • 过滤函数
static void Main(string[] args)
       {
           Console.WriteLine("输入盘子数量");
           int _n = Convert.ToInt32(Console.ReadLine());
           Hanoi(_n, 'A', 'B', 'C');
             
           Console.ReadLine();
       }
 
       static void Hanoi(int n, char A, char B, char C)
       {
           if (n == 1)
           {
               Console.WriteLine("Move {0} From {1} to {2}", n, A, C);
           }
           else
           {
               Hanoi(n - 1, A, C, B);
               Console.WriteLine("Move {0} From {1} to {2}", n, A, C);
               Hanoi(n - 1, B, A, C);
           }
       }

语法:filter(function,iterable)

  

function:用来筛选的函数,在filter中会自动的把iterable中的元素传递给function,然后依照function重回的True大概False来判定是不是保留此项数据

大家用多少为三个盘子的时候来看一下那么些Hanoi(int n, char A, char B, char
C)方法

iterable:可迭代对象

 

回去二个迭代器

一.Hanoi(n – 一, A, C,
B);这些递归是把n-一个盘子按从大到小的相继放到B柱子上,

lst1 = [1,2,3,4,5,6,7,8,9,0]
lst2 = filter(lambda x:x%2==0,lst1) #筛选出lst1中的偶数
print(lst2)
print(list(lst2))

lst3 = [{"id":1,"name":'zhangsan',"age":18},
        {"id":2,"name":'lisi',"age":19},
        {"id": 3, "name": 'wangwu', "age": 20},
        {"id": 4, "name": 'zhaoliu', "age": 21}]

lst4 = filter(lambda item:item['age']>19,lst3) #筛选出lst3中年龄大于19的人
print(list(lst4))

     约等于n为3-一=一个盘子的时候,即Hanoi(二,A,C,B);

  输出为:

       今年的B是原本的C,C为本来的B

<filter object at 0x000002060C6F2748>
[2, 4, 6, 8, 0]
[{'id': 3, 'name': 'wangwu', 'age': 20}, {'id': 4, 'name': 'zhaoliu', 'age': 21}]

       n>1还要访问Hanoi(n – 一, A, C,
B);也正是Hanoi(一,A,C,B);会把A柱子最上边的一盘子放到C柱子上去

 

      n为二 时施行完 Hanoi(n – 一, A, C, B);

                                Console.WriteLine(“Move {0} From {一}
to {②}”, n, A, C);那是把A柱子上的第3市价放到B(因为这年的C为B)柱子上去

        Hanoi(n – 一, B, A, C);这一定于Hanoi(壹,C,A,B) 把C柱子上的一盘子放到B上

2 Console.WriteLine(“Move {0} From {1} to {2}”, n, A, C);

  把A柱子上的尾声2个盘子叁放到C柱子上

到这年 A柱子已经空了

               B柱子上一丁点儿的行情壹在二盘子上边

       C柱子上有最大的市价3

三 Hanoi(n – 1, B, A,
C);上贰个递归大家早就把n-3个盘子放到了B柱子上,那一个方法就是把B柱子上的物价指数放到C柱子上

     也正是Hanoi(贰,B,A,C)它再递归

             先调用Hanoi(n – 1, A, C, B); 这一年 的A是B  B为C,C为A 
正是把B上的1盘子放到A柱子上

         Console.WriteLine(“Move {0} From {一} to {2}”, n, A, C); 把B柱子上的二盘子放到C柱子上

          Hanoi(n – 一, B, A, C);也便是Hanoi(一,A,B,C);会把A柱子上的C盘子入到C柱子上去

网站地图xml地图