python打印杨辉三角，第m行第k个数，多种方法

1. 第m行第k个数

第m行有m项，m是正整数，因此k一定不会大于m，这个需求需要保存m行的数据，那么可以使用一个嵌套结构[[],[],[]]

m=int(input('行>>>'))
k=int(input('第几个数>>>'))
triangle=[]
for i in range(m):
    row=[1]                #所有行都以1开头
    triangle.append(row)
    if i==0:
        continue
    for j in range(1,i):
        row.append(triangle[i-1][j-1]+triangle[i-1][j])
    row.append(1)
print("--------------------------------")
print(triangle)
print("--------------------------------")
print("第%d行第%d个数为：%d"%(m,k,triangle[m-1][k-1]))

2. m行k列的值，C(m-1，k-1)组合数

组合数方式：根据杨辉三角的定理，第n行的m个数(m>0且n>0)可表示为C(n-1，m-1)，即为从n-1个不同元素中取m-1个元素的组合数
组合数公式：有m个不同的元素，任意取n(n≤m)个元素，记作C(m，n)，则C(m，n)=m!/(n!(m-n)!) =C(m,m-n)

m = int(input('行>>>'))
k = int(input('列>>>')) #  则C(n,r)=C(m-1,k-1)=(m-1)!/((k-1)!(m-r)!)= n!/(r!(n-r)!)
n = m - 1
r = k - 1
d = n - r
targets = []    #r, n-r, n
factorial = 1   #可以加入k为1或m的判断，返回1
for i in range(1,n+1):
    factorial *= i
    if i == r:
        targets.append(factorial)
if i == d:
        targets.append(factorial)
if i == n:
        targets.append(factorial)
print(targets[2]//(targets[0]*targets[1]))

3. 基本方法：下一行是上一行所有元素两两相加得到，两端再添加上1

n = int(input('>>'))
tiangle=[[1],[1,1]]              #预先定义前两行
for i in range(2,n):
    per=tiangle[i -1]
    cur = [1]                             #创建新行，首位为1
    for j in range(i-1):                  #循环添加中间值
        cur.append(per[j]+per[j+1])
    cur.append(1)                         #末位添加1
    tiangle.append(cur)
print(tiangle)                            #将新生成的行添加到总列表

4. 对称法 ：一次性开辟出空间，先算出前一半的值，然后对称赋值

一次性开辟出第n行所需空间然后算值替换，比循环迭代append添加更高效。每次只推算一半，时间复杂度更低

n = int(input('>>'))
triangle = [[1],[1,1]]
for i in range(2,n):
    row = [1]*(i + 1)                 #打印第n行先创建出n个元素列表
    pre = triangle[i - 1]
    for j in range(i//2):           #推算该行前一半的值
        val = pre[j] + pre[j + 1]
        row[j + 1] = val
        row[ - j - 2] = val               #对称赋值
    triangle.append(row)
print(triangle)

举例：计算前6行

n = 6
row = [1] * n  #一次性开辟足够的空间
for i in range(n):
    offset = n – i
    z = 1   #因为会有覆盖影响计算，所以引入一个临时变量
    for j in range(1,i//2+1):  #对称性
        val = z + row[j]
        row[j],z = val,row[j]
        if i != 2*j:
            row[-j-offset] = val
print(row[:i+1])   #从row的第一个元素打印到第i个

5. 单行覆盖：在上面对称法的基础上降低空间复杂度

一次性开辟好n个长度的空间，每次推算新行时不生成新的列表，在原来的基础上赋值替换。

n = int(input('>>'))
row = [1]*n                 #一次性开辟空间
for i in range(n):
    z = 1
    for j in range(i//2):
        val = z +row[j+1]    #计算出来的新值会影响后面的计算，使用临时变量置换一下
        z = row[j+1]
        row[j+1]=val
        row[i-j-1]=val     #对称赋值    row[j+1]=row[i-j-1]
    print(i,end='\t')
    print(row[:i+1])     #最后在总列表中截取当前计算的行长度打印出来