康威的生命游戏更新（下一代）

Question

我正在编写 Conway 的生命游戏 Java 代码，并且我正在为我的更新方法（也称为下一代创建者）而苦苦挣扎。我将发布我到目前为止编写的代码，请让我知道我可以做些什么来修复更新方法。

如果在时间 T 没有细胞，则生成一个细胞 1 和恰好三个它的邻居还活着。

如果在时间 T，一个现有的细胞仍然活着 1 有两个或三个邻居

如果在时间 T，一个细胞会因隔离而死亡 1 邻居少于两个。

如果在时间 T，一个细胞会因过度拥挤而死亡 1 邻居超过三个。

public class GameOfLife {

    private char [][] grid;
    private int rows;
    private int columns;

    public GameOfLife(int rows, int columns) {
        grid=new char[rows][columns];
        for(int i=0;i<grid.length;i++)
        {
            for(int j=0;j<grid[i].length;j++)
                grid[i][j]=' ';
        }

    }

    public int numberOfRows() {
         int countRows=0;
          for(int i=0;i<grid.length;i++){
             countRows++;
             rows=countRows;
          }
          return rows;

    }

    public int numberOfColumns() {
        int countColumns=0;
          for(int i=0;i<1;i++){
             for(int j=0;j<grid[i].length;j++)
                countColumns++;
                columns=countColumns;
          }
          return columns;
    }

    public void growCellAt(int row, int col) {
        for(int i=0;i<grid.length;i++){
            for(int j=0;j<grid[i].length;j++) 
                   grid[row][col]='O';
        }
    }

    public boolean cellAt(int row, int col) {
        for(int i=0;i<grid.length;i++){
            for(int j=0;j<grid[i].length;j++)
                if(grid[row][col]=='O')
                    return true;
        }
        return false;
    }

    public String toString() {
        String result="";
        for(int i=0;i<rows;i++){
            for(int j=0;j<columns;j++)
                result+=grid[i][j];
        }
        return result;
    }

    public int neighborCount(int row, int col) {
        int count=0;
        int i=row;
        int j=col;
        int left;
        int right;
        int up;
        int down;
        if(i > 0)
            up = i-1;
        else
            up = grid.length-1;

        if(i < (grid.length-1))
            down = i+1;
        else
            down = 0;

        if(j > 0) 
            left = j-1;
        else
            left = grid[i].length - 1;

        if(j < (grid[i].length-1))
            right = j+1;
        else
            right = 0;

        if(grid[up][left] == 'O')
            count++;

        if(grid[up][j] == 'O')
            count++;

        if(grid[up][right] == 'O')
            count++;

        if(grid[i][left] == 'O')
            count++;

        if(grid[i][right] == 'O')
            count++;

        if(grid[down][left] == 'O')
            count++;

        if(grid[down][j] == 'O')
            count++;

        if(grid[down][right] == 'O')
            count++;

        return count;
    }

    public void update() {

        for(int i=0;i<grid.length;i++){
            for(int j=0;j<grid[i].length;j++){
                if(grid[i][j]==' ' && neighborCount(i,j)==3)
                    grid[i][j]='O';
                if(neighborCount(i,j)<2 || neighborCount(i,j)>3)
                    grid[i][j]= ' ';
                if(grid[i][j]=='O' && neighborCount(i,j)==2 || neighborCount(i,j)==3)
                    grid[i][j]='O';
            }
        }
    }
}

好的，关于在更新方法中创建一个新数组，这就是所有需要做的吗？另外，我将如何对更新方法进行断言测试？

public void update() {
    char[][] newGrid = new char[grid.length][grid[0].length];
    for(int i=0;i<grid.length;i++){
        for(int j=0;j<grid[i].length;j++){
            if(grid[i][j]==' ' && neighborCount(i,j)==3)
                newGrid[i][j]='O';
            if(neighborCount(i,j)<2 || neighborCount(i,j)>3)
                newGrid[i][j]= ' ';
            if(grid[i][j]=='O' && neighborCount(i,j)==2 || neighborCount(i,j)==3)
                newGrid[i][j]='O';
        }
    }
}

Answer 1

您似乎正在尝试修改您正在循环的同一个网格。当您遍历网格时，应根据网格的先前状态进行更改。尝试构建一个新网格而不是覆盖旧网格。

Answer 2

这就是我的做法。 请注意，这是 C++11 实现

template<std::size_t X, std::size_t Y>
class GameOfLife {
private: 
  std::pair<int, int> neighbors[8];

public:
  typedef std::array<std::array<uint16_t,Y>,X> Grid;

private:
  uint16_t getCellStatus(Grid const& conway, int x, int y) {        
    uint16_t liveCount = 0;     
    for(auto&& neighbor: neighbors) {
      int nX = x + neighbor.first;
      int nY = y + neighbor.second;
      if(nX>=0 && nX<X && nY>=0 && nY<Y){
        if(conway[nX][nY]>0) liveCount++;
      }     
    }
    if(conway[x][y]>0){
      if(liveCount==2 ||liveCount == 3) return 1;        
    } 
    else {
      if(liveCount==3) return 1;        
    }
    return 0;
    }

public: 
  GameOfLife() {
    size_t index = 0;
    for(int i=-1; i<=1; ++i) {
      for(int j=-1; j<=1; ++j){
        if((i|j)==0) continue;
        neighbors[index].first = i;
        neighbors[index++].second = j;
      }             
    }
  }

  Grid getNextConway(Grid const& conway) {
    Grid output;
    for(size_t i=0; i<X; ++i)
      for(size_t j=0; j<Y; ++j) output[i][j]=getCellStatus(conway,i,j);
      return output;
  }

  Grid printGrid(Grid const& conway) { 
    for (int i = 0; i < X; ++i){
      for (int j = 0; j < Y; ++j) {
        if(conway[i][j]==0) std::cout<<"0";
        else std::cout<<"1";
      }
      std::cout<<std::endl;
    }
    std::cout<<std::endl;
  } 

};


int main() {
  size_t const DIM = 8;
  size_t const NUM_GENS = 10;
  typedef GameOfLife<DIM,DIM> Game;
  typename Game::Grid gameGrid;  
  for (int i = 0; i < DIM; ++i) {    
    for (int j = 0; j < DIM; ++j) {
      gameGrid[i][j] = rand()%2;
    }
  }
  Game conway;
  conway.printGrid(gameGrid);  
  for (int i = 0; i < NUM_GENS; ++i) {
    gameGrid = conway.getNextConway(gameGrid);
    conway.printGrid(gameGrid);
  }
  return 0;
}