Question

请用C++编这个 我还会追加的

目标
实现一个简单的科学分析程序：“生命”。

内容
在这个程序中，玩家有一块地。
设计并初始化一个播种模式，即在一块地中种一些种子，每一粒种子占一个格子。这时称为第1代。
+ + + + + + + +
+ + + + + + @ +
+ + + + @ @ + +
+ + + + + + + +

每个种子有八个邻居。在第n+1代，每个格子是空还是被新的种子占据依赖于它们在第n代时的状态：
生存：有两个或三个邻居的种子将存活到下一代，即仍然占据该格子；
死亡：如果有四个或更多的邻居，种子将因为过度拥挤而死亡；如果种子只有一个或零个邻居，将因为孤独而死亡；
繁殖：如果一个空格子有三个邻居，那么将会长出一粒新种子。
+ + + + + + + +
+ + @ + + @ + +
@ @ + + + @ + +
+ + + + + + + +

一种模式在经过若干代之后有以下四种可能的结局之一：
消亡；
不变——静态；
振荡——在一组模式间循环多次后在相同的位置出现相同的模式；
滑动——在一组模式间循环多次后在不同的位置出现相同的模式。
+ + + + + + + + + + + +
+ + @ + + @ + + + + + +
@ @ + + + @ + + + + + +
+ + + + + + + + + + + +
1 2 3(die)

要求
允许用户指定初始的模式或计算机自动创建初始的模式；
显示进化的过程，即历代模式；
要求至少能判断出第一种结局；
当模式消亡就停止进化，或者提示用户是否继续显示下一代，或开始新的案例，抑或退出。

注释
可用一个n*n的矩阵表示模式：
+ + + + + + + + + + + +
+ + @ + + @ + + + + + +
@ @ + + + @ + + + + + +
+ + + + + + + + + + + +
1 2 3(die)

Answer 1

程序设定最大空格数为1000*1000，这个不是很好，有可能溢出也有可能内存浪费，最好使用链表，不过比较麻烦了，偷个懒。编程环境是VS2008，如果编译器不识别，就去掉stdafx头文件，再把主函数改为正常的就可以了。
// seed.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include <cstdlib>
#include <time.h>
using namespace std;
int seed[1000][1000]={0},n; //定义最大的小格数组,并初始化
int tem[1000][1000];
void select_pattern(); //声明选择模式的函数
void man_pattern(); //声明人工初始化函数
void auto_pattern(); //声明计算机随机初始化函数
void print_seed();//声明输入空地情况的函数
int neighbour_count(int,int),generation; //声明计算每个种子有几个邻居的函数
void seed_development(); //声明种子的发展情况的函数
int is_dead(); //声明判断是否消亡的函数

int _tmain(int argc, _TCHAR* argv[])
{

select_pattern();
seed_development();
system("pause");
return 0;
}

void select_pattern() //定义选择模式的函数
{
cout<<"请输入正整数n，用来表示共有n*n个小格:";
cin>>n;
int pattern;
do
{
cout<<endl<<"人工指定初始模式请输入1，计算机自动生成请输入2:";
cin>>pattern;
if(pattern==1) //人工初始化空地
man_pattern();
if(pattern==2)
auto_pattern(); //电脑随机初始化
} while((pattern!=1)&&(pattern!=2));
print_seed();
}

void man_pattern() //人工初始化空地函数
{
cout<<"人工初始化，空地的模型如下："<<endl<<endl;
for(int i=0;i<=n-1;i++) //输出空地模型
{
for(int j=0;j<=n-1;j++)
cout<<"+";
cout<<endl;
}
cout<<endl<<endl;
int x,y;
do
{
cout<<"请输入要栽种种子的坐标，左上角的坐标设为（0，0），输入（-1，-1）停止输入: ";
cin>>x>>y; //输入种子所在的位置
if(x==-1&&y==-1)
break;
seed[x][y]=1;
} while(1);
cout<<endl<<endl;
}

