C++ 无法确定Conway'；s"；“生命的游戏”；正确（生与死的三大法则） #包括 使用名称空间std； 字符**创建数组（整数行、整数列）{ 字符**a； a=新字符*[行]； 对于（int i=0；i 3）{ a[i][x]=''； } else如果（n[计数器]==0 | | n[计数器]==1）{ a[i][x]=''； } else if（n[计数器]==3）{ a[i][x]='*'； } 计数器++； } } 返回a； } 结构GOL{ 字符**表； int-gen； int行； int cols； }; 无效打印数组（字符**a，整数行，整数列）{ 对于（int i=0；i

首先，变量

count

和

n

必须在使用前初始化：

#include <iostream>
using namespace std;

char **create_2darray(int rows, int cols){
    char **a;
    a = new char *[rows];
    for(int i = 0;i<rows;i++){
        a[i]=new char[cols];
    }
    return a;
}
char **set_2darry(int rows, int cols, char** array){
    char ** a = array;
    for(int i = 0; i < rows; i++){
        for(int x = 0; x < cols; x++){
            a[i][x]= ' ';
        }
    }
    return a;
}

char **locate_array(char ** a, int rows, int cols){
    a[rows][cols] = '*';
    return a;
}
char **determine(char ** a, int rows, int cols){
    int counter;
    int n[1000];

    for(int i = 0; i< rows;i++){
        for(int x = 0; x< cols; x++){

            if(i == 0 && x == 0){
                if(a[i][x] == '*'){
                    if(a[i+1][x] == '*'){
                        n[counter]++;
                    }

                    if(a[i][x+1] == '*'){
                        n[counter]++;

                    }
                    if(a[i+1][x+1] == '*'){
                        n[counter]++;
                    }
                }
            }
            else if(i == 0 && x == cols-1){
                if(a[i][x] == '*'){
                    if(a[i][x-1] == '*'){
                        n[counter]++;
                    }
                    if(a[i+1][x-1] == '*'){
                        n[counter]++;
                    }

                    if(a[i+1][x] == '*'){
                        n[counter]++;
                    }
                }

            }
            else if(i == rows-1 && x == 0){
                if(a[i][x] == '*'){
                    if(a[i-1][x] == '*'){
                        n[counter]++;
                    }
                    if(a[i-1][x+1] == '*'){
                        n[counter]++;
                    }
                    if(a[i][x+1] == '*'){
                        n[counter]++;
                    }
                }
            }
            else if(i == rows-1 && x == cols-1){
                if(a[i][x] == '*'){
                    if(a[i-1][x-1] == '*'){
                        n[counter]++;
                    }
                    if(a[i][x-1] == '*'){
                        n[counter]++;
                    }

                    if(a[i-1][x] == '*'){
                        n[counter]++;
                    }
                }
            }
            else if(i == rows-1){
                if(a[i][x] == '*'){
                    if(a[i-1][x-1] == '*'){
                        n[counter]++;

                    }
                    if(a[i][x-1] == '*'){
                        n[counter]++;
                    }

                    if(a[i-1][x] == '*'){
                        n[counter]++;
                    }

                    if(a[i-1][x+1] == '*'){
                        n[counter]++;
                    }
                    if(a[i][x+1] == '*'){
                        n[counter]++;
                    }
                }

            }
            else if(i == 0){
                if(a[i][x] == '*'){
                    if(a[i][x-1] == '*'){
                        n[counter]++;
                    }
                    if(a[i+1][x-1] == '*'){
                        n[counter]++;
                    }
                    if(a[i+1][x] == '*'){
                        n[counter]++;
                    }

                    if(a[i][x+1] == '*'){
                        n[counter]++;
                    }
                    if(a[i+1][x+1] == '*'){
                        n[counter]++;
                    }
                }
            }
            else if(x == 0){
                if(a[i][x] == '*'){
                    if(a[i-1][x] == '*'){
                        n[counter]++;
                    }
                    if(a[i+1][x] == '*'){
                        n[counter]++;
                    }
                    if(a[i-1][x+1] == '*'){
                        n[counter]++;
                    }
                    if(a[i][x+1] == '*'){
                        n[counter]++;
                    }
                    if(a[i+1][x+1] == '*'){
                        n[counter]++;
                    }
                }
            }
            else if(x == cols-1){
                if(a[i][x] == '*'){
                    if(a[i-1][x-1] == '*'){
                        n[counter]++;
                    }
                    if(a[i][x-1] == '*'){
                        n[counter]++;
                    }
                    if(a[i+1][x-1] == '*'){
                        n[counter]++;
                    }
                    if(a[i-1][x] == '*'){
                        n[counter]++;
                    }
                    if(a[i+1][x] == '*'){
                        n[counter]++;
                    }
                }
            }
            else {
                if(a[i][x] == '*'){
                    if(a[i-1][x-1] == '*'){
                        n[counter]++;
                    }
                    if(a[i][x-1] == '*'){
                        n[counter]++;
                    }
                    if(a[i+1][x-1] == '*'){
                        n[counter]++;
                    }
                    if(a[i-1][x] == '*'){
                        n[counter]++;
                    }
                    if(a[i+1][x] == '*'){
                        n[counter]++;
                    }
                    if(a[i-1][x+1] == '*'){
                        n[counter]++;
                    }
                    if(a[i][x+1] == '*'){
                        n[counter]++;
                    }
                    if(a[i+1][x+1] == '*'){
                        n[counter]++;
                    }
                }

            }
            counter++;
                    }
    }
    counter = 0;
    for(int i = 0; i< rows;i++){
        for(int x = 0; x< cols; x++){

            if(n[counter] > 3){
                a[i][x] = ' ';
            }
            else if(n[counter] == 0 || n[counter] == 1){
                a[i][x] = ' ';
            }
            else if(n[counter] == 3){
                a[i][x] = '*';
            }
            counter++;
        }
    }

        return a;
}

