C++实现生命细胞机，高斯帕滑翔机枪的实现以及模拟细胞分裂

最新推荐文章于 2023-02-20 23:44:57 发布
最新推荐文章于 2023-02-20 23:44:57 发布
阅读量2.3k 收藏 10
点赞数 3
分类专栏： C语言程序设计 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43212988/article/details/106985234
版权

播种者
相信不少接触过C语言编成的同学都了解过“生命细胞机”这么一个有意思的游戏。这个游戏由英国数学家约翰·何顿·康威在1970年发明。上图所示即为生命细胞机一个非常经典的结构：“播种者”，他有很多个高斯帕滑翔机枪组成并且一直平移，所经过之处会产生许多个高斯帕滑翔机枪不断生成高斯帕滑翔机。

生命游戏中，对于任意细胞，规则如下：

  1. 每个细胞有两种状态 - 存活或死亡，每个细胞与以自身为中心的周围八格细胞产生互动
  2. 当前细胞为存活状态时，当周围的存活细胞低于2个时（不包含2个），该细胞变成死亡状态。（模拟生命数量稀少）
  3. 当前细胞为存活状态时，当周围有2个或3个存活细胞时，该细胞保持原样。
  4. 当前细胞为存活状态时，当周围有超过3个存活细胞时，该细胞变成死亡状态。（模拟生命数量过多）
  5. 当前细胞为死亡状态时，当周围有3个存活细胞时，该细胞变成存活状态。（模拟繁殖）

可以把最初的细胞结构定义为种子，当所有在种子中的细胞同时被以上规则处理后，可以得到第一代细胞图。按规则继续处理当前的细胞图，可以得到下一代的细胞图，周而复始。

下面给出生命游戏中几种经典的细胞形态：
在这里插入图片描述
在这里插入图片描述

怎么使用C语言实现生命细胞机呢？

其实生命细胞机的规则很简单，我们首先需要初始化一个二位数组模拟“棋盘”布局。随后我们生成一定量的初始点，并且使用循环的方式遍历这个数组所有的点，依次判断他们周边点的状态，从而确定下一次周期该点的生存或者死亡。

我们先给出实现代码：

#include<stdio.h>
#include <unistd.h>
#include<time.h>
#include<memory.h>
#include<string>
#include <cstdlib>
using namespace std;



int life[80][240] = {0};//生命矩阵
int lifen[80][240]= {0};//中间矩阵
int mm, nn,s,times=0;
int main(){
      srand((unsigned)time(NULL));
      for (int sy = 0; sy < 80; sy++) { //全部点都初始化为活
          for (int s = 0; s < 240; s++) {
              life[sy][s] =1;
              lifen[sy][s] = 1;
          }
      }
     /*这里可以生成随机的生命点
      for (int ra = 0; ra < 800; ra++) {
            
            mm = (rand()%80);
            nn= (rand() % 240);
            life[mm][nn] = 1;
            lifen[mm][nn] = 1;
      }*/
    int m,t,e;
    while(1){

        for(int y=1;y<79;y++)
        {//对所有的数据点进行遍历
            for(int x=1;x<239;x++)
            {
                if(life[y][x]==1)
                {    
                    m=0;
                    m = life[y - 1][x - 1] + life[y - 1][x] + life[y - 1][x + 1] + life[y][x - 1] + life[y][x + 1] + life[y + 1][x - 1] + life[y + 1][x + 1] + life[y + 1][x];//统计周围点的生存状态
                    if(m==2){
                        lifen[y][x]=1;
                    }
                    else if(m==3){
                        lifen[y][x]=1;
                    }
                    else lifen[y][x]=0;
                }
                if (life[y][x] == 0)
                {
                    m = 0;
                    m = life[y - 1][x - 1] + life[y - 1][x] + life[y - 1][x + 1] + life[y][x - 1] + life[y][x + 1] + life[y + 1][x - 1] + life[y + 1][x +1] + life[y + 1][x];

                    if (m == 3) {
                        lifen[y][x] = 1;
                    }
                    else lifen[y][x] = 0;
                }
            }
        }
        for(int my=0;my<80;my++)
        {
            for(int mx=0;mx<240;mx++)
            {
                life[my][mx]=lifen[my][mx];//将中间的矩阵状态复制给生命矩阵
            }
        }
            
            printf("start print:%d\n",times);
            for (int py = 0; py < 80; py++)
            {
                for (int px = 0; px < 240; px++)
                {
                    if (life[py][px] == 0) {
                        printf("\033[47m*\033[0m");//点死亡为白色
                    }
                    else {
                        printf("\033[41m*\033[0m");//点存活为红色
                    }
                }
                printf("\n");
            }
            usleep(100000);//每一次刷新停留0.1秒
            system("clear");
        times++;
    }
}

