本关任务： （1）编写一个函数输出杨辉三角前n行。 （2）调用函数，输出任意行

# 定义函数，输出杨辉三角前n行
def yanghui_triangle(n):
triangle = [] # 存储杨辉三角
for i in range(n):
row = [1] * (i + 1) # 初始化这一行
for j in range(1, i):
row[j] = triangle[i-1][j-1] + triangle[i-1][j] # 计算该行每个数字
triangle.append(row) # 将该行加入杨辉三角
for row in triangle:
print(row)

# 调用函数，输出第8行杨辉三角
yanghui_triangle(8)

相关问题

定义杨辉三角函数，主函数调用该函数，输入任意数n，输出n行杨辉三角图形

### 回答1：
杨辉三角函数是一个用来生成杨辉三角的函数，它的定义如下：

def yanghui(n):
triangle = []
for i in range(n):
row = [1] * (i + 1)
for j in range(1, i):
row[j] = triangle[i - 1][j - 1] + triangle[i - 1][j]
triangle.append(row)
return triangle

主函数可以调用这个函数来生成任意行数的杨辉三角图形，例如：

n = 5
triangle = yanghui(n)
for row in triangle:
print(row)

输出结果如下：

[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]

这就是一个5行的杨辉三角图形。

### 回答2：
杨辉三角是一种很有趣的数学图形，它是个三角形，其中每个数等于它正上方与左上方的两个数的和，同时第一行只有一个数字1，第二行有两个数字1，后面的每行数字个数都与行数相等，并且每行两侧的数字都为1。因此可以使用递归或者循环，编写一个函数来生成杨辉三角形。

定义杨辉三角函数：
1. 函数名：yang_triangle
2. 参数：n，表示需要输出多少行杨辉三角形
3. 返回值：无

函数体实现：

def yang_triangle(n):
  # 定义一个空列表存放数字
  nums = []
  # 遍历每一行
  for i in range(n):
    # 在每一行中，第一个数字和最后一个数字都是1，其他数字是上一行对应数字的和
    row = [1]
    for j in range(1, i):
      row.append(nums[i-1][j-1] + nums[i-1][j])
    if i > 0:
      row.append(1)
    nums.append(row)
  # 输出杨辉三角形
  for row in nums:
    print(" ".join(str(x) for x in row).center(n*5))

主函数调用该函数，输入任意数n，输出n行杨辉三角图形：

n = int(input("请输入杨辉三角的行数："))
yang_triangle(n)

运行结果：

请输入杨辉三角的行数：6
                  1                  
                1   1                
              1   2   1              
            1   3   3   1            
          1   4   6   4   1          
        1   5  10  10   5   1        

通过这个函数，我们可以方便的输出任意行数的杨辉三角形。

### 回答3：
杨辉三角是一个由数字组成的三角形，数字是根据规则排列的，其中第一行只有一个数字1，接下来的每一行数字都是上一行数字左右两个数字之和。如下所示：

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

现在要定义一个杨辉三角函数，主函数调用该函数，输入任意数n，输出n行杨辉三角图形。函数的具体定义如下：

函数名：yanghui
输入参数：代表输出杨辉三角的行数n
返回值：无

程序实现思路如下：首先定义一个二维数组，其行数为n，列数为n+1。由于每一行数字个数都比上一行多1个，因此列数要比行数多1。定义杨辉三角函数中第一个数、最后一个数为1，其他数根据杨辉三角规则依次计算。最后输出数组中的每一个数即可。具体实现代码如下：

#include <stdio.h>

void yanghui(int n)
{
    int a[100][100];
    int i, j;
    for(i = 0; i < n; i++)
    {
        a[i][0] = 1;
        a[i][i+1] = 1;
    }
    for(i = 2; i < n; i++)
        for(j = 1; j <= i; j++)
            a[i][j] = a[i-1][j-1] + a[i-1][j];
    for(i = 0; i < n; i++)
    {
        for(j = 0; j <= i; j++)
            printf("%d ", a[i][j]);
        printf("\n");
    }
}

int main()
{
    int n;
    printf("请输入杨辉三角的行数：");
    scanf("%d", &n);
    yanghui(n);
    return 0;
}

运行结果如下：

请输入杨辉三角的行数：5
1 
1 1 
1 2 1 
1 3 3 1 
1 4 6 4 1

编写函数输出行数为n的杨辉三角，void yanghuTriangle(int n),在主函数中调用输出9行杨辉三角

杨辉三角，又称帕斯卡三角，是一种数学上常见的二项式系数表示形式，每一行都是前一行的数字之和，除了最左边和最右边的第一列，其余每个数都是它上面两数之和。在C语言中，我们可以用嵌套循环来打印出指定行数的杨辉三角。下面是一个函数`yanghuTriangle`的简单实现：

#include <stdio.h>
#include <stdlib.h> // 用于动态分配内存

void printNum(int num) {
    printf("%d ", num);
}

void yanghuTriangle(int n) {
    int** triangle = malloc(sizeof(int*) * n); // 动态分配数组空间
    for (int i = 0; i < n; i++) {
        triangle[i] = (int*)malloc(sizeof(int) * (i + 1)); // 内部再分配一维空间
        triangle[i][0] = triangle[i][i] = 1; // 初始化第一列和最后一列
        for (int j = 1; j < i; j++) {
            triangle[i][j] = triangle[i - 1][j - 1] + triangle[i - 1][j]; // 计算当前元素
        }
        printNum(triangle[i][0]);
        for (int j = 1; j < i; j++) {
            printNum(triangle[i][j]);
        }
        printf("\n");
        free(triangle[i]); // 释放当前行的内存
    }
    free(triangle); // 释放所有行的内存
}

int main() {
    int n = 9;
    yanghuTriangle(n);
    return 0;
}

在`main`函数中，我们调用`yanghuTriangle`函数并传递参数9，这将输出9行的杨辉三角。当你运行这段代码时，会看到从1开始逐渐增长的组合数序列形成的一个金字塔形状的三角形。