struct GOL{
    char** table;
    int gen;
    int rows;
    int cols;
};

void print_2darray(char** a, int rows, int cols){
    for(int i = 0; i < rows; i++){
        for(int x = 0; x < cols; x++){
            cout << a[i][x];
        }
        cout << endl;
    }
}

其次，只检查占用的单元格（规则1和2），但没有检查空单元格的代码（规则3）

虽然可以对现有代码进行更改，但我的建议是编写新代码，以便采用完全不同的逻辑。与其检查相邻单元格对当前单元格的影响，不如更好地计算当前单元格对相邻单元格的影响。（数组中与活细胞相邻的所有细胞都增加1个

n

）。代码看起来更简单

---

对现有代码的更改相当简单。如果（a[i][x]='*'），请删除所有

，

，以便对活细胞和死细胞的相邻活细胞进行计数。

您可以通过使游戏板无限大来简化自己的生活-也就是说，它可以包装

int counter = 0;
int n[1000] = {0};

#包括
#包括
结构网格
{
标准向量<标准向量>m_网格；
尺寸、宽度、高度；
转弯处的大小；
网格（大小、宽度、大小、高度）
：m_宽度（宽度），m_高度（高度）
，m_匝数（0）
{
m_网格。调整大小（m_宽度）；
用于（尺寸x=0；x>newGrid；
newGrid.resize（m_宽度）；
用于（尺寸x=0；xnewGrid[x][y]=（计数器>=2&&counter如果给定的答案之一是该问题的已接受答案，则应通过单击答案旁边的空心复选标记接受该答案，使其变为绿色。如果发现不同的解决方案，则应在此处描述并接受它。
#include <vector>
#include <iostream>

struct Grid
{
    std::vector< std::vector<char> > m_grid;
    size_t m_width, m_height;
    size_t m_turns;

    Grid(size_t width_, size_t height_)
        : m_width(width_), m_height(height_)
        , m_turns(0)
    {
        m_grid.resize(m_width);
        for (size_t x = 0; x < m_width; ++x) {
            m_grid[x].resize(m_height);
            std::fill(m_grid[x].begin(), m_grid[x].end(), ' ');
        }
    }

    char& at(int w_, int h_)
    {
        size_t x = static_cast<size_t>((w_ + m_width) % m_width);
        size_t y = static_cast<size_t>((h_ + m_height) % m_height);
        return m_grid[x][y];
    }

    int count(int w_, int h_)
    {
        return (at(w_, h_) == ' ') ? 0 : 1;
    }

    void turn()
    {
        std::vector< std::vector< char > > newGrid;
        newGrid.resize(m_width);
        for (size_t x = 0; x < m_width; ++x) {
            newGrid[x].resize(m_height);
            for (size_t y = 0; y < m_height; ++y) {
                int counter = count(x - 1, y - 1) + count(x - 1, y) + count(x - 1, y + 1) +
                    count(x, y - 1) + count(x, y + 1) +
                    count(x + 1, y - 1) + count(x + 1, y) + count(x + 1, y + 1);
                if (m_grid[x][y] == '*')
                    newGrid[x][y] = (counter >= 2 && counter <= 3) ? '*' : ' ';
                else
                    newGrid[x][y] = (counter == 3) ? '*' : ' ';
            }
        }
        m_grid = newGrid;

        ++m_turns;
    }

    void paint()
    {
        std::cout << "Turns: " << m_turns << "\n";
        for (size_t x = 0; x < m_width; ++x) {
            for (size_t y = 0; y < m_height; ++y) {
                std::cout << at(x, y);
            }
            std::cout << "\n";
        }
        std::cout << "\n";
    }
};

int main()
{
    Grid g(8, 8);

    g.at(3, 2) = '*';
    g.at(3, 3) = '*';
    g.at(3, 4) = '*';
    g.at(2, 4) = '*';
    g.at(1, 3) = '*';

    for (size_t i = 0; i < 5; ++i) {
        g.paint();
        g.turn();
    }
    g.paint();
}