版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/yuzongtao/article/details/83539456
目录
1、选秀节目打分
分为专家评委和大众评委，score[] 数组里面存储每个评委打的分数，judge_type[] 里存储与 score[] 数组对应的评委类别，judge_type[i] == 1，表示专家评委，judge_type[i] == 2，表示大众评委，n表示评委总数。打分规则如下：专家评委和大众评委的分数先分别取一个平均分（平均分取整），然后，总分 = 专家评委平均分 * 0.6 + 大众评委 * 0.4，总分取整。如果没有大众评委，则 总分 = 专家评委平均分，总分取整。函数最终返回选手得分。
函数接口 int cal_score(int score[], int judge_type[], int n)
package com.huawei;
import java.util.Arrays;
/*
* @author yuzongtao
*/
public class XuanXiu {
/**
* 1、选秀节目打分，分为专家评委和大众评委，score[] 数组里面存储每个评委打的分数，
* judge_type[] 里存储与 score[] 数组对应的评委类别，
* judge_type[i] == 1，表示专家评委，judge_type[i] == 2，表示大众评委，n表示评委总数。
* 打分规则如下：专家评委和大众评委的分数先分别取一个平均分（平均分取整），
* 然后，总分 = 专家评委平均分 * 0.6 + 大众评委 * 0.4，总分取整。
* 如果没有大众评委，则 总分 = 专家评委平均分，总分取整。函数最终返回选手得分。
* 函数接口 int cal_score(int score[], int judge_type[], int n)
*/
public static void main(String[] args) {
int n = 10; // n表示评委总数
int[] score = new int[n];
int[] judge_type = new int[n];
for(int i=0;i<10;i++){
score[i] = (int) (100*Math.random()); // score[] 数组里面存储每个评委打的分数
judge_type[i] = i%2 == 0 ? 1 : 2; // judge_type[] 里存储与 score[] 数组对应的评委类别:1，表示专家评委，2，表示大众评委
}
int totalScore = cal_score(score,judge_type,n);
System.out.println("score="+Arrays.toString(score));
System.out.println("judgeTypes="+Arrays.toString(judge_type));
System.out.println("totalScore="+totalScore);
}
public static int cal_score(int score[], int judge_type[], int n){
int totalScore = 0; // 选手总分
if(null != judge_type && judge_type.length>0){
int zNum = 0; // 专家人数
int dNum = 0; // 大众人数
int zTotalScore = 0; // 专家总分
int dTotalScore = 0; // 专家总分
for(int i=0;i<judge_type.length;i++){
if(judge_type[i] == 2){
zTotalScore += score[i];
zNum++;
}else{
dTotalScore += score[i];
dNum++;
}
}
if(dTotalScore > 0){ // 总分 = 专家评委平均分 * 0.6 + 大众评委 * 0.4，总分取整。
totalScore = (int) (Math.round(zTotalScore/zNum)*0.6 + Math.round(dTotalScore/dNum)*0.4);
}else{ // 总分 = 专家评委平均分，总分取整
totalScore = (int) Math.round(zTotalScore/zNum);
}
}
return totalScore;
}
}
输出：
score=[93, 39, 21, 42, 83, 13, 96, 34, 34, 82]
judgeTypes=[1, 2, 1, 2, 1, 2, 1, 2, 1, 2]
totalScore=512、奇偶排序
给定一个数组input[] ，如果数组长度n为奇数，则将数组中最大的元素放到 output[] 数组最中间的位置，如果数组长度n为偶数，则将数组中最大的元素放到 output[] 数组中间两个位置偏右的那个位置上，然后再按从大到小的顺序，依次在第一个位置的两边，按照一左一右的顺序，依次存放剩下的数。
例如：input[] = {3, 6, 1, 9, 7} output[] = {3, 7, 9, 6, 1}; input[] = {3, 6, 1, 9, 7, 8} output[] = {1, 6, 8, 9, 7, 3}
函数接口 void sort(int input[], int n, int output[])
package com.huawei;
import java.util.Arrays;
/*
* @author yuzongtao
*/
public class SortTest {
/**
* 给定一个数组input[] ，如果数组长度n为奇数，则将数组中最大的元素放到 output[] 数组最中间的位置，
* 如果数组长度n为偶数，则将数组中最大的元素放到 output[] 数组中间两个位置偏右的那个位置上，
* 然后再按从大到小的顺序，依次在第一个位置的两边，按照一左一右的顺序，依次存放剩下的数。
*
* 例如：input[] = {3, 6, 1, 9, 7} output[] = {3, 7, 9, 6, 1};
* input[] = {3, 6, 1, 9, 7, 8} output[] = {1, 6, 8, 9, 7, 3}
*
* 函数接口 void sort(int input[], int n, int output[])
*/
public static void main(String[] args) {
int[] input = {3, 6, 1, 9, 7};
int[] output = new int[input.length];
sort(input,input.length,output);
System.out.println(" ----------------------");
int[] input2 = {3, 6, 1, 9, 7, 8};
int[] output2 = new int[input2.length];
sort(input2,input2.length,output2);
}
public static void sort(int input[], int n, int output[]){
boolean flag = false; // 奇数（false） 偶数（true）
flag = n%2 == 1 ? false : true ;
Arrays.sort(input); // input数据 正向排序
System.out.println("input="+Arrays.toString(input));
if(!flag){ // 如果数组长度n为奇数，则将数组中最大的元素放到 output[] 数组最中间的位置
for(int i=0;i<input.length;i++){
if(i%2 == 0){ // 中间第奇数个数字排在右边
output[(n+i)/2] = input[input.length-1-i];
}else{ // 中间第偶数个数字排在左边
output[(n-i)/2-1] = input[input.length-1-i];
}
}
System.out.println("output="+Arrays.toString(output));
}else{ // 如果数组长度n为偶数，则将数组中最大的元素放到 output[] 数组中间两个位置偏右的那个位置上
for(int i=0;i<input.length;i++){
if(i%2 == 0){ // 数组中间两个位置偏右的那个位置上
output[(n+i)/2] = input[input.length-1-i];
}else{ // 数组中间两个位置偏左的那个位置上
output[(n-i-1)/2] = input[input.length-1-i];
}
}
System.out.println("output="+Arrays.toString(output));
}
}
}
输出：
input=[1, 3, 6, 7, 9]
output=[3, 7, 9, 6, 1]
----------------------
input=[1, 3, 6, 7, 8, 9]
output=[1, 6, 8, 9, 7, 3]3、操作系统任务调度问题。
操作系统任务分为系统任务和用户任务两种。其中，系统任务的优先级 < 50，用户任务的优先级 >= 50且 <= 255。优先级大于255的为非法任务，应予以剔除。现有一任务队列task[]，长度为n，task中的元素值表示任务的优先级，数值越小，优先级越高。函数scheduler实现如下功能，将task[] 中的任务按照系统任务、用户任务依次存放到 system_task[] 数组和 user_task[] 数组中（数组中元素的值是任务在task[] 数组中的下标），并且优先级高的任务排在前面，优先级相同的任务按照入队顺序排列（即先入队的任务排在前面），数组元素为-1表示结束。
例如：task[] = {0, 30, 155, 1, 80, 300, 170, 40, 99} system_task[] = {0, 3, 1, 7, -1} user_task[] = {4, 8, 2, 6, -1}
函数接口 void scheduler(int task[], int n, int system_task[], int user_task[])
package com.huawei;
import java.util.Arrays;
/*
* @author yuzongtao
*/
public class schedulerTest {
/**
* 操作系统任务调度问题。操作系统任务分为系统任务和用户任务两种。
* 其中，系统任务的优先级 < 50，用户任务的优先级 >= 50且 <= 255。优先级大于255的为非法任务，应予以剔除。
* 现有一任务队列task[]，长度为n，task中的元素值表示任务的优先级，数值越小，优先级越高。
* 函数scheduler实现如下功能，将task[] 中的任务按照系统任务、用户任务依次存放到 system_task[] 数组
* 和 user_task[] 数组中（数组中元素的值是任务在task[] 数组中的下标），并且优先级高的任务排在前面，
* 优先级相同的任务按照入队顺序排列（即先入队的任务排在前面），数组元素为-1表示结束。
* 例如：task[] = {0, 30, 155, 1, 80, 300, 170, 40, 99}
* system_task[] = {0, 3, 1, 7, -1} user_task[] = {4, 8, 2, 6, -1}
* 函数接口 void scheduler(int task[], int n, int system_task[], int user_task[])
*/
public static void main(String[] args) {
int[] task = {0, 30, 155, 1, 80, 300, 170, 40, 99};
int[] system_task = null;
int[] user_task = null;
scheduler(task, task.length, system_task, user_task);
}
public static void scheduler(int task[], int n, int system_task[], int user_task[]){
int sys_length = 0; // 系统任务数组长度
int user_length = 0; // 用户任务数组长度
for(int i=0;i<task.length;i++){
if(task[i]<50){
sys_length++;
}
if(task[i]>=50 && task[i]<=255){
user_length++;
}
}
int[] sys_value = new int[sys_length]; // 系统任务值的数组
int[] user_value = new int[user_length]; // 用户任务值的数组
system_task = new int[sys_length+1]; // 系统任务下标的数组
user_task = new int[user_length+1]; // 用户任务下标的数组
int sys_index = 0; // 系统任务下标
int user_index = 0; // 用户任务下标
for(int i=0;i<task.length;i++){
if(task[i]<50){ // 获取系统任务 值和下标的数组
system_task[sys_index] = i; // 下标
sys_value[sys_index] = task[i]; // 值
sys_index++;
}
if(task[i]>=50 && task[i]<=255){ // 获取用户任务 值和下标的数组
user_task[user_index] = i; // 下标
user_value[user_index] = task[i]; // 值
user_index++;
}
}
for(int i=0;i<sys_value.length;i++){
for(int j=i;j<sys_value.length;j++){
if(sys_value[i]>sys_value[j]){
// 系统任务数组值排序
int sys_num = sys_value[i];
sys_value[i] = sys_value[j];
sys_value[j] = sys_num;
// 系统任务数组下标排序
int temp = system_task[i];
system_task[i] = system_task[j];
system_task[j] = temp;
}
}
}
for(int i=0;i<user_value.length;i++){
for(int j=i;j<user_value.length;j++){
if(user_value[i]>user_value[j]){
// 用户任务数组值排序
int user_num = user_value[i];
user_value[i] = user_value[j];
user_value[j] = user_num;
// 用户任务数组下标排序
int temp = user_task[i];
user_task[i] = user_task[j];
user_task[j] = temp;
}
}
}
system_task[system_task.length-1] = -1;
user_task[user_task.length-1] = -1;
System.out.println("task="+Arrays.toString(task));
System.out.println("system_task="+Arrays.toString(system_task));
System.out.println("user_task="+Arrays.toString(user_task));
}
}
输出：
task=[0, 30, 155, 1, 80, 300, 170, 40, 99]
system_task=[0, 3, 1, 7, -1]
user_task=[4, 8, 2, 6, -1]4. 打印数组中最大的2个数
手动输入一个存储整数的数组，要求输出数组里面的2个最大值。实例： 输入：1,2,5,9,84,3,2 输出：84,9
package com.huawei;
import java.util.Arrays;
/*
* @author yuzongtao
*/
public class FindMaxTwoNum {
/**
* 手动输入一个存储整数的数组，要求输出数组里面的2个最大值。
* 实例： 输入：1,2,5,9,84,3,2输出：84,9
*/
public static void main(String[] args) {
int[] array = {1,22,3,56,34,5,0,567};
Arrays.sort(array);
System.out.println("最大的两个数："+array[array.length-1]+","+array[array.length-2]);
}
}
输出：
最大的两个数：567,56
5.回文数字判断。
有这样一类数字，他们顺着看和倒着看是相同的数，例如：121,656,2332等，这样的数字就称为：回文数字。编写一个函数，判断某数字是否是回文数字。
package com.huawei;
/*
* @author yuzongtao
*/
public class HuiWenShuTest {
/**
* 回文数字判断
* 有这样一类数字，他们顺着看和倒着看是相同的数，
* 例如：121,656,2332等，这样的数字就称为：回文数字。
* 编写一个函数，判断某数字是否是回文数字。
*/
public static void main(String[] args) {
int num = 123321;
boolean flag = isPalindrome(String.valueOf(num));
System.out.println("num = 123321 是否为回文数："+flag);
}
public static boolean isPalindrome(String strIn){
boolean flag = false;
String str = "";
char[] strIns = strIn.toCharArray();
for(int i=strIns.length;i>0;i--){
str += strIns[i-1];
}
if(strIn.equals(str)){
flag = true;
}
return flag;
}
}
输出：
num = 123321 是否为回文数：true6.中级题：亮着电灯的盏数
一条长廊里依次装有n(1 ≤ n ≤ 65535)盏电灯，从头到尾编号1、2、3、…n-1、n。每盏电灯由一个拉线开关控制。开始，电灯全部关着。有n个学生从长廊穿过。第一个学生把号码凡是1的倍数的电灯的开关拉一下；接着第二个学生把号码凡是2的倍数的电灯的开关拉一下；接着第三个学生把号码凡是3的倍数的电灯的开关拉一下；如此继续下去，最后第n个学生把号码凡是n的倍数的电灯的开关拉一下。n个学生按此规定走完后，长廊里电灯有几盏亮着。注：电灯数和学生数一致。
package com.huawei;
/*
* @author yuzongtao
*/
public class LightTest {
/**
* 亮着电灯的盏数
* 一条长廊里依次装有n(1 ≤ n ≤ 65535)盏电灯，从头到尾编号1、2、3、…n-1、n。每盏电灯由一个拉线开关控制。
* 开始，电灯全部关着。有n个学生从长廊穿过。第一个学生把号码凡是1的倍数的电灯的开关拉一下；
* 接着第二个学生把号码凡是2的倍数的电灯的开关拉一下；接着第三个学生把号码凡是3的倍数的电灯的开关拉一下；
* 如此继续下去，最后第n个学生把号码凡是n的倍数的电灯的开关拉一下。n个学生按此规定走完后，长廊里电灯有几盏亮着。
* 注：电灯数和学生数一致。
*/
public static void main(String[] args) {
int n = 100;
int[] lights = new int[n];
int[] students = new int[n];
for(int i=0;i<students.length;i++){
for(int j=0;j<lights.length;j++){
if((j+1)%(i+1) == 0){
if(lights[j] == 0){
lights[j] = 1; // 1 代表灯亮
}else{
lights[j] = 0; // 1 代表灯灭
}
}
}
}
int num = 0;
for(int i=0;i<lights.length;i++){
if(lights[i] == 1){
num++;
}
}
System.out.println("长廊里电灯亮着的灯数目为："+num);
}
}
输出：
长廊里电灯亮着的灯数目为：107.高级题：地铁换乘
已知2条地铁线路，其中A为环线，B为东西向线路，线路都是双向的。经过的站点名分别如下，两条线交叉的换乘点用T1、T2表示。编写程序，任意输入两个站点名称，输出乘坐地铁最少需要经过的车站数量（含输入的起点和终点，换乘站点只计算一次）。
地铁线A（环线）经过车站：
A1 A2 A3 A4 A5 A6 A7 A8 A9 T1 A10 A11 A12 A13 T2 A14 A15 A16 A17 A18
地铁线B(直线)经过车站：
B1 B2 B3 B4 B5 T1 B6 B7 B8 B9 B10 T2 B11 B12 B13 B14 B15
package com.huawei;
import java.util.Scanner;
/*
* @author yuzongtao
*/
public class StationTest {
/**
* 高级题：地铁换乘
* 已知2条地铁线路，其中A为环线，B为东西向线路，线路都是双向的。经过的站点名分别如下，两条线交叉的换乘点用T1、T2表示。
* 编写程序，任意输入两个站点名称，输出乘坐地铁最少需要经过的车站数量（含输入的起点和终点，换乘站点只计算一次）。
* 地铁线A（环线）经过车站：A1 A2 A3 A4 A5 A6 A7 A8 A9 T1 A10 A11 A12 A13 T2 A14 A15 A16 A17 A18
* 地铁线B(直线)经过车站：B1 B2 B3 B4 B5 T1 B6 B7 B8 B9 B10 T2 B11 B12 B13 B14 B15
*/
public static void main(String[] args) {
// 1.输入2个站点名称
System.out.println("请输入地铁站名称：");
Scanner sc = new Scanner(System.in);
String[] stationNames = sc.nextLine().split(",");
String[] stationALine = {"A1","A2","A3","A4","A5","A6","A7","A8","A9","T1","A10",
"A11","A12","A13","T2","A14","A15","A16","A17","A18"};
String[] stationBLine = {"B1","B2","B3","B4","B5","T1","B6","B7","B8","B9","B10","T2","B11","B12","B13","B14","B15"};
int num = 0; // 距离地铁站数目
// 2.计算2个站点分别在哪条地铁线上
String startStation = stationNames[0];
String endStation = stationNames[1];
boolean sA = isInLine(stationALine,startStation);
boolean sB = isInLine(stationBLine,startStation);
boolean eA = isInLine(stationALine,endStation);
boolean eB = isInLine(stationBLine,endStation);
// 3.计算最少经过的车站数量
// 3.1 如果在一条地铁站上,只需要计算一条线上的距离，不用考虑换乘，因为只允许换乘一次
// 3.2 如果分别在2条地铁线路上
if(sA && eA){ // 如果都在A地铁上
num = getIndex(stationALine,endStation) - getIndex(stationALine,startStation);
}else if(sB && eB){ // 如果都在B地铁上
num = getIndex(stationBLine,endStation) - getIndex(stationBLine,startStation);
}else{
int sAT1 = Math.abs(getIndex(stationALine,"T1") - getIndex(stationALine,startStation)+1); // 起点到T1站距离
int sAT2 = Math.abs(getIndex(stationALine,"T2") - getIndex(stationALine,startStation)+1); // 起点到T2站距离
int sBT1 = Math.abs(getIndex(stationBLine,"T1") - getIndex(stationBLine,endStation)+1); // 终点点到T1站距离
int sBT2 = Math.abs(getIndex(stationBLine,"T2") - getIndex(stationBLine,endStation)+1); // 终点点到T2站距离
num = sAT1 + sBT1 > sAT2 +sBT2 ? sAT2 +sBT2 : sAT1 + sBT1; // 取最短距离
}
System.out.println("最少需要经过的车站数量:"+Math.abs(num+1));
}
// 计算2个站点分别在哪条地铁线上
public static boolean isInLine(String[] stationLine,String stationName){
boolean flag = false;
for(int i=0;i<stationLine.length;i++){
if(stationLine[i].equals(stationName)){
flag = true;
break;
}
}
return flag;
}
// 获取地铁站所在数组下标
public static int getIndex(String[] stationLine,String stationName){
int index = 0;
for(int i=0;i<stationLine.length;i++){
if(stationLine[i].equals(stationName)){
index = i;
break;
}
}
return index;
}
}
输出：
请输入地铁站名称：
A3,B9
最少需要经过的车站数量:12
8.判断if语句括号是否合法
编程的时候，if条件里面的“(”、“)”括号经常出现不匹配的情况导致编译不过，请编写程序检测输入一行if语句中的圆括号是否匹配正确。同时输出语句中出现的左括号和右括号数量，如if((a==1)&&(b==1))是正确的，而if((a==1))&&(b==1))是错误的。注意if语句的最外面至少有一对括号。提示：用堆栈来做。
输入：if((a==1)&&(b==1))
输出：RIGTH 3 3
输入：if((a==1))&&(b==1))
package com.huawei;
import java.util.Scanner;
import java.util.Stack;
/*
* @author yuzongtao
*/
public class kuoHaoMatchTest {
/**
* 括号配对问题
* 判断if语句括号是否合法
* 编程的时候，if条件里面的“(”、“)”括号经常出现不匹配的情况导致编译不过，请编写程序检测输入一行if语句中的圆括号是否匹配正确。
* 同时输出语句中出现的左括号和右括号数量，如if((a==1)&&(b==1))是正确的，而if((a==1))&&(b==1))是错误的。
* 注意if语句的最外面至少有一对括号。
* 提示：用堆栈来做。
* 输入：if((a==1)&&(b==1)) 输出：RIGHT 3 3
* 输入：if((a==1))&&(b==1)) 输出：WRONG 3 4
*/
public static void main(String[] args) {
System.out.println("请输入测试程序段：");
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
String msg = isMatch(str);
System.out.println(msg);
}
public static String isMatch(String str){
String isMatch = "RIGHT";
int numLeft = 0; // 左括号数目
int numRight = 0; // 右括号数目
Stack<String> st = new Stack<String>();
if(null != str && !"".equals(str)){
// 校验左右括号是否匹配
for(int i=0;i<str.length();i++){
if('(' == str.charAt(i)){ // 遇到左括号就放入栈中
st.push(String.valueOf(str.charAt(i)));
numLeft++;
}else if(')' == str.charAt(i)){ // 遇到右括号就取出栈顶元素进行比较
if(!st.isEmpty() && "(".equals(st.peek())){
st.pop(); // 如果栈顶元素为"(",则删除栈顶元素
}else{
isMatch = "WRONG";
}
numRight++;
}
}
}
return isMatch+" "+numLeft+" "+numRight;
}
}
输出：
请输入测试程序段：
if((a==1)&&(b==1))
RIGHT 3 3请输入测试程序段：
if((a==1))&&(b==1))
WRONG 3 49. 打印 杨辉三角形
有如下规律：
1.左右两边都是1
2.有n行那么第n行就有n个数
3.每行除了左右两边的数之外，第n行第l列的数字是第n-1行的l-1与第n-1行的l数之和
三种实现方式，第一种是我自己写的，与第二种类似，第三种最简洁
package com.huawei;
public class YangHuiSanJiao {
/**
* 有如下规律：
* 1.左右两边都是1
* 2.有n行那么第n行就有n个数
* 3.每行除了左右两边的数之外，第n行第l列的数字是第n-1行的l-1与第n-1行的l数之和
*/
public static void main(String[] args) {
System.out.println("第一种实现方式：");
int n=10; // 定义杨辉三角行数
int[][] yhArray = new int[n][n];
// 循环赋值得到杨辉三角的二维数组
for(int i=0;i<yhArray.length;i++){
int[] array = new int[i+1]; // 有n行那么第n行就有n个数,左右两边都是1
array[0] = 1;
array[array.length-1] = 1;
for(int j=1;j<array.length-1;j++){
// 每行除了左右两边的数之外，第n行第l列的数字是第n-1行的l-1与第n-1行的l数之和
array[j] = yhArray[i-1][j-1] + yhArray[i-1][j];
}
yhArray[i] = array;
}
// 打印等腰杨辉三角
for(int i=0;i<yhArray.length;i++){
int[] array = yhArray[i];
//打印空格，第一行打印 n-1个空格，第二行n-2个空格
for(int m = 0; m < yhArray.length - 1 - i; m++){
System.out.print(" ");
}
for(int j=0;j<array.length;j++){
System.out.printf("%4d",array[j]);
}
System.out.println("");
}
System.out.println("");
System.out.println("==================================================");
System.out.println("第二种实现方式：");
//定义二维数组的长度
int length = 10;
//声明二维数组
int[][] arr = new int[length][];
//遍历二维数组
for(int i = 0; i < arr.length; i++){
//打印空格
for(int m = 0; m < arr.length - 1 - i; m++){
System.out.print(" ");
}
//给每个二维数据的元素赋值一维数组
arr[i] = new int[i+1];
//遍历一维数组
for(int j = 0; j < arr[i].length; j++){
//第一个元素和最后一个元素的值都是1
if( j == 0 || j == arr[i].length -1 ){
arr[i][j] = 1;
}else{
//当前一维数组的索引n元素的值，等于前一个数组索引n-1，加上索引n的值
arr[i][j] = arr[i -1][j - 1] + arr[i - 1][j];
}
//格式化输出元素值
System.out.printf("%4d",arr[i][j]);
}
//换行
System.out.println();
}
System.out.println("");
System.out.println("==================================================");
System.out.println("第三种实现方式：");
int rows = 10;
for(int i =0;i<rows;i++) {
int number = 1;
//打印空格字符串
System.out.format("%"+(rows-i)*2+"s","");
for(int j=0;j<=i;j++) {
System.out.format("%4d",number);
number = number * (i - j) / (j + 1);
}
System.out.println();
}
}
}
输出：
第一种实现方式：
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
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
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