这段代码的执行效果如图：

在这里插入图片描述
程序在执行一段时间后会到达稳态，如图所示：
在这里插入图片描述

高斯帕滑翔机枪

那么实现了生命细胞机的基本结构，我们怎么生成震撼的滑翔机呢？
这就要求我们具有恰当的初始化的种子，这需要符合高斯帕滑翔机枪的初始结构，在这里我把它们初始化为这些点：

for (int sy = 2; sy < 11; sy++) {
          for (int ss = 0; ss < 240; ss++) {
              s=ss/40;
              s=s*40;
              if(sy==2){life[sy][s+4]=1;life[sy][s+10]=1;life[sy][s+11]=1;}
              else if(sy==3){life[sy][s+2]=1;life[sy][s+6]=1;life[sy][s+10]=1;life[sy][s+11]=1;life[sy][s+12]=1;}
              else if(sy==4){life[sy][s+6]=1;life[sy][s+12]=1;life[sy][s+13]=1;life[sy][s+15]=1;life[sy][s+24]=1;}
              else if(sy==5){life[sy][s+1]=1;life[sy][s+7]=1;life[sy][s+12]=1;life[sy][s+15]=1;life[sy][s+22]=1;life[sy][s+24]=1;}
              else if(sy==6){life[sy][s+1]=1;life[sy][s+2]=1;life[sy][s+12]=1;life[sy][s+13]=1;life[sy][s+15]=1;life[sy][s+21]=1;life[sy][s+23]=1;}
              else if(sy==7){life[sy][s+10]=1;life[sy][s+11]=1;life[sy][s+12]=1;life[sy][s+20]=1;life[sy][s+23]=1;life[sy][s+35]=1;life[sy][s+36]=1;}
              else if(sy==8){life[sy][s+10]=1;life[sy][s+11]=1;life[sy][s+21]=1;life[sy][s+23]=1;life[sy][s+35]=1;life[sy][s+36]=1;}
              else if(sy==9){life[sy][s+22]=1;life[sy][s+24]=1;}
              else if(sy==10){life[sy][s+24]=1;}
          }
      }

接下来给出完整代码：

#include<stdio.h>
#include <unistd.h>
#include<time.h>
#include<memory.h>
#include<string>
#include <cstdlib>
using namespace std;



