按如下函数原型编写程序，输入n×n阶矩阵，用函数编程计算并输出其两条对角线上的各元素之和。 C语言

#include <stdio.h>

int diagonal_sum(int arr[][100], int n);

int main() {
int n;
int arr[100][100];

printf("Enter the size of matrix: ");
scanf("%d", &n);

printf("Enter the elements of matrix:\n");
for(int i=0; i<n; i++) {
for(int j=0; j<n; j++) {
scanf("%d", &arr[i][j]);
}
}

int sum = diagonal_sum(arr, n);
printf("Sum of diagonal elements: %d", sum);

return 0;
}

int diagonal_sum(int arr[][100], int n) {
int sum = 0;
for(int i=0; i<n; i++) {
sum += arr[i][i]; // add elements on main diagonal
sum += arr[i][n-i-1]; // add elements on opposite diagonal
}
return sum;
}

相关问题

按如下函数原型编写程序，输入n×n阶矩阵，用函数编程计算并输出其两条对角线上的各元素之和。

### 回答1：
好的，以下是按照函数原型编写的程序，可以输入n×n阶矩阵，用函数计算并输出其两条对角线上的各元素之和：

def diagonal_sum(matrix):
    n = len(matrix)
    sum1 = 0
    sum2 = 0
    for i in range(n):
        sum1 += matrix[i][i]
        sum2 += matrix[i][n-i-1]
    print("第一条对角线上的元素之和为：", sum1)
    print("第二条对角线上的元素之和为：", sum2)

n = int(input("请输入矩阵的阶数："))
matrix = []
for i in range(n):
    row = input("请输入第{}行元素，以空格分隔：".format(i+1)).split()
    row = [int(x) for x in row]
    matrix.append(row)

diagonal_sum(matrix)

希望能对您有所帮助！

### 回答2：
问题分析：

该问题需要我们编写一个函数来计算矩阵的对角线之和，并且需要输入一个n×n的矩阵。

解决方案：

我们可以定义一个名为diagonal_sum（）的函数来实现这个功能。该函数首先接受用户输入的矩阵，然后使用两个for循环来遍历矩阵的对角线，并计算对角线元素之和。最后返回这个和。

下面给出详细代码实现：

#include <iostream>
using namespace std;

int diagonal_sum(int mat[100][100], int n) {
    int sum = 0;
    for (int i = 0; i < n; i++) {
        sum += mat[i][i]; // 计算主对角线之和
        sum += mat[i][n-1-i];  // 计算副对角线之和
    }
    return sum;
}

int main() {
    int n;
    int mat[100][100];

    cout << "请输入矩阵的阶数n: " << endl;
    cin >> n;

    cout << "请输入" << n << "×" << n << "矩阵的元素：" << endl;

    // 接收用户输入的矩阵元素
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cin >> mat[i][j];
        }
    }

    // 计算对角线之和
    int sum = diagonal_sum(mat, n);

    // 输出结果
    cout << "矩阵对角线之和为：" << sum << endl;

    return 0;
}

运行程序后，先输入矩阵阶数n，然后逐行输入每个元素。程序将计算对角线之和并输出结果。

总结：

本题需要我们熟悉二维数组的遍历方法和函数定义。我们编写了一个名为diagonal_sum（）的函数，该函数接受一个n×n矩阵和阶数n作为参数，并返回矩阵两个对角线之和。通过该题的练习，我们可以更深入地理解函数参数传递和二维数组的操作方式，还能提高编程水平。

### 回答3：
这道题目要求我们编写一个函数，计算一个n×n阶矩阵两条对角线的元素之和。按照题目所给的函数原型，我们需要写一个函数，函数的返回值为整型，输入参数是一个n×n的二维数组和n的值。

我们可以定义两个变量res1和res2，分别表示两条对角线的元素之和。然后使用两个循环嵌套遍历矩阵，对于第i行第j列的元素，如果i等于j，则它在第一条对角线上，加到res1中；如果i+j等于n-1，则它在第二条对角线上，加到res2中。最后返回res1和res2的和即可。

下面是完整的代码实现示例：

#include <iostream>
using namespace std;

int diagonalSum(int **matrix, int n) {
    int res1 = 0, res2 = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i == j) {
                res1 += matrix[i][j];
            }
            if (i + j == n - 1) {
                res2 += matrix[i][j];
            }
        }
    }
    return res1 + res2;
}

