C++兩個vector元素取反

如果你的向量是 `std::vector<int>` 类型的，可以使用 `std::transform` 函数和一个 lambda 表达式来实现元素取反。示例代码如下：

#include <algorithm>
#include <iostream>
#include <vector>

int main() {
    std::vector<int> v1{1, 2, 3, 4, 5};
    std::vector<int> v2(v1.size());

    std::transform(v1.begin(), v1.end(), v2.begin(),
                   [](int x) { return -x; });

    for (auto i : v2) {
        std::cout << i << " ";
    }
    std::cout << '\n';

    return 0;
}

在这个例子中，我们首先定义了一个 `std::vector<int>` 类型的向量 `v1`，并将其初始化为 `{1, 2, 3, 4, 5}`。然后我们创建了另一个与 `v1` 同样大小的向量 `v2`，并使用 `std::transform` 函数将 `v1` 中的每个元素取反并存储到 `v2` 中。这里的 lambda 表达式 `[](int x) { return -x; }` 将输入的整数取反并返回。最后，我们遍历 `v2` 并输出其中的元素。

相关问题

生成C++代码，计算两个特征向量的夹角，如果夹角大于90°，则将一个特征量向量方向取反

以下是生成的C++代码：

#include <iostream>
#include <vector>
#include <cmath>

using namespace std;

double dot_product(vector<double> vec1, vector<double> vec2)
{
    double result = 0.0;
    for (int i = 0; i < vec1.size(); i++) {
        result += vec1[i] * vec2[i];
    }
    return result;
}

double norm(vector<double> vec)
{
    double result = 0.0;
    for (int i = 0; i < vec.size(); i++) {
        result += vec[i] * vec[i];
    }
    return sqrt(result);
}

double angle_between_vectors(vector<double> vec1, vector<double> vec2)
{
    double dot_prod = dot_product(vec1, vec2);
    double norm1 = norm(vec1);
    double norm2 = norm(vec2);
    double cosine = dot_prod / (norm1 * norm2);
    return acos(cosine) * 180.0 / M_PI;
}

void reverse_vector(vector<double>& vec)
{
    for (int i = 0; i < vec.size(); i++) {
        vec[i] = -vec[i];
    }
}

int main()
{
    vector<double> vec1 = {1.0, 2.0, 3.0};
    vector<double> vec2 = {-1.0, -2.0, -3.0};

    double angle = angle_between_vectors(vec1, vec2);
    cout << "Angle between vectors: " << angle << " degrees" << endl;

    if (angle > 90.0) {
        reverse_vector(vec1);
        cout << "Reversed vector 1: ";
        for (int i = 0; i < vec1.size(); i++) {
            cout << vec1[i] << " ";
        }
        cout << endl;
    }

    return 0;
}

这段代码计算了两个特征向量的夹角，并且如果夹角大于90°，则将第一个特征向量方向取反。你可以将 `vec1` 和 `vec2` 替换为你自己的特征向量。注意，这里假设两个特征向量的维度相同。如果不相同，需要在代码中进行相应的修改。

运用C++类的功能编写康威生命游戏代码 规则: 每个细胞处于两种可能状态中的一种，活的或死的 每个细胞与它的8个邻居相互作用: 1. 任何活细胞如果邻居少于两个就会死亡。 2. 任何一个活的细胞，只要有两到三个活的邻居，就会延续到下一代。 3.任何有三个以上邻居的活细胞都会死到下一代。 4. 任何一个死去的细胞只要有恰好三个活着的邻居，就会成为一个活细胞，延续到下一代。 要求: 1.用户能够自定义创建网格大小 2.用户可以随时暂停和恢复游戏的进程 3.用黑白方块代表细胞的状态 4.先进行随机演化之后在演化过程中可以改变细胞的状态

好的，我会尽力回答你的问题。

以下是使用 C++ 类编写康威生命游戏代码的示例：

#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <chrono>
#include <thread>

class Grid {
private:
    int rows;
    int cols;
    std::vector<std::vector<bool>> cells;

public:
    Grid(int rows, int cols) : rows(rows), cols(cols), cells(rows, std::vector<bool>(cols, false)) {}

    void randomize() {
        std::srand(std::time(nullptr));
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                cells[i][j] = std::rand() % 2;
            }
        }
    }

    void print() {
        system("clear"); // 清除屏幕
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                std::cout << (cells[i][j] ? "■" : "□") << " ";
            }
            std::cout << std::endl;
        }
    }

    void update() {
        std::vector<std::vector<bool>> newCells(rows, std::vector<bool>(cols, false));
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                int neighbors = 0;
                for (int m = -1; m <= 1; m++) {
                    for (int n = -1; n <= 1; n++) {
                        if (m == 0 && n == 0) continue;
                        int x = i + m;
                        int y = j + n;
                        if (x < 0 || x >= rows || y < 0 || y >= cols) continue;
                        if (cells[x][y]) neighbors++;
                    }
                }
                if (cells[i][j]) {
                    if (neighbors < 2 || neighbors > 3) newCells[i][j] = false; // 规则 1 和 3
                    else newCells[i][j] = true; // 规则 2
                }
                else {
                    if (neighbors == 3) newCells[i][j] = true; // 规则 4
                }
            }
        }
        cells = newCells;
    }
};

int main() {
    int rows, cols;
    std::cout << "请输入网格的行数和列数：";
    std::cin >> rows >> cols;

    Grid grid(rows, cols);
    grid.randomize();
    grid.print();

    bool paused = false;
    while (true) {
        if (!paused) {
            grid.update();
            grid.print();
        }
        std::cout << "请输入命令（p 暂停/恢复，c 更改细胞状态，q 退出）：";
        char cmd;
        std::cin >> cmd;
        if (cmd == 'p') paused = !paused;
        else if (cmd == 'c') {
            int x, y;
            std::cout << "请输入细胞的坐标（行 列）：";
            std::cin >> x >> y;
            grid.cells[x][y] = !grid.cells[x][y];
            grid.print();
        }
        else if (cmd == 'q') break;
    }

    return 0;
}

在这个示例中，我们定义了一个名为 `Grid` 的类来表示康威生命游戏中的网格。这个类有三个私有成员变量：行数、列数和一个二维布尔型向量来表示每个细胞的状态。类中包含了三个公有成员函数，分别是：

- `randomize()`：随机生成初始状态。
- `print()`：将当前状态打印到控制台上。
- `update()`：根据康威生命游戏的规则更新状态。

`main()` 函数中，我们首先让用户输入网格的行数和列数，并创建一个 `Grid` 对象。然后，我们使用 `randomize()` 函数来随机生成初始状态，并使用 `print()` 函数将其打印到控制台上。

接下来，我们进入一个循环中。在每次循环中，如果游戏没有被暂停，我们就使用 `update()` 函数更新状态，并使用 `print()` 函数将其打印到控制台上。然后，我们等待用户输入命令，并根据命令执行相应的操作。如果用户输入了 `p`，我们就将游戏暂停或恢复。如果用户输入了 `c`，我们就让用户输入细胞的坐标，并将该细胞的状态取反。如果用户输入了 `q`，我们就退出循环，结束程序。

注意，在每次更新状态之前，我们使用 `system("clear")` 函数清除了控制台上的内容，以便于在同一位置打印新的状态。

希望这个示例能够帮助你编写出自己的康威生命游戏代码。如果你有任何问题或疑问，欢迎随时向我提出。