生命游戏（Life game）

最新推荐文章于 2025-02-24 12:27:29 发布

橡树心

最新推荐文章于 2025-02-24 12:27:29 发布

阅读量4k

点赞数

分类专栏： Java算法文章标签：游戏 C C++ C# J#

Java算法专栏收录该内容

12 篇文章

订阅专栏

本文介绍了一种基于Java实现的生命游戏算法。该游戏遵循英国数学家J.H.Conway提出的规则，包括细胞的孤单死亡、拥挤死亡、稳定及复活等状态变化。通过二维数组模拟细胞状态，并实现了状态迭代和显示。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

[b]问题说明：[/b]

生命游戏，为1970年英国数学家J.H.Conway所提出，某一细胞的邻居包括上，下，左，右，左上，左下，右上与右下相邻的细胞，游戏规则如下：

1，孤单死亡：如果细胞的邻居小于一个，则该细胞在下一个状态死亡。

2，拥挤死亡：如果细胞的邻居在四个以上，则该细胞在下一个状态死亡。

3，稳定：如果细胞的邻居为两个或三个，则该细胞在下一个状态稳定。

4，复活：如果某位置原无细胞存活，而该位置的邻居为三个，则该位置将复活一个细胞。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class LifeGame {
    private boolean[][] map;
    private boolean[][] newmap;

    public LifeGame(int maxRow, int maxColumn) {
        map = new boolean[maxRow][maxColumn];
        newmap = new boolean[maxRow][maxColumn];
    }

    public void setCell(int x, int y) {
        map[x][y] = true;
    }

    public void next() {
        for(int row = 0; row < map.length; row++) {
            for(int col = 0; col < map[0].length; col++) {
               switch (neighbors(row, col)) {
                  case 0: 
                  case 1: 
                  case 4: 
                  case 5: 
                  case 6: 
                  case 7: 
                  case 8: 
                     newmap[row][col] = false; 
                     break; 
                  case 2: 
                     newmap[row][col] = map[row][col]; 
                     break; 
                  case 3: 
                     newmap[row][col] = true; 
                     break; 
               } 
            }
         }

         copyMap();
    }

    public void outputMap() throws IOException { 
        System.out.println("\n\nGame of life cell status"); 
        for(int row = 0; row < map.length; row++) { 
            System.out.print("\n "); 
           for(int col = 0; col < map[0].length; col++) 
              if(map[row][col] == true) 
                  System.out.print('#'); 
              else 
                  System.out.print('-'); 
        } 
    }

    private void copyMap() {
        for(int row = 0; row < map.length; row++) 
           for(int col = 0; col < map[0].length; col++) 
              map[row][col] = newmap[row][col]; 
    }

    private int neighbors(int row, int col) {
        int count = 0; 

        for(int r = row-1; r <= row+1; r++) 
           for(int c = col-1; c <= col+1; c++) { 
              if(r < 0 || r >= map.length ||
                 c < 0 || c >= map[0].length) 
                 continue; 
              if(map[r][c] == true) 
                 count++; 
           } 

        if(map[row][col] == true) 
           count--; 

        return count; 
    } 

    public static void main(String[] args) 
                 throws NumberFormatException, IOException {
        BufferedReader bufReader = 
            new BufferedReader(
                    new InputStreamReader(System.in));

        LifeGame game = new LifeGame(10, 25);

        System.out.println("Game of life Program"); 
        System.out.println(
                   "Enter x, y where x, y is living cell");
        System.out.println("0 <= x < 10, 0 <= y < 25"); 
        System.out.println("Terminate with x, y = -1, -1");

        while(true) {
            String[] strs = bufReader.readLine().split(" ");
            int row = Integer.parseInt(strs[0]);
            int col = Integer.parseInt(strs[1]);

            if(0 <= row && row < 10 && 0 <= col && row < 25) 
                game.setCell(row, col);
            else if(row == -1 || col == -1) {
                break;
            }
            else { 
                System.out.print(
                         "(x, y) exceeds map ranage!");
            }
        }

        while(true) {
            game.outputMap();
            game.next();

            System.out.print(
                         "\nContinue next Generation ? ");

            String ans = bufReader.readLine().toUpperCase();

            if(!ans.equals("Y"))
                break;
        } 
    }
}