int main() {
    int n;
    cout << "请输入矩阵的阶数n：" << endl;
    cin >> n;
    int **matrix = new int*[n];
    for (int i = 0; i < n; i++) {
        matrix[i] = new int[n];
        for (int j = 0; j < n; j++) {
            cout << "请输入第" << i + 1 << "行，第" << j + 1 << "列的值：" << endl;
            cin >> matrix[i][j];
        }
    }
    int sum = diagonalSum(matrix, n);
    cout << "两条对角线上的各元素之和为：" << sum << endl;
    for (int i = 0; i < n; i++) {
        delete[] matrix[i];
    }
    delete[] matrix;
    return 0;
}

我们先输入矩阵的阶数n，然后动态申请一个二维数组matrix，用于存储矩阵的元素。接着使用两个for循环，输入矩阵每个元素的值。

最后调用diagonalSum函数计算两条对角线上的元素之和，并输出结果。最后别忘了释放数组的内存。

输入n×n阶矩阵，用函数编程计算并输出其两条对角线上的各元素之和

### 回答1：
可以使用以下函数来计算矩阵的两条对角线上的元素之和：

def diagonal_sum(matrix):
n = len(matrix)
sum1 = sum(matrix[i][i] for i in range(n))
sum2 = sum(matrix[i][n-i-1] for i in range(n))
return sum1 + sum2

其中，n表示矩阵的阶数，sum1表示从左上角到右下角的对角线上的元素之和，sum2表示从右上角到左下角的对角线上的元素之和。

使用该函数，可以对输入的n×n阶矩阵进行计算并输出其两条对角线上的各元素之和。

### 回答2：
题目要求我们编写一个函数，计算并输出一个n×n阶矩阵的两条对角线上的各元素之和。首先，我们需要明确什么是对角线。在一个n×n阶矩阵中，有两条对角线，一条是从左上角到右下角的主对角线，另一条是从右上角到左下角的副对角线。如下图所示：

1 2 3
4 5 6
7 8 9

主对角线上的元素为1、5、9，副对角线上的元素为3、5、7。它们的和分别为15和15。

接下来，我们可以定义一个函数来计算对角线之和。我们可以使用一个双重循环来遍历矩阵。外层循环控制行数，内层循环控制列数。针对主对角线，行和列的下标相等；对于副对角线，行和列的下标之和等于矩阵的行数减1。因此，我们可以在循环中利用这个规律来累加对角线上的元素。

以下是一个实现该函数的Python代码示例：

def sum_diagonal(matrix):
    n = len(matrix)
    main_diag_sum = 0
    sub_diag_sum = 0
    for i in range(n):
        main_diag_sum += matrix[i][i]
        sub_diag_sum += matrix[i][n-1-i]
    print("主对角线之和为：", main_diag_sum)
    print("副对角线之和为：", sub_diag_sum)

该函数的参数是一个二维列表，即一个n×n的矩阵。首先获取矩阵的行数n。接下来，用两个变量分别表示主对角线和副对角线上元素的累加和，初始值都为0。通过两层循环遍历矩阵的每个元素，累加到对应的变量中。循环结束后，输出两条对角线上元素之和即可。

最后，我们可以通过下面的代码来测试该函数：

matrix = [[1,2,3],
          [4,5,6],
          [7,8,9]]
sum_diagonal(matrix)

运行结果如下：

主对角线之和为： 15
副对角线之和为： 15

可以看到，函数计算出了这个3×3矩阵的两条对角线之和都为15，符合预期。

### 回答3：
题目是要我们通过函数编程来计算并输出一个n×n阶矩阵两条对角线上的各元素之和。

首先，我们需要输入矩阵。可以使用二维数组来存储。函数中传入n表示矩阵的阶数，再让用户输入矩阵中每个元素的值，依次存储到数组中。

接下来，我们需要计算矩阵两条对角线上的各元素之和。对于正方形矩阵，其主对角线上的元素满足行列下标相等，副对角线上的元素满足行列下标之和为n-1。我们可以创建两个变量，一个用于存储主对角线元素之和，一个用于存储副对角线元素之和，遍历数组，依次累加满足条件的元素值即可。

最后，我们可以在函数中使用printf函数输出两条对角线上的各元素之和。

完整代码如下：

#include <stdio.h>

int main() {
    int n, i, j, sum1 = 0, sum2 = 0;
    printf("请输入矩阵阶数n：");
    scanf("%d", &n);
    int matrix[n][n];
    printf("请输入矩阵元素值：\n");
    for(i = 0; i < n; i++) {
        for(j = 0; j < n; j++) {
            scanf("%d", &matrix[i][j]);
            if(i == j) {
                sum1 += matrix[i][j];
            }
            if(i + j == n - 1) {
                sum2 += matrix[i][j];
            }
        }
    }
    printf("主对角线元素之和为：%d\n", sum1);
    printf("副对角线元素之和为：%d\n", sum2);
    return 0;
}

以上就是一种函数式编程的方式，用来计算矩阵两条对角线上的各元素之和。