void auto_pattern() //定义自动初始化的函数
{
srand((unsigned)time(NULL));
for(int i=0;i<=n-1;i++)
for(int j=0;j<=n-1;j++)
seed[i][j]=rand()%2;
}

void print_seed() //定义输出空地情况的函数
{
for(int i=0;i<=n-1;i++)
{
for(int j=0;j<=n-1;j++)
if(seed[i][j]==0)
cout<<"+";
else
cout<<"@";
cout<<endl;
}
}

int neighbour_count(int x,int y) //定义计算种子邻居个数的函数
{
int count=0;
for(int i=x-1;i<=x+1;i++)
{
for(int j=y-1;j<=y+1;j++)
if((i>=0&&i<=n-1)&&(j>=0&&j<=n-1))
if(seed[i][j]==1)
count++;
}
if(seed[x][y]==1)
count-=1;
return count;
}

void seed_development() //定义种子的发展情况的函数
{
int flag;
cout<<endl<<endl;
generation=1; //初始化繁殖的代数
while(is_dead())
{
flag=0;
for(int i=0;i<=n-1;i++)
for(int j=0;j<=n-1;j++)
tem[i][j]=seed[i][j];
for(int i=0;i<=n-1;i++)
{
for(int j=0;j<=n-1;j++)
{
int count=neighbour_count(i,j);
if(seed[i][j]==1)
{
if(count==2||count==3)
continue;
else if(count>=4)
tem[i][j]=0;
else if(count==0||count==1)
tem[i][j]=0;
}
else if(count==3)
tem[i][j]=1;

}
}
for(int i=0;i<=n-1;i++)
for(int j=0;j<=n-1;j++)
if(seed[i][j]!=tem[i][j])
{
flag=1;
seed[i][j]=tem[i][j];
}
cout<<"第"<<generation<<"子代:"<<endl<<endl;
generation++;
if(flag==0)
cout<<"进入震荡模式"<<endl<<endl;
print_seed();
cout<<endl<<endl;

cout<<"请选择操作，1产生下一代，2重新开始实验，3结束: ";
int user;
do
{
cin>>user;
if(user==1)
break;
else if(user==2)
{
generation=1;
select_pattern();
}
else if(user==3)
exit(0);
} while(user!=1&&user!=2&&user!=3);

}
cout<<"注意已经进入进入消亡模式"<<endl<<endl;
cout<<"请选择操作，1重新开始实验，2结束: ";
int user;
do
{
cin>>user;
if(user==1)
{
generation=1;
select_pattern();
}
else if(user==2)
exit(0);
} while(user!=1&&user!=2);
}

int is_dead() //定义判断是否消亡的函数
{
int flag=0;
for(int i=0;i<=n-1;i++)
for(int j=0;j<=n-1;j++)
if(seed[i][j]!=0)
{
flag=1;
break;
}
return flag;
}

Answer 2

mark

Answer 3

You can search for "artificial life".
I have read it in a book(but forgot its name).

Answer 4

这个挺好玩的，想起了遗传学算法，mark一下

Answer 5

#include<iostream>
#include<time.h>
using namespace std;

