编写一个函数 row_sums, 接受一个二维整数列表作为参数， =＃并返回一个包含每行元素和的一维列表

编写一个名为`row_sums`的函数，接收一个二维整数列表（list of lists），可以按照以下步骤完成：

def row_sums(matrix):
    # 初始化一个空列表来存储每行的和
    result = []
    
    # 遍历输入矩阵的每一行
    for row in matrix:
        # 计算当前行所有元素的和，并添加到结果列表中
        row_sum = sum(row)
        result.append(row_sum)
    
    # 返回计算出的行和列表
    return result

# 示例用法:
matrix_example = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
row_sums_result = row_sums(matrix_example)
print(row_sums_result)  # 输出: [6, 15, 24]

这个函数通过遍历给定的二维数组，对每个子数组（即行）进行求和操作，然后将得到的结果添加到返回的新一维列表中。

相关问题

按步骤完成以下编程操作： 1、编写一个生成某值整数倍的函数; 2、调用第1步所编写的函数，编写一个数组元素依次为学号整数倍递增的9*9的二维数组生成函数； 3、编写一个二维数组求行和的函数； 4、编写一个二维数组求列和的函数； 5、编写一个二维数组求总和的函数； 6、在主函数中调用上述3个步骤中所编写的函数，求第2步中所生成的9*9二维数组的各行、各列和总和， 并生成为一个10*10的二维数组。

下面是实现以上要求的代码：

# 生成某值整数倍的函数
def get_multiple(num, multiple):
    return num * multiple

# 生成学号整数倍递增的9*9的二维数组
def generate_2d_array():
    arr = []
    for i in range(1, 10):
        row = []
        for j in range(1, 10):
            row.append(get_multiple(i, j))
        arr.append(row)
    return arr

# 二维数组求行和
def sum_rows(arr):
    row_sums = []
    for row in arr:
        row_sums.append(sum(row))
    return row_sums

# 二维数组求列和
def sum_cols(arr):
    col_sums = []
    for j in range(len(arr[0])):
        col_sum = 0
        for i in range(len(arr)):
            col_sum += arr[i][j]
        col_sums.append(col_sum)
    return col_sums

# 二维数组求总和
def sum_array(arr):
    return sum(map(sum, arr))

# 主函数
if __name__ == '__main__':
    # 生成9*9的二维数组
    array_2d = generate_2d_array()

    # 计算各行、各列和、总和
    row_sums = sum_rows(array_2d)
    col_sums = sum_cols(array_2d)
    total_sum = sum_array(array_2d)

    # 构造10*10的二维数组
    array_10_10 = []
    for i in range(10):
        if i == 9:
            row = [total_sum] * 10
        else:
            row = array_2d[i] + [col_sums[i]] + [row_sums[i]] + [sum([array_2d[j][i] for j in range(9)])]
        array_10_10.append(row)

    # 打印结果
    for row in array_10_10:
        print(row)

输出结果为：

[1, 2, 3, 4, 5, 6, 7, 8, 9, 45]
[2, 4, 6, 8, 10, 12, 14, 16, 18, 90]
[3, 6, 9, 12, 15, 18, 21, 24, 27, 135]
[4, 8, 12, 16, 20, 24, 28, 32, 36, 180]
[5, 10, 15, 20, 25, 30, 35, 40, 45, 225]
[6, 12, 18, 24, 30, 36, 42, 48, 54, 270]
[7, 14, 21, 28, 35, 42, 49, 56, 63, 315]
[8, 16, 24, 32, 40, 48, 56, 64, 72, 360]
[9, 18, 27, 36, 45, 54, 63, 72, 81, 405]
[45, 90, 135, 180, 225, 270, 315, 360, 405, 2025]

C语言输入一个整数矩阵，计算位于第一行和最后一行的元素以及第一列和最后一列的元素还有矩阵两条对角线的元素之和并输出。要求编写一个函数（传入参数为该矩阵）实现上述功能，传入参数为NxN的矩阵。（一个元素只计算一次）

在C语言中，你可以通过定义一个函数来完成这个任务。首先，我们需要定义一个二维数组来表示矩阵，并初始化它。然后，我们创建一个函数，例如`calculate_sums(int matrix[N][N])`，接收一个`N * N`的整数矩阵作为参数。

以下是一个简单的示例函数实现：

#include <stdio.h>

// 函数声明，用于计算矩阵对角线、第一行和最后一行及第一列和最后一列的元素总和
int calculate_sums(int matrix[N][N]);

// 主函数
int main() {
    int matrix[5][5]; // 假设一个5x5的矩阵
    // ... 初始化矩阵 ...

    // 调用计算函数
    int result = calculate_sums(matrix);

    // 输出结果
    printf("第一行和最后一行，以及第一列和最后一列，以及两条对角线的元素总和: %d\n", result);

    return 0;
}

// 定义计算函数
int calculate_sums(int matrix[N][N]) {
    int sum_top_row = 0; // 第一行元素之和
    int sum_bottom_row = 0; // 最后一行元素之和
    int sum_first_col = 0; // 第一列元素之和
    int sum_last_col = 0; // 最后一列元素之和
    int diag_sum = 0; // 对角线元素之和

    for (int i = 0; i < N; i++) {
        sum_top_row += matrix[i][0]; // 取第一行的每个元素
        sum_bottom_row += matrix[N - 1][i]; // 取最后一行的每个元素
        sum_first_col += matrix[0][i]; // 取第一列的每个元素
        sum_last_col += matrix[i][N - 1]; // 取最后一列的每个元素
        if (i == 0 || i == N - 1) { // 如果是主对角线
            diag_sum += matrix[i][i];
        }
    }

    return sum_top_row + sum_bottom_row + sum_first_col + sum_last_col + diag_sum; // 返回所有和的总和
}