利用python打印杨辉三角

用python打印杨辉三角

介绍

杨辉三角,是初高中时候的一个数列,其核心思想就是说生成一个数列,该数列中的每一个元素,都是之前一个数列中,同样位置的元素和前一个元素的和。

正好在python中,也就是生成一个列表,该列表中的元素,都是之前列表的同样位置的元素和前一个元素的和。在这里,我想到的方法是通过迭代来进行计算,因为每一个数列的生成,都是需要前一个数列作为基础。

实现方式

首先,需要实现第N个杨辉三角的列表生成,通过分析整个杨辉三角,除了第一个和第二个数列意外,其他的都是可以通过迭代的方式进行生成的。具体的函数如下:

def Traingle(x):
    '''定义杨辉三角的函数,即下一行的第N个元素,是本行的第N个元素和第N-2个元素的和,最后返回一个列表'''
    x = int(x)
    Traingle_list = []
    if x == 1:
        Traingle_list = [1]
    elif x == 2:
        Traingle_list = [1,1]
    else:
        Traingle_list_temp = Traingle(x-1)#获取上一行三角列表
        Traingle_list = [1,1]
        temp = 1
        while temp <= x-2:
            Traingle_list.insert(temp,Traingle_list_temp[temp]+Traingle_list_temp[temp-1])
            temp += 1

    return Traingle_list

在上面的函数中,1和2比较好理解,因为比较简单,从第3个开始,都是要先获取前一个数列,然后利用循环的方式,在对应的位置上,进行插入,插入的元素,即为前一个数列中,同样位置和之前一个元素的和。同时需要注意的是,由于列表索引和初始列表的原因,第一个元素和最后一个元素是不用插入的,所以最后一个元素是x-1,最多插入到x-2的位置。

返回的结果是一个列表,可以直接进行调用打印。

为了是杨辉三角看上去比较有规律,在打印的时候需要做一下处理,比如居中显示。我能想到的办法是利用字符串的居中显示,先将列表转化成为字符串,然后对整个字符串进行居中显示。

在处理数据的过程中,由于数字越加越大,所以每个元素的长度也不一样,居中显示如果固定死了,对于后面的列表,就显得不好看。所以在处理的过程中,默认先取出最大的列表中的最大元素,然后计算该元素的长度,所有列表中的每一个元素,都按照该元素的长度进行居中补齐,这样就保证了所有列表的所有元素,长度都是固定相同的,看上去就能好看一些。

另外,由于整个列表的长度,由列表转化成为的字符串来限定的,字符串,由元素和空格组成,元素是固定长度的,空格是固定个数的,有N个元素,就有N-1个空格。所以定义一个打印的函数,对杨辉三角的输出进行打印,具体如下:

def PrintTringle(x):
    '''
    打印杨辉三角,其中利用到的是字符串居中显示,周围填充空格,但是由于不确定得到的结果的长度,所以需要得到整个列表中最大的那个元素,然后计算该元素的长度,利用该长度,为每一个杨辉三角的值进行填充剧中。
    :param x:
    :return:
    '''
    n = 1
    x = int(x)
    # 获取最大的元素,判断列表最大的元素的长度
    if x % 2 == 0:
        max_item = Traingle(x)[int(x/2)]
    else:
        max_item = Traingle(x)[int((x+1)/2)]
    max_length = len(str(max_item))
    while n <= x :
        list = Traingle(n)
        string = ''
        tem = 0
        # 对每一列杨辉三角进行处理,转化成为字符串,拼接
        while tem < len(list):
            if tem == 0:
                string = str(list[tem]).center(max_length)
            else:
                string = string + ' ' + str(list[tem]).center(max_length)
            tem += 1
        # 打印处理,每一列的元素有N个,空格用N+1
        print(string.center((max_length+1)*x-1))
        n += 1

在调用该函数的时候,只需要输入一个参数,正整数,就可以打印出整个杨辉三角到一定长度的完整序列,并且逻辑展示排列。比如打印20个。

PrintTringle(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  

以上显示,受页面排版的影响,显示不全,其实在终端中是可以正常显示的。

 

猜你喜欢

转载自www.cnblogs.com/bobo137950263/p/11074151.html