int life[80][240] = {0};
int lifen[80][240]= {0};
int mm, nn,s,times=0;
int main(){
      for (int sj = 0; sj < 80; sj++) {
          for (int sm = 0; sm < 240; sm++) {
              life[sj][sm] =0;
              lifen[sj][sm] = 0;
          }
      }
      
      for (int sy = 2; sy < 11; sy++) {
          for (int ss = 0; ss < 240; ss++) {
              s=ss/40;
              s=s*40;
              if(sy==2){life[sy][s+4]=1;life[sy][s+10]=1;life[sy][s+11]=1;}
              else if(sy==3){life[sy][s+2]=1;life[sy][s+6]=1;life[sy][s+10]=1;life[sy][s+11]=1;life[sy][s+12]=1;}
              else if(sy==4){life[sy][s+6]=1;life[sy][s+12]=1;life[sy][s+13]=1;life[sy][s+15]=1;life[sy][s+24]=1;}
              else if(sy==5){life[sy][s+1]=1;life[sy][s+7]=1;life[sy][s+12]=1;life[sy][s+15]=1;life[sy][s+22]=1;life[sy][s+24]=1;}
              else if(sy==6){life[sy][s+1]=1;life[sy][s+2]=1;life[sy][s+12]=1;life[sy][s+13]=1;life[sy][s+15]=1;life[sy][s+21]=1;life[sy][s+23]=1;}
              else if(sy==7){life[sy][s+10]=1;life[sy][s+11]=1;life[sy][s+12]=1;life[sy][s+20]=1;life[sy][s+23]=1;life[sy][s+35]=1;life[sy][s+36]=1;}
              else if(sy==8){life[sy][s+10]=1;life[sy][s+11]=1;life[sy][s+21]=1;life[sy][s+23]=1;life[sy][s+35]=1;life[sy][s+36]=1;}
              else if(sy==9){life[sy][s+22]=1;life[sy][s+24]=1;}
              else if(sy==10){life[sy][s+24]=1;}
          }
      }
    int m,t,e;
    while(1){

        for(int y=1;y<79;y++)
        {
            for(int x=1;x<239;x++)
            {
                if(life[y][x]==1)
                {    
                    m=0;
                    m = life[y - 1][x - 1] + life[y - 1][x] + life[y - 1][x + 1] + life[y][x - 1] + life[y][x + 1] + life[y + 1][x - 1] + life[y + 1][x + 1] + life[y + 1][x];
                    if(m==2){
                        lifen[y][x]=1;
                    }
                    else if(m==3){
                        lifen[y][x]=1;
                    }
                    else lifen[y][x]=0;
                }
                if (life[y][x] == 0)
                {
                    m = 0;
                    m = life[y - 1][x - 1] + life[y - 1][x] + life[y - 1][x + 1] + life[y][x - 1] + life[y][x + 1] + life[y + 1][x - 1] + life[y + 1][x +1] + life[y + 1][x];

                    if (m == 3) {
                        lifen[y][x] = 1;
                    }
                    else lifen[y][x] = 0;
                }
            }
        }
        for(int my=0;my<80;my++)
        {
            for(int mx=0;mx<240;mx++)
            {
                life[my][mx]=lifen[my][mx];
            }
        }
        //if (times %==1) {
            
            printf("start print:%d\n",times);
            for (int py = 0; py < 80; py++)
            {
                for (int px = 0; px < 240; px++)
                {
                    if (life[py][px] == 0) {
                        //color(7);
                        printf("\033[47m*\033[0m");
                        //color(1);
                    }
                    else {
                        //color(1);
                        printf("\033[41m*\033[0m");
                        //color(7);
                    }
                }
                printf("\n");
            }
            usleep(100000);
            system("clear");
        //}
        times++;
    }
}

运行结果：
在这里插入图片描述

模拟细胞分裂

如果我们对康威的生命规则进行一些改变：

  1. 生命不会凭空产生，旧的生命可以制造新的生命。
  2. 由于环境绕动，生命可能发生位置上的移动。
  3. 生命会在一定的周期后消亡，并且生命害怕拥挤
  4. 生命不害怕孤独。

那么根据上面的规则我们修改代码如下：

#include<stdio.h>
#include <unistd.h>
#include<time.h>
#include<memory.h>
#include<string>
#include <cstdlib>
using namespace std;



