以下是用 C++ 编写一个函数，输入一个一维数组并计算一维数组 a[n] 中所有元素的平方和。

可以参考以下代码实现：

#include <iostream>
using namespace std;

int sumOfSquares(int arr[], int n) {
    int sum = 0;
    for (int i = 0; i < n; i++) {
        sum += arr[i] * arr[i];
    }
    return sum;
}

int main() {
    int n;
    cout << "Enter the size of array: ";
    cin >> n;

    int arr[n];
    cout << "Enter the elements of array: ";
    for (int i = 0; i < n; i++) {
        cin >> arr[i];
    }

    int sum = sumOfSquares(arr, n);
    cout << "Sum of squares of elements in the array: " << sum << endl;

    return 0;
}

函数 `sumOfSquares` 用于计算一维数组中所有元素的平方和。在 `main` 函数中，先输入数组的大小和元素，然后调用 `sumOfSquares` 函数计算平方和，并输出结果。

相关问题

利用c＋＋，编写一个函数求一维数组a[n]中所有元素平方和

以下是用 C++ 编写一个函数，计算一维数组 a[n] 中所有元素的平方和。

#include <iostream>
using namespace std;

int squareSum(int a[], int n) {
    int sum = 0;
    for (int i = 0; i < n; i++) {
        sum += a[i] * a[i];
    }
    return sum;
}

int main() {
    int a[] = {1, 2, 3, 4, 5};
    int n = sizeof(a)/sizeof(a[0]);
    int result = squareSum(a, n);
    cout << "平方和为：" << result << endl;
    return 0;
}

函数 `squareSum` 接收两个参数：一个整型数组 `a` 和数组的长度 `n`。在函数中，我们使用一个循环遍历数组中的所有元素，将每个元素的平方加到 `sum` 变量中。最后，函数返回 `sum` 的值。

在主函数中，我们定义了一个整型数组 `a`，并初始化了它的值。然后我们调用 `squareSum` 函数，并将结果存储在 `result` 变量中。最后，我们输出结果。

输出结果应该是：

平方和为：55

用C++代码写一个六子棋估值函数

六子棋的估值函数可以通过统计某个点周围的连续子数量来计算。具体实现代码如下：

int evaluate(int board[][15], int player) {
    int score = 0;
    int opponent = player == 1 ? 2 : 1;
    int i, j, k, count;
    // 统计横向和纵向的连续子数量
    for (i = 0; i < 15; i++) {
        for (j = 0; j < 15; j++) {
            if (board[i][j] == player) {
                for (k = 1, count = 0; j + k < 15 && board[i][j + k] == player; k++, count++);
                score += count * count;
                for (k = 1, count = 0; i + k < 15 && board[i + k][j] == player; k++, count++);
                score += count * count;
            } else if (board[i][j] == opponent) {
                for (k = 1, count = 0; j + k < 15 && board[i][j + k] == opponent; k++, count++);
                score -= count * count;
                for (k = 1, count = 0; i + k < 15 && board[i + k][j] == opponent; k++, count++);
                score -= count * count;
            }
        }
    }
    // 统计斜向的连续子数量
    for (i = 0; i < 15; i++) {
        for (j = 0; j < 15; j++) {
            if (board[i][j] == player) {
                for (k = 1, count = 0; i + k < 15 && j + k < 15 && board[i + k][j + k] == player; k++, count++);
                score += count * count;
                for (k = 1, count = 0; i + k < 15 && j - k >= 0 && board[i + k][j - k] == player; k++, count++);
                score += count * count;
            } else if (board[i][j] == opponent) {
                for (k = 1, count = 0; i + k < 15 && j + k < 15 && board[i + k][j + k] == opponent; k++, count++);
                score -= count * count;
                for (k = 1, count = 0; i + k < 15 && j - k >= 0 && board[i + k][j - k] == opponent; k++, count++);
                score -= count * count;
            }
        }
    }
    return score;
}

其中，`board`是一个二维数组表示棋盘，`player`表示当前玩家（1为先手，2为后手）。函数返回当前棋盘在`player`下的估值分数。该函数会统计当前棋盘中所有的连续子，将连续子的数量平方加入到分数中。如果连续子属于对手，则减去分数。最终返回的分数越高表示当前棋盘在`player`下越有优势。