概述：

    中国古代数学家在数学的许多重要领域中处于遥遥领先的地位。中国古代数学史曾经有自己光辉灿烂的篇章， 而杨辉三角的发现就是十分精彩的一页。 杨辉三角形，是二项式系数在三角形中的一种几何排列。杨辉三角图：

杨辉三角性质：

1、每行数字左右对称，由1开始逐渐变大，然后变小，回到1。 　　 2、第n行的数字个数为n个。 　　 3、第n行数字和为2^(n－1)。（2的（n-1）次方） 　　 4、每个数字等于上一行的左右两个数字之和。 5、将第2n+1行第1个数，跟第2n+2行第3个数、第2n+3行第5个数……连成一线，这些数的和是第2n个斐波那契数。将第2n行第2个数，跟第2n+1行第4个数、第2n+2行第6个数……这些数之和是第2n-1个斐波那契数。 　　 6、第n行的第1个数为1，第二个数为1×(n-1)，第三个数为1×(n-1)×（n-2）/2，第四个数为1×(n-1)×（n-2）/2×（n-3）/3…依此类推。 　　 7.两个未知数和的n次方运算后的各项系数依次为杨辉三角的第(n+1)行。

下面老男孩来带大家使用某些开发人员认为最土的shell脚本来实现：

本文内容来自《老男孩linux运维实战培训中心》shell编程部分内部学生练习资料， 在这里和大家一起分享，希望大家一起探讨，找到更多更好的方法。

实现脚本一(重点)：

1. #!/bin/bash  
2. export LANG="zh_CN.GB18030" 
3. #本文内容来自《老男孩linux运维实战培训中心》shell编程部分内部学生练习资料  
4. #欢迎广到运维兄弟一起交流linux/unix网站运维技术!  
5. #网站运维交流群：114580181 45039636 37081784    
6. #老男孩 QQ:31333741    
7. #mail:31333741@qq.com  
8. #blog:http://oldboy.blog.51cto.com  
9.  
10. #judge input  
11. if (test -z $1) ;then 
12.   read -p "Input Max Int Lines:" MAX 
13. else 
14.         MAX=$1  
15. fi  
16.  
17. #judge int   
18. [ -n "`echo $MAX|sed 's/[0-9]//g'`" ] && \  
19. echo "Oldboy say,the num your input must be int,thank you,bye!" && exit 1  
20.  
21. #require <10  
22. [ ! $MAX -lt 10 ] && \  
23. echo "Oldboy say,the num your input must be int(1-9),thank you,bye!" && exit 1  
24.  
25. #start  
26. a[0]=1                  
27. for((i=0;i<=MAX;i++))     
28. do  
29.         for ((j=$i;j>0;j--))     
30.         do  
31.                 ((a[$j]+=a[$j-1]))  
32.         done  
33.                 for ((j=0;j<=$[MAX-$i];j++))  
34.                 do  
35.                     if [ $MAX -le 6 ]  
36.                       then 
37.                          echo -en "\t" 
38.                     else 
39.                          echo -n "   " 
40.                     fi  
41.                 done  
42.         for ((j=0;j<=$i;j++))  
43.         do  
44.                     if [ $MAX -le 6 ]  
45.                       then 
46.                          echo -en "\t\t"${a[$j]}  
47.                     else 
48.                          echo -n ${a[$j]}"      " 
49.                     fi  
50.         done  
51. echo  
52. done 

执行结果： [oldboy@A ~]$ bash oldboy_training.sh 4                                                         1                                                 1               1                                         1               2               1                                 1               3               3               1                         1               4               6               4               1 [oldboy@A ~]$ bash oldboy_training.sh 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         1      10      45      120      210      252      210      120      45      10      1     

结论说明：

    这个脚本难度一般，但是包含大量的shell基本语法，及相关解决问题技巧。值得每一个运维工程师，学习研究。  在写脚本时，老男孩也特意使用了多个shell语法结合的手法，希望同学们能掌握之。     网上的高手朋友，如果有更好的方法欢迎一起交流探讨！    实现脚本二：

1. #!/bin/bash  
2. if (test -z $1) ;then 
3.  read -p "Input Max Lines:" MAX 
4. else 
5.         MAX=$1  
6. fi  
7.  
8. i=1  
9. while [ $i -le $MAX ]   #i行控制  
10. do  
11.      j=1  
12.      while [ $j -le $i ]        #j列控制  
13.      do  
14.         f=$[i-1]        #f=i-1 这是另一种计算写法。  
15.         g=$[j-1]        #g=j-1 这是另一种计算写法。  
16.         if [ $j -eq $i ] || [ $j -eq 1 ] ; then 
17.                 declare SUM_${i}_$j=1           #声明变量 头尾都是1  
18.         else 
19.                 declare A=$[SUM_${f}_$j]       #取上一行的j列变量  
20.                 declare B=$[SUM_${f}_$g]       #取上一行的j-1列变量  
21.                 declare SUM_${i}_$j=`expr $A + $B`    #声明并计算当前变量的值  
22.         fi  
23.         echo -en $[SUM_${i}_$j]" "  #输出当前变量  
24.         let j++  
25.      done  
26.      echo       #换行  
27.      let i++  
28. done 

实现脚本三：

1. #!/bin/bash  
2. #History  
3. #2006.05.22    oldboy    QQ:31333741  
4. #i表示当前行  
5. #j表示当前位置  
6. #f/g表示上一行、上一位置  
7.  
8. if (test -z $1) ;then 
9.  read -p "Input Max Int Lines:" MAX 
10. else 
11.         MAX=$1  
12. fi  
13. for ((i=1;i<=MAX;i++))  
14. do  
15.     for ((j=1;j<=i;j++))  
16.     do  
17.       f=$(($i-1))  
18.       g=$(($j-1))  
19.           if [ "$j" == 1 ];then 
20.            declare SUM_${i}_$j=1  
21.           else 
22.            declare  A=$[SUM_${f}_$j]  
23.            declare  B=$[SUM_${f}_$g]  
24.            declare  SUM_${i}_$j=`expr $A + $B`  
25.           fi  
26.       echo -n $[SUM_${i}_$j]  
27.       echo -en "  " 
28.     done  
29. echo  "  " 
30. done  
31. 执行结果：  
32. [root@oldboy scripts]# bash oldboy.sh   
33. Input Max Lines:10  
34. 1      
35. 1  1      
36. 1  2  1      
37. 1  3  3  1      
38. 1  4  6  4  1      
39. 1  5  10  10  5  1      
40. 1  6  15  20  15  6  1      
41. 1  7  21  35  35  21  7  1      
42. 1  8  28  56  70  56  28  8  1      
43. 1  9  36  84  126  126  84  36  9  1  

 实现脚本4

1. #!/bin/bash   
2. #   
3. # Yang_Hui_Triangle   
4.    
5. Yang_Hui_Triangle()   
6. {   
7.     vector[0]=1   
8.     echo ${vector[0]}   
9.     for((row=1; row<=${1}; ++row))   
10.     do   
11.         vector[row]=1   
12.         for((col=row-1; col>0; --col))   
13.         do   
14.             ((vector[col]+=vector[col-1]))   
15.         done   
16.         for((col=0; col<=row; ++col))   
17.         do   
18.             echo -n "${vector[col]} "   
19.         done   
20.         echo   
21.     done   
22. }       
23.    
24. Yang_Hui_Triangle ${1} 

脚本4为永夜兄弟提供！

执行结果： [oldboy@A ~]$ bash yang.sh  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 1 10 45 120 210 252 210 120 45 10 1 （over）