求一个3×3矩阵两条对角线上元素之和(中心元素只加一次)。 函数接口定义： int fun(int a[N][N]); 其中a是用户传入的参数，函数fun求a数组的两条对角线上元素之和并返回。

好的，这是一个简单的矩阵操作问题。我可以为您提供如下代码实现：

#include <iostream>
using namespace std;

const int N = 3;

int fun(int a[N][N]) {
    int sum = 0;
    for(int i = 0; i < N; i++) {
        sum += a[i][i];         // 左上到右下对角线
        sum += a[i][N - i - 1]; // 右上到左下对角线
    }
    sum -= a[N/2][N/2];         // 中心元素只加一次，减去多加的一次
    return sum;
}

int main() {
    int a[N][N] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    cout << fun(a) << endl;     // 输出：25
    return 0;
}

函数 `fun` 的思路是遍历矩阵的两条对角线，将元素之和累加到变量 `sum` 中。需要注意的是，中心元素只加一次，所以最后需要减去多加的一次中心元素。

相关问题

二维数组：求5行5列矩阵的主、副对角线上元素之和。 注意：两条对角线相交的元素只加一次。 函数接口定义： int fun(int a[M][M]) ; 函数返回主副对角线元素的累加和。

实现代码如下：

#define M 5

int fun(int a[M][M])
{
    int sum = 0;
    // 计算主对角线元素之和
    for (int i = 0; i < M; i++) {
        sum += a[i][i];
    }
    // 计算副对角线元素之和
    for (int i = 0; i < M; i++) {
        sum += a[i][M - i - 1];
    }
    // 如果有重复计算的元素，需要减去一次
    if (M % 2 == 1) {
        sum -= a[M/2][M/2];
    }
    return sum;
}

主对角线上的元素都是形如 `a[i][i]` 的形式，而副对角线上的元素都是形如 `a[i][M - i - 1]` 的形式。需要注意的是，如果矩阵的行数和列数都是奇数，那么两条对角线会在中心元素相交，此时中心元素会被重复计算，需要减去一次。

编写函数int fun(int a[M][M])，求5行5列矩阵的主、副对角线上元素之和。注意，两条对角线相交的元素只加一次。

### 回答1：
可以通过两个循环遍历矩阵，分别计算主对角线和副对角线上的元素之和。主对角线上的元素满足行列下标相等，副对角线上的元素满足行列下标之和为4。代码如下：

#include <iostream>
using namespace std;

const int M = 5;  // 矩阵大小

int fun(int a[M][M])
{
    int sum = 0;
    for (int i = 0; i < M; i++) {
        sum += a[i][i];  // 计算主对角线上的元素之和
        sum += a[i][M-i-1];  // 计算副对角线上的元素之和
    }
    sum -= a[M/2][M/2];  // 由于两条对角线相交的元素被计算了两次，需要减去一次
    return sum;
}

int main()
{
    int a[M][M] = {{1, 2, 3, 4, 5},
                   {6, 7, 8, 9, 10},
                   {11, 12, 13, 14, 15},
                   {16, 17, 18, 19, 20},
                   {21, 22, 23, 24, 25}};
    cout << "矩阵的主、副对角线上元素之和为：" << fun(a) << endl;
    return 0;
}

输出结果为：

矩阵的主、副对角线上元素之和为：101

### 回答2：
编写函数int fun(int a[M][M])，可以通过循环遍历矩阵的主、副对角线上的元素，并求和。首先，我们要明确主对角线和副对角线的位置。在一个5行5列的矩阵中，主对角线上的元素都满足行号和列号相等的条件，而副对角线上的元素满足行号和列号之和等于4（行数+列数=4）的条件。

算法步骤如下：
1. 初始化主对角线和副对角线的和为0，设为sum1和sum2。
2. 使用两层循环，外层循环遍历每一行，内层循环遍历每一列。
3. 判断当前元素是否在主对角线上，即行号等于列号，如果是，则将该元素的值加到sum1中。
4. 判断当前元素是否在副对角线上，即行号加列号等于4，如果是，则将该元素的值加到sum2中。
5. 循环结束后，求得主对角线上的元素之和sum1和副对角线上的元素之和sum2。
6. 返回主对角线和副对角线的和：return sum1 + sum2。

代码实现如下：

int fun(int a[M][M]) {
    int sum1 = 0; // 主对角线和
    int sum2 = 0; // 副对角线和
    for (int i = 0; i < M; i++) {
        for (int j = 0; j < M; j++) {
            if (i == j) { // 判断是否在主对角线上
                sum1 += a[i][j];
            }
            if (i + j == M - 1) { // 判断是否在副对角线上
                sum2 += a[i][j];
            }
        }
    }
    return sum1 + sum2;
}

这样就得到了主、副对角线上元素之和的函数实现。

### 回答3：
编写函数int fun(int a[M][M])，求5行5列矩阵的主、副对角线上元素之和。注意，两条对角线相交的元素只加一次。

要求求解两条对角线的和，可以采用遍历矩阵的方式，将对角线上的元素累加起来。

首先，我们可以定义两个变量，分别用来保存主对角线和副对角线上的元素之和。可以初始化这两个变量为0。

然后，通过遍历矩阵的方式，对于主对角线上的元素，行和列的下标相等，将这些元素累加到主对角线和的变量中。

同时，对于副对角线上的元素，行和列的下标之和等于矩阵的维度减一（即5-1=4），将这些元素累加到副对角线和的变量中。

最后，两个和值分别代表了主对角线和副对角线上的元素之和。

具体的代码实现如下：

#define M 5

int fun(int a[M][M]) {
    int mainDiagonalSum = 0;  // 主对角线和
    int antidiagonalSum = 0;  // 副对角线和

    // 遍历矩阵
    for (int i = 0; i < M; i++) {
        for (int j = 0; j < M; j++) {
            // 主对角线上的元素
            if (i == j) {
                mainDiagonalSum += a[i][j];
            }
            // 副对角线上的元素
            if (i + j == M - 1) {
                antidiagonalSum += a[i][j];
            }
        }
    }

    return mainDiagonalSum + antidiagonalSum;
}

以上就是编写函数`int fun(int a[M][M])`，求5行5列矩阵的主、副对角线上元素之和的方法。在遍历矩阵的过程中，通过判断行和列的关系，将对应位置的元素累加到对角线和的变量中。