int life[80][400];
int lifen[80][400];
int lifes[80][400];
int period[80][400];
int mm, nn,s,times=0,ry,rx;
int main(){
      for (int sj = 0; sj < 80; sj++) {//初始化所有生命为死亡
          for (int sm = 0; sm < 400; sm++) {
              life[sj][sm] =0;
              lifen[sj][sm] = 0;
              lifes[sj][sm] = 0;
              period[80][400];
          }
      }
      life[40][120]=1;period[40][120]=5;lifes[40][120]=1;//再一个点初始化一个生命
      srand((unsigned)time(NULL));
    int m,t,e;
    while(1){

            if(life[ry=rand()%80][rx=rand()%400]==1){//生命会随机的发生位移
               life[ry][rx]==0;
               life[ry=rand()%80][rx=rand()%400]=1;period[ry][rx]=5;lifes[ry][rx]=1;
            }
        for(int y=1;y<79;y++)
        {//开始遍历数组
            for(int x=1;x<399;x++)
            {
                if(life[y][x]==1)
                {    
                    m=0;
                    m = life[y - 1][x - 1] + life[y - 1][x] + life[y - 1][x + 1] + life[y][x - 1] + life[y][x + 1] + life[y + 1][x - 1] + life[y + 1][x + 1] + life[y + 1][x];
                    if(m==0){
                        lifen[y][x]=1;
                    }
                    else if(m==1){
                        lifen[y][x]=1;
                    }
                    else if(m==2){
                        lifen[y][x]=1;
                    }
                    else {lifen[y][x]=0;period[y][x]==0;}
                    
                    if(period[y][x]!=0)
                       period[y][x]=period[y][x]-1;//生命周期减少
                    else if(period[y][x]==0)lifen[y][x] = 0;
                }
                else if (life[y][x] == 0)
                {
                    m = 0;
                    mm=(rand()%2);
                    if(mm==1){
                    m = lifes[y - 1][x - 1] + lifes[y - 1][x] + lifes[y - 1][x + 1] + lifes[y][x - 1] + lifes[y][x + 1] + lifes[y + 1][x - 1] + lifes[y + 1][x +1] + lifes[y + 1][x];
                    if(lifes[y - 1][x - 1]==1)lifes[y - 1][x - 1]=0;
                    else if(lifes[y - 1][x]==1)lifes[y - 1][x]=0;
                    else if(lifes[y - 1][x+1]==1)lifes[y - 1][x+1]=0;
                    else if(lifes[y][x-1]==1)lifes[y][x-1]=0;
                    else if(lifes[y][x+1]==1)lifes[y][x+1]=0;
                    else if(lifes[y+1][x-1]==1)lifes[y + 1][x-1]=0;
                    else if(lifes[y+1][x]==1)lifes[y + 1][x]=0;
                    else if(lifes[y+1][x+1]==1)lifes[y + 1][x+1]=0;
                    }
                    if (m != 0) {
                        lifen[y][x] = 1;period[y][x]=5;//新生命诞生，初始化生命周期
                    }
                    else {lifen[y][x]=0;period[y][x]==0;}
                }
            }
        }

        for(int my=0;my<80;my++)
        {
            for(int mx=0;mx<400;mx++)
            {
                life[my][mx]=lifen[my][mx];
                lifes[my][mx]=lifen[my][mx];
            }
        }
            printf("start print:%d\n",times);
            for (int py = 0; py < 80; py++)
            {
                for (int px = 0; px < 400; px++)
                {
                    if (life[py][px] == 0) {
                        printf("\033[47m*\033[0m");
                    }
                    else {
                        printf("\033[41m*\033[0m");
                    }
                }
                printf("\n");
            }
            usleep(300000);
            system("clear");
        times++;
    }
}

最后来看看效果图吧：
在这里插入图片描述

木字春
关注
  • 3
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MATLAB算法实战应用案例精讲-【数模应用】元胞自动机生命游戏（附Java、Python、C语言、C++和MATLAB代码实现）
qq_36130719的博客
03-28 831
生命游戏生命游戏其实是一个零玩家游戏，它包括一个二维矩形世界，这个世界中的每个方格居住着一个活着的或死了的细胞。一个细胞在下一个时刻生死取决于相邻八个方格中活着的或死了的细胞的数量。如果相邻方格活着的细胞数量过多，这个细胞会因为资源匮乏而在下一个时刻死去；相反，如果周围活细胞过少，这个细胞会因太孤单而死去。实际中，你可以设定周围活细胞的数目怎样时才适宜该细胞的生存。如果这个数目设定过高，世界中的大部分细胞会因为找不到太多的活的邻居而死去，直到整个世界都没有生命；
Python 实现生命游戏
Python高效编程
06-06 1287
这次我们使用 Python 来实现生命游戏，这是一种简单的元胞自动机。基于一定规则，程序可以自动从当前状态推演到下一状态。制作的成品如下： 先来说说生命游戏的规则： 在生命游戏中，每个单元格有两种状态，生与死。在我们的实现中，黄色的单元格代表活着的细胞，红色单元格表示死亡的细胞。而每一个细胞的下一状态，是由该细胞及周围的八个细胞的当前状态决定的。 具体而言： 当前细胞为活细胞 周围有两个或者三...
生命游戏——高斯帕滑翔机枪
weixin_42162449的博客
05-30 3051
#include<iostream> #include<stdlib.h> #include<windows.h> using namespace std; int map[40][40]= { {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
高斯帕滑翔机枪matlab,cgame3(life)v4.cpp
weixin_30819757的博客
03-16 516
//https://gitee.com/devcpp/cgames anbangli@foxmail.com GNU GPL v3//cgame3(life)v4 康威生命游戏第4版：扩展初始化模式#include #include #include #include using namespace std;const int WD = 38, HT = 20; //游戏地图...
c++ 45行代码实现 生命游戏-细胞自动机！！！
S_JH330206的博客
08-30 831
概念：自动运行的机器 大家知道细胞自动机这个东西吗？当年冯诺依曼发明了计算机，同时也提出了一个概念：有一种机器，只要人为事先设定好，便可以一直自行地执行下去。可惜他早逝，52岁便被癌症带往天堂，到真正实现就要到那个人了：约翰.康威。他发明了一款连他自己也想不到其影响的游戏，即生命游戏，现在就是我们的细胞自动机。接下来，来看一下ta的运行规则吧。 运行规则： 很简单，也很好理解： 这是一个只有细胞元的世界，每个细胞元占一格，且只有生与死两种状态； 现在时刻的状态由上一步骤决定； 状态变化的规则1：如果一个生
高斯帕滑翔机枪matlab,高斯帕滑翔机枪的播种机这么做？
weixin_39884144的博客
03-16 322
该楼层疑似违规已被系统折叠隐藏此楼查看此楼别听楼上瞎说，他估计连播种机是什么都不知道，就把高斯帕滑翔机枪贴上去了，播种机是下面这个x = 420, y = 338, rule = B3/S2375bo2bo$79bo$75bo3bo$76b4o$87b2o$73bo11bo4bo$71bobo17bo$13bobo46bo8bobo11bo5bo$13bobo44bo3bo21b6o5b6o$2...
信息学奥赛C++语言：细胞分裂
zsbailong的博客
03-30 3083
【题目描述】 1个细胞，第1次分裂成2个，第2次2个分裂成4个，……，试编一程序，算一下第5次分裂成几个？ 【输入】 无 【输出】 输出经过5次分裂后，细胞的总数。 【输入样例】 无 【输出样例】 输出经过5次分裂后，细胞的总数。 代码 ...
C++: 生命游戏(模拟细胞群演化)
页面无法显示_(:з」∠)__
05-28 2454
生命游戏是由英国剑桥大学数学家John Conway提出的,游戏的规则是这样的,在一个M*N棋盘上,每格只有两个状态, “生”和“死”,分别表示是否被一个生命棋子所占有.每个方格有八个邻格,游戏的规则如下： a) 对于处在“生”状态的格,若八个邻居中当前有2个或3个“生命”,则继续保持存活状态,否则在下一个状态，将因过于孤独或过于拥挤而死亡. b) 对于处在“死”态的空格,若八个邻格中有3个“
生命游戏（golly）v3.2安装包
08-10
康威最初认为生命游戏中没有任何图形可以无限增长，但很快高斯帕滑翔机枪（Gosper glider gun）推翻了他的想法。这个图形每15代产生一架滑翔机，无限延续。 （图源：en.wikipedia.org） 复杂振荡器一类里有一个...
空间点像素索引（一）
吴建明wujianming_110117
05-09 591
空间点像素索引（一） 给你一个需求，查找定位点附近的一定范围内所有餐馆，你会怎么实现呢？ 一一计算定位点与所有餐馆的距离，然后取出最小的距离？如果同时有很多遍布全国的请求都在查找附近的餐馆，按照上述的做法，你的服务有能力及时响应么？本文介绍了两种高效的空间点查找方法，并且该方法在打车领域和地图领域有广泛的实际应用。文章很长，如果来不及看完，只需要记得，如果你需要一种高效的空间点索引算法来处理海量的空间点查找需求，那么Geohash和Google S2可以帮助到你。 引论 每天我们晚上加班回家，可能都会用到滴
matlab实现康威生命游戏的代码以及matlab全部版本下载
07-02
我在我的学校的一间教室根据康威游戏规则编写出一份matlab程式叫conway.m 该程式包含了我的编程思路历程,且大部分语句都有我的编程时的注释,希望能有助于看懂我的程式 由于我是第一次编写matlab程序,且时间仓促,导致程序的效率可能不高,特别是遇到大型数组去做循环时会特别耗时 所以如果有更好的实现代码或者建议,请发送到邮箱地址:632999353@qq.com
康威生命游戏C语言并行实现（intrinsics)
01-13
康威生命游戏SIMD版本实现，采用C语言的intrinsics实现并行。支持计算繁殖时间和简单的繁殖过程绘图。编译环境为VS2010.
生命游戏
误入其途
02-11 1136
说明：生命游戏为1970年英国数学家J.H.Conway所提出，某一细胞的邻居包括上、下、左、右、左上、左下、右上、右下，游戏规则如下： 孤单细胞死亡：如果细胞邻居小于一个，则该细胞在下一状态将死亡。 拥挤死亡：如果细胞的邻居在4个以上，则该细胞在下一状态将死亡。 稳定：如果细胞的邻居为二个或三个，则下一状态为稳定存活： 复活：如果某位置原无细胞存活，而该位置的邻居为3个，则该位置将复活一
生命游戏C++
最新发布
weixin_52034407的博客
02-20 636
生命游戏一般指康威生命游戏，是由剑桥大学约翰.何顿.康威设计的计算机程序。生命游戏既没有玩家之间的竞争，也没有输赢，可以归类为仿真游戏。当前细胞为死亡状态时，当周围由3个存活细胞时，迭代后该细胞变成存活状态；生命游戏规定，每个方格可以放置一个生命细胞，而每个生命细胞只有生和死两种状态。当前细胞为存活状态，而周围的邻居细胞小于两个存活时，则细胞死亡；细胞为存活状态，而周围细胞存活数为2或3时，该细胞状态保持不变；当细胞状态为存活状态，而周围存活了大于3个细胞时，则细胞死亡。使用graphics库进行图形化。
讲函数了！C++解细胞分裂，细胞每分裂一次数量增加一倍，分裂了n次，出现了多少个完整的细胞？
zhengheda的博客
09-08 1065
IPO模型分析（IPO模型很重要） IPO模型（第二次说了） （两种代码实现） //代码1:新建变量m的解法 #include <iostream> using namespace std; int main(){ int N; cin >> N; //新建变量m表示当前细胞数 long long sum = 1,m = 1; for(int i = 1;i<= N;++i){ m *= 2...
C语言实现之牛的数量（细胞分裂问题）（利用树实现）
wpggles的专栏
10-18 3923
起因：     老师上课的时候说了一个题：         牛长到3岁可以生小牛，长到9岁后去世，每年可以生一头小牛，最初牛圈中只有一头牛，经过X年后，牛圈里有几头牛？     当我听完之后第一反应，9年以内是一头牛，九年之后就没牛了，有的话也只剩尸体了。牛是哺乳动物，有性生殖，一头牛怎么生啊？我更喜欢称这个问题叫细胞分裂问题，比如说蛙的红细胞就是通过无丝分裂增殖的。不多扯了，还是用牛吧，我
使用C++实现“生命游戏“
m0_72650909的博客
07-09 1947
生命游戏为美国数学家康威设计的计算机程序，它由极其简单的规则衍生出复杂的“生命”，让人不禁想到浩淼的宇宙是否也是如此的优美而简练呢？
细胞分裂模拟
Lesel的博客
09-12 1292
功能：         一种细胞在诞生（即上次分裂）后会在500~2000秒内分裂为两个细胞，每个细胞又按照同样的规律继续分裂。         本程序模拟了细胞分裂的过程，输出了每个细胞分裂的时间。 环境：VS2010。            控制台应用程序。 程序： // cell_split_simulation_use_priority_queue.cpp : 定义控制台应用...
C/C++实现简单生命游戏(Game Of Life)
memcpy0的博客
10-06 6677
文章目录点子-Game of Life实现1. 游戏框架-静止图案2. 动态图案-按规则繁衍死亡 继main函数内部一把梭后，我们进行了模块化改造，但是这样管理游戏数据还是很不好的。加上数组，我们就有能力实现更有意思的游戏，游戏中的一些写法也会改变。 对了，虽然大体上是C实现游戏，但是有的地方写法可能是C++的，建议用.cpp格式运行。我也懒得区分了。 点子-Game of Life 生命游戏是...
生命细胞游戏的C++实现
咚咚怪的博客
10-04 3618
  生命游戏   （游戏作品） 生命游戏是英国数学家约翰·何顿·康威在1970年发明的细胞自动机。它最初于1970年10月在《科学美国人》杂志中马丁·葛登能（Martin Gardner，1914年11月21日－2010年5月22日。又译：马丁·加德纳）的“数学游戏”专栏出现。 中文名 生命游戏 原版名称 Game of Life 其他名称 生命棋 制作人 约翰·何顿·康威...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值