class field
{
private:
char *a;
char *group;
int M,N;
int generation;
int neighbors(int m,int n)
{
int x,y,z,w,i,j,c=0;
x=0>m-1?0:m-1;
y=m+1<M-1?m+1:M-1;
z=0>n-1?0:n-1;
w=n+1<N-1?n+1:N-1;
for(i=x;i<=y;i++)
for(j=z;j<=w;j++)
if(a[i*N+j])
c++;
return c;
}
void showfield1(int n)
{
int i,j;

cout<<" ";
for(j=0;j<N;j++)
cout<<"-";
cout<<" \n";

for(i=0;i<M;i++)
{
cout<<"|";
for(j=0;j<N;j++)
{
if(group[n*M*N+i*N+j])
cout<<"*";
else
cout<<" ";
}
cout<<"|"<<endl;
}

cout<<" ";
for(j=0;j<N;j++)
cout<<"-";

}
public:
field(int m, int n)
{
generation=0;
srand(time(NULL));
M=m;
N=n;
a=(char *)malloc(M*N);
memset(a,0,M*N);
}
field(int m, int n,int seed)
{
generation=0;
srand(time(NULL));
M=m;
N=n;
a=(char *)malloc(M*N);
randomseed(seed);
}

field(int m, int n,char * str)//用字符串初始化田地1代表有，其余代表无
{
generation=0;
int j=0;
srand(time(NULL));
M=m;
N=n;
a=(char *)malloc(M*N);
memset(a,0,M*N);
if(strlen(str)==M*N)
{
while(*(str+j))
{
if(*(str+j)=='1')
a[j]=1;
}
}
}

void randomseed(int seed)
{
int i;
memset(a,0,M*N);
for(i=0;i<seed;i++)
*(a+rand()%(M*N))=1;
}

char putseed(int m,int n)
{
if(m>=0&&m<M&&n>=0&&n<N)
{
a[m*N+n]=1;
return true;
}
else;
return false;
}

char removeseed(int m,int n)
{
if(m>=0&&m<M&&n>=0&&n<N)
{
a[m*N+n]=1;
return true;
}
else
return false;
}

void evolve(void)
{
generation++;
char *b=(char *)malloc(M*N);
int i,j,n;
for(i=0;i<M;i++)
{
for(j=0;j<N;j++)
{
n=neighbors(i,j);
if(a[i*N+j])
{
//live
if(n==3||n==2)
b[i*N+j]=1;
//extinct
else if(n>=4||n==1||n==0)
b[i*N+j]=0;
}
//breed
else if(n==3)
b[i*N+j]=1;
}
}
}
void showfield(void)
{
int i,j;
system("cls");
cout<<"这是第"<<generation<<"代:"<<endl<<endl;
cout<<" ";
for(j=0;j<N;j++)
cout<<"-";
cout<<" \n";

for(i=0;i<M;i++)
{
cout<<"|";
for(j=0;j<N;j++)
{
if(a[i*N+j])
cout<<"*";
else
cout<<" ";
}
cout<<"|"<<endl;
}

cout<<" ";
for(j=0;j<N;j++)
cout<<"-";

}
int countplants(void)
{
int i,j,s=0;
for(i=0;i<M;i++)
for(j=0;j<N;j++)
if(a[i*N+j])
s++;
return s;
}

void stat(int pre, int max)
{ //先进化pre次，然后开始记录max次，最后分析是那种稳态

int area=M*N;
int i,j;
bool bb=true;
group=(char *)malloc(M*N*max);
for(i=0;i<pre;i++)
{
evolve();
}
for(i=0;i<max;i++)
{
memmove(group+area*i,a,area);
evolve();
}
//分析消亡模式
for(i=0;i<M*N;i++)
{
if(group[area*(max-1)+i])
{
bb=false;
break;
}
}
if(bb)
{
cout<<"消亡模式"<<endl;
return;
}

//分析不变模式
if(memcmp(group+area*(max-1),group+area*(max-2),area)==0)
{
cout<<"最后2种形态完全相同，不变模式"<<endl;
//打印最终形态
showfield1(max-1);
system("pause");
}
//从最后开始找，先分析是否循环模式
for(i=max-2;i>=0;i--)
if(memcmp(group+area*(max-1),group+area*i,area)==0)
{

if(max-1-i==1)
break;
cout<<"循环模式，循环节为:"<<max-1-i<<endl;
//打印最终形态
showfield1(max-1);
system("pause");
break;
}
}

//滑动模式不可能出现，因为进化不是随机的，不判断

};

void main()
{
field a(10,10,10);
a.showfield();
a.stat(100,100);

}