Python打印杨辉三角

题目：python打印杨辉三角

杨辉三角性质有很多，我们的程序主要运用以下性质

• 第n行的m个数可表示为 C(n-1，m-1)，即为从n-1个不同元素中取m-1个元素的组合数。
• 第n行的数字有n项

大致形状（来自百科）

程序运行效果

n = 5

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

n = 10

                           1 
                        1     1      
                     1     2     1      
                  1     3     3     1      
               1     4     6     4     1      
            1     5     10    10    5     1      
         1     6     15    20    15    6     1      
      1     7     21    35    35    21    7     1      
   1     8     28    56    70    56    28    8     1      
1     9     36    84    126   126   84    36    9     1      

n = 20

                                                                                               1 
                                                                                          1         1          
                                                                                     1         2         1          
                                                                                1         3         3         1          
                                                                           1         4         6         4         1          
                                                                      1         5         10        10        5         1          
                                                                 1         6         15        20        15        6         1          
                                                            1         7         21        35        35        21        7         1          
                                                       1         8         28        56        70        56        28        8         1          
                                                  1         9         36        84        126       126       84        36        9         1          
                                             1         10        45        120       210       252       210       120       45        10        1          
                                        1         11        55        165       330       462       462       330       165       55        11        1          
                                   1         12        66        220       495       792       924       792       495       220       66        12        1          
                              1         13        78        286       715       1287      1716      1716      1287      715       286       78        13        1          
                         1         14        91        364       1001      2002      3003      3432      3003      2002      1001      364       91        14        1          
                    1         15        105       455       1365      3003      5005      6435      6435      5005      3003      1365      455       105       15        1          
               1         16        120       560       1820      4368      8008      11440     12870     11440     8008      4368      1820      560       120       16        1          
          1         17        136       680       2380      6188      12376     19448     24310     24310     19448     12376     6188      2380      680       136       17        1          
     1         18        153       816       3060      8568      18564     31824     43758     48620     43758     31824     18564     8568      3060      816       153       18        1          
1         19        171       969       3876      11628     27132     50388     75582     92378     92378     75582     50388     27132     11628     3876      969       171       19        1  

代码实现

1.阶乘函数

计算组合数时要用到阶乘

def factorial(n):
    if n == 1 or n == 0:
        return 1
    else:
        return (n*factorial(n-1))

2.组合数函数

根据组合数的公式，直接写出组合数函数

def Coefficient(n,k):
    num = factorial(n) / (factorial(k) * factorial(n-k))
    return int(num)

3.杨辉三角函数

写的过程并不复杂，但会发现问题，比较大的问题就是对齐的问题，而且会随着数字位数增多会重复出现问题，所以我们最好找到一个系数动态解决这个问题。
最后找到的解决方案是，预留空间，计算出n阶杨辉三角最大的数的位数记为space，那么给每个数两倍的space空间（数字长度+空格），可解决对齐的问题（因为这时相当于每个数所占空间相同）

def YangHui():
    n = int(input("输入杨辉三角阶数："))

    # 计算二项式系数最大数长度，以便对齐
    if (n - 1) % 2 == 0:
        space = len(str(Coefficient(n - 1, (n - 1) / 2)))
    else:
        space = len(str(Coefficient(n - 1, n / 2)))

    # 控制换行
    for i in range(1,n+1):
        print((n-i)*space*' ',end="")
        # 控制每一行内容
        if i == 1:
            print(1,end="")
        else:
            for j in range(0,i):
                num = Coefficient(i-1,j)
                length = len(str(num))
                print(str(num)+(space-length)*' ',end="") #空格是为了给num空间，num空间(数字长度+空格数)要与数字后空格数相同，否则对齐混乱
                print(space*' ',end="")  #每个数字后的空格数
        print(' ') # 用于换行

4.最终代码

#定义阶乘
def factorial(n):
    if n == 1 or n == 0:
        return 1
    else:
        return (n*factorial(n-1))
# 定义二项式系数
def Coefficient(n,k):
    num = factorial(n) / (factorial(k) * factorial(n-k))
    return int(num)

# 定义杨辉三角
def YangHui():
    n = int(input("输入杨辉三角阶数："))

    # 计算二项式系数最大数长度，以便对齐
    if (n - 1) % 2 == 0:
        space = len(str(Coefficient(n - 1, (n - 1) / 2)))
    else:
        space = len(str(Coefficient(n - 1, n / 2)))

    # 控制换行
    for i in range(1,n+1):
        print((n-i)*space*' ',end="")
        # 控制每一行内容
        if i == 1:
            print(1,end="")
        else:
            for j in range(0,i):
                num = Coefficient(i-1,j)
                length = len(str(num))
                print(str(num)+(space-length)*' ',end="") #空格是为了给num空间，num空间(数字长度+空格数)要与数字后空格数相同，否则对齐混乱
                print(space*' ',end="")  #每个数字后的空格数
        print(' ') # 用于换行
YangHui()

2020/6/25在leetcode看到一种数据更小的算二项式系数的办法，不过是java代码，这样可以用一个循环就代替原先的阶乘。

private int Combination(int N, int k) {
    long res = 1;
    for (int i = 1; i <= k; i++)
        //通过分数的形式可以巧妙地避免数据溢出，先约掉分母和分子的一部分
        res = res * (N - k + i) / i;
    return (int) res;
}