Board logo

标题: 批处理编程竞赛 第2011-001期[Life 游戏] [打印本页]

作者: netbenton    时间: 2011-2-11 20:10     标题: 批处理编程竞赛 第2011-001期[Life 游戏]

上世纪70年代,一些人曾疯迷于一种被称作“生命(life)游戏”的小游戏,这种游戏相当简单。
假设有一个象棋盘一样的方格网,每个方格中放置一个生命细胞,生命细胞只有两种状态:
“生”或“死”。由英国数学家John Conway确定的游戏规则如下:
   (1)如果一个细胞周围有3个细胞为生(一个细胞周围共有8个细胞),则该细胞为生,
    即该细胞若原先为死,则转为生,若原先为生,则保持不变;
   (2)如果一个细胞周围有2个细胞为生,则该细胞的生死状态保持不变;
   (3)在其它情况下,该细胞为死,即该细胞若原先为生,则转为死,若原先为死,则保持不变。
    依此规则进行迭代变化,使细胞生生死死,会得到一些有趣的结果。该游戏之所以被称为生命游戏,
是因为其简单的游戏规则反映了自然界中这样的生存规律:如果一个生命,其周围的同类生命太少的话,
会因为得不到帮助而死亡,如果太多,则会因为得不到足够的生命资源而死亡。
    用计算机模拟这个生命游戏也相当简单,可以用一个M×N象素的图象来代表M×N个细胞,
其中每一个象素,代表一个细胞,象素为黑色表示细胞为生,象素为白色代表细胞为死。
例如一个图象中几个象素所代表的生命的初始状态如下图所示,依上述规则进行行迭代变化,
则经过1次、2次、3次变化后的情况分别如下图所示:
活:■
死:▓

第 1 代
▓■■■▓▓▓▓
▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓
▓▓■■▓▓▓▓
▓■■■▓▓▓▓
▓▓■▓▓▓▓▓
▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓

第 2 代
▓▓■▓▓▓▓▓
▓▓■▓▓▓▓▓
▓▓▓▓▓▓▓▓
▓■▓■▓▓▓▓
▓■▓▓▓▓▓▓
▓■■■▓▓▓▓
▓▓▓▓▓▓▓▓
▓▓■▓▓▓▓▓

第 3 代
▓■■■▓▓▓▓
▓▓▓▓▓▓▓▓
▓▓■▓▓▓▓▓
▓▓■▓▓▓▓▓
■■▓■▓▓▓▓
▓■■▓▓▓▓▓
▓■▓■▓▓▓▓
▓▓▓▓▓▓▓▓


设定图象中每个象素的初始状态后依据上述的游戏规则演绎生命的变化,由于初始状态和迭代次数不同,
将会得到令人叹服的优美图案。

我认为,其实这是一个让程序员练手的游戏,现出一批处理代码效率比赛题:

  1,格子矩阵大小:25 X 25 初始图如下(第1代):
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓▓■■■▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓▓▓
▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓▓■■■▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■▓▓■■■▓▓▓▓▓■■▓▓▓▓▓■■■▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓▓■■■▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓■■▓▓▓▓▓■■▓▓▓▓▓■■
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■▓■■■▓▓▓▓▓■■▓▓▓▓▓■■■▓▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓


  2,顶边与底边,还有左边与右边,认为是相连接的;
        2.1 补充一点:对角点也认为是相连接的,如图点A,周围的8个点,分别对应对角和对边的位置
B■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓cc
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓▓■■■▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓▓▓
▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓▓■■■▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■▓▓■■■▓▓▓▓▓■■▓▓▓▓▓■■■▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓▓■■■▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓■■▓▓▓▓▓■■▓▓▓▓▓■■
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■▓■■■▓▓▓▓▓■■▓▓▓▓▓■■■▓▓▓▓
d■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓d
d■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓Ad
                       ccB


  3,主程序用批处理完成,可用三方命令。但是用纯其它语言编写的游戏,仅仅还原成可执行文件运行的不算
  4,以算到第100代时所花的时间作为本次比赛标准,
       注意:要把每一代结果都显示出来,
  5, 这是很要效率的,可以先写出一个可行的版本,然后慢慢优化;

  6,请参加的朋友于2011-03-07 到 2011-03-10 上传作品,请以附件形式上传
设置阅读权限为240,防止他人抄袭。评比结果最后公布在本楼。

  
    看看谁写的代码速度最快。一个月后(2011-03-13),将给予相应积奖励:
    效率最高的: 100积分 10技术
           第二名:   50积分    5技术
           第三名:   20积分    2技术


终于到公示代码日期了~~~


代码测试环境:
操作系统 WINXP SP3  关闭杀毒软件  不运行任何其它程序
CPU: AMD3200  1G内存DDR677

说明:
    各选手文件夹内的 file.bat 是加入统一的计时后的代码,
选手的原代码为另一个文件,欢迎测试、监督、指正。

公示名次:
获奖名次      选手                大约用时

  第1名       zm900612      00:00:09:65
  第2名      
terse              00:00:14:12
  第3名       caruko           00:00:15:43

其它就不公布了,想了解和监督的朋友请下载附件。






按照料 batcher 所说的方法测试代码,排名并没有变化,

公示三天已过,得出本次竞赛最终结果为:

获奖名次      选手                大约用时

  第1名       zm900612      00:00:09:65
  第2名      
terse              00:00:14:12
  第3名       caruko           00:00:15:43

[ 本帖最后由 netbenton 于 2011-3-15 19:18 编辑 ]
作者: cjiabing    时间: 2011-2-11 21:25

兄弟新年新作品啊!~
先顶一下!~有空玩玩!~
作者: netbenton    时间: 2011-2-12 19:53

这不是我的什么作品,是一个批处理编程竞赛。



本人以 8 X 8 距阵格子试了下,纯批处理也完全可以算出来的。

这次我作为“主考官”就不参加比赛了,希望大家踊跃参加!!!

也欢迎哪位版主出来和我一起搞好这一次竞赛。

[ 本帖最后由 netbenton 于 2011-2-12 20:03 编辑 ]
作者: CrLf    时间: 2011-2-13 00:09

好玩,等待开赛。下面这个月的时间要是有空我也参赛,混个鼓励奖~
作者: CrLf    时间: 2011-2-13 00:13

对了,好像没说不能只用echo...
作者: netbenton    时间: 2011-2-15 12:58

你是说直接 echo 把一百张图显示出来吗?
那当然不算了,我这里给出一张图,只是一个例子,

编写的代码是要能处理同样大小的,任意随机图才行的。
作者: CrLf    时间: 2011-2-15 13:29

那初始图到底是用顶楼的那份呢,还是到评卷的时候临时给的随机图?
作者: HLS    时间: 2011-2-15 14:41

初始图的读入方法是从文件读入吗?
还有,前99张图要不要显示?
作者: netbenton    时间: 2011-2-15 17:56

re HLS

为了统一,就用顶楼的图作为比赛标准(但是比赛代码必须具有同规格的随机图处理能力),每一代都要显示出来,然后清屏显示下一代,可见到动态效果,直到100代时停止。

[ 本帖最后由 netbenton 于 2011-2-15 17:59 编辑 ]
作者: conconcon1    时间: 2011-2-15 19:22

下个月来参拜大作 还没有这个能力
作者: HLS    时间: 2011-2-17 11:30

难道这么大一张图都得塞进批 里面吗?




楼主有没有试过,速度是多少^_^

[ 本帖最后由 HLS 于 2011-2-17 11:31 编辑 ]
作者: 523066680    时间: 2011-2-17 13:29

这个要求解了
第二代中:

第 2 代
▓▓■▓▓▓▓▓
▓▓■▓▓▓▓▓
▓▓▓▓▓▓▓▓
▓■▓■▓▓▓▓
▓■▓▓▓▓▓▓
▓■■■▓▓▓▓
▓▓▓▓▓▓▓▓
▓▓■▓▓▓▓▓


第一代中,后面两行都是空的,第二代的最后一行怎么会生了一个?

[ 本帖最后由 523066680 于 2011-2-17 13:39 编辑 ]
作者: HLS    时间: 2011-2-17 13:42     标题: 回复 12楼 的帖子

最上面和最下面,最左边和最右边是看成相连接的
作者: 523066680    时间: 2011-2-17 14:03

最上面和最下面,最左边和最右边是看成相连接的
假如是2X2那就是这样,为了标识就用不同数字:
  3 4  ---->1
2 1 2 1
4 3 4 3
  1 2 <---来自上面

那么四个顶点也是相连接咯?  1的左上角=4 , 2的右上角=3 。。。。

4 3 4 3
2 1 2 1
4 3 4 3
4 1 2 1

如果是这样的话还真是折腾=。= 自己加一个虚的外围,继续处理

(以上内容仅为猜测,netbenton表示对顶角不相接,我决定去网上找找其他实例看看)


[ 本帖最后由 523066680 于 2011-2-19 11:10 编辑 ]
作者: CrLf    时间: 2011-2-17 17:40

确实折腾...不过我估计最后大家的思路会殊途同归
作者: 523066680    时间: 2011-2-17 22:55

做了,优化了,感觉尽力了。 希望能贴个第100张的正确结果
俺先自己核对一下先 (要是到时候错了就太囧啦)
作者: zhengboy2000    时间: 2011-2-18 22:35

[attach]3491[/attach][attach]3492[/attach]

[ 本帖最后由 zhengboy2000 于 2011-2-18 22:55 编辑 ]
作者: zhengboy2000    时间: 2011-2-18 22:41

[attach]3487[/attach][attach]3488[/attach]

[attach]3489[/attach][attach]3487[/attach][attach]3488[/attach][attach]3489[/attach][attach]3490[/attach]

[ 本帖最后由 zhengboy2000 于 2011-2-18 22:42 编辑 ]
作者: terse    时间: 2011-2-19 03:03

上传到这里吗?               ~
作者: 523066680    时间: 2011-2-19 09:08

怎么你们都喜欢截图呢,纳闷…… 莫非是把批处理跟图片压制在一起上传了?
现在自己贴了一下,用宋体就可以整齐排列啦
我的前四代结果跟 18楼  zhengboy2000 的能对上,跟其他两位一百代不同。
(后来发现我跟其他三位都不同,区别在于对顶角是否相接的问题)

▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓▓■■■▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓▓▓
▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓▓■■■▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■▓▓■■■▓▓▓▓▓■■▓▓▓▓▓■■■▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓▓■■■▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓■■▓▓▓▓▓■■▓▓▓▓▓■■
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■▓■■■▓▓▓▓▓■■▓▓▓▓▓■■■▓▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
第1代 原版


■▓▓▓■▓▓▓■▓▓▓■▓▓▓■▓▓▓■▓▓▓▓
▓■▓▓▓■▓▓▓■▓▓▓■▓▓▓■▓■■▓■▓▓
▓▓▓▓■■▓▓▓▓▓▓■■▓▓▓▓▓▓■▓■▓▓
▓■▓▓▓■▓▓▓▓■▓▓▓■▓▓▓■■▓▓▓▓▓
■▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
■▓▓▓■▓▓▓▓■▓■▓▓▓▓▓■▓■▓▓▓▓▓
▓■▓▓▓▓▓▓■■▓▓▓▓▓▓■■▓■■■▓▓▓
▓▓▓▓▓▓▓▓▓▓▓■■▓▓▓▓▓▓■■■▓▓▓
▓■▓▓▓▓▓▓▓■▓▓▓▓▓▓▓■▓▓▓■▓▓▓
▓■▓▓▓■▓▓▓■▓▓▓■▓▓▓■▓▓▓■▓▓▓
▓▓▓▓■■▓▓▓▓▓▓■■▓▓▓▓▓▓■■▓▓▓
▓■■■▓▓▓▓▓▓■■▓▓■▓▓▓■▓▓▓■▓▓
■▓▓▓■■▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓
■▓▓▓▓■▓▓▓■▓▓▓▓▓▓▓■▓▓▓▓▓▓▓
■▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
■▓▓▓■▓▓▓▓▓▓▓■▓▓▓▓▓▓▓■▓▓▓▓
▓■▓▓▓▓▓▓▓■▓▓▓■▓▓▓■▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■■▓▓▓
▓■▓▓▓▓▓▓▓■▓▓▓▓▓▓▓■▓▓▓■▓▓▓
▓▓▓▓■▓▓▓■▓▓▓▓▓▓▓▓▓▓■▓▓▓▓▓
▓▓▓▓■▓▓▓■▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓■▓▓■▓▓▓■▓▓▓■▓▓▓▓
■▓▓▓▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓■▓▓▓▓
■▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
■▓▓▓■▓▓▓■▓▓▓■▓▓▓■▓▓▓■▓▓▓▓

第2代

■■▓▓■■▓▓■■▓▓■■▓▓■■▓▓■▓▓▓▓
▓▓▓▓▓■▓▓▓▓▓▓▓■▓▓▓▓▓■■▓▓▓▓
▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓■▓▓▓▓
▓▓▓▓▓■▓▓▓▓▓▓▓■▓▓▓▓▓■▓▓▓▓▓
■■▓▓■■▓▓▓▓■▓▓▓▓▓▓▓▓■▓▓▓▓▓
■■▓▓▓▓▓▓■■■▓▓▓▓▓■■▓■▓▓▓▓▓
▓▓▓▓▓▓▓▓■■▓■■▓▓▓■■▓▓▓■▓▓▓
▓▓▓▓▓▓▓▓■■■▓▓▓▓▓■■▓■▓▓■▓▓
▓▓▓▓▓▓▓▓▓▓■▓■▓▓▓▓▓■▓▓■■▓▓
▓▓▓▓■■▓▓▓▓▓▓■■▓▓▓▓▓▓▓■■▓▓
▓■▓■■■▓▓▓▓■■■■■▓▓▓▓▓■■■▓▓
▓■■■▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓■▓▓▓
■▓■■■■▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓
■■▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■
■■▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■
■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■■▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■■▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■▓▓▓
▓▓▓▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■
■■▓▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
第3代




▓■▓■■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓■▓■■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓■■■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■■▓▓▓▓▓▓▓
▓■▓▓▓▓▓■■▓▓■■■▓▓■■▓▓▓▓▓▓▓
■■▓▓▓▓▓▓■▓■■▓▓▓▓▓▓▓▓▓▓▓▓■
■▓▓▓▓▓▓▓▓■■■▓▓▓▓▓▓▓▓▓▓■▓▓
▓▓▓▓▓■■▓▓■■▓▓▓▓▓▓▓▓▓▓■■▓■
▓■▓■▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓■■■▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓■▓
■▓■▓■■■■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■
▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓■▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓■▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓■▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
第100代


[ 本帖最后由 523066680 于 2011-2-19 11:05 编辑 ]
作者: zhengboy2000    时间: 2011-2-19 09:56

在第二代中,红色箭头所指的位置有三个活着的,根据规则(1)如果一个细胞周围有3个细胞为生,则该细胞为生, 即该细胞若原先为死,则转为生,若原先为生,则保持不变;那么到了第三代,绿色箭头所指的细胞应该由死变活。不知道我的理解是否正确?[attach]3494[/attach]
作者: 523066680    时间: 2011-2-19 10:48     标题: 回复 21楼 的帖子

报告,绿色箭头应该不会活
那天我问了netbenton ,
只是上下相接, 左右相接,   两对-对顶角  不相接。 原来我跟你的也不一样。
不过只差一步吧,我这里只要把对顶补上就一样了

  ■▓▓▓■▓▓▓■▓▓▓■▓▓▓■▓▓▓■▓▓▓▓
▓■▓▓▓■▓▓▓■▓▓▓■▓▓▓■▓▓▓■▓▓▓▓■
▓▓■▓▓▓■▓▓▓■▓▓▓■▓▓▓■▓■■▓■▓▓▓
▓▓▓▓▓■■▓▓▓▓▓▓■■▓▓▓▓▓▓■▓■▓▓▓
▓▓■▓▓▓■▓▓▓▓■▓▓▓■▓▓▓■■▓▓▓▓▓▓
▓■▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■
▓■▓▓▓■▓▓▓▓■▓■▓▓▓▓▓■▓■▓▓▓▓▓■
▓▓■▓▓▓▓▓▓■■▓▓▓▓▓▓■■▓■■■▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓■■▓▓▓▓▓▓■■■▓▓▓▓
▓▓■▓▓▓▓▓▓▓■▓▓▓▓▓▓▓■▓▓▓■▓▓▓▓
▓▓■▓▓▓■▓▓▓■▓▓▓■▓▓▓■▓▓▓■▓▓▓▓
▓▓▓▓▓■■▓▓▓▓▓▓■■▓▓▓▓▓▓■■▓▓▓▓
▓▓■■■▓▓▓▓▓▓■■▓▓■▓▓▓■▓▓▓■▓▓▓
▓■▓▓▓■■▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓■
▓■▓▓▓▓■▓▓▓■▓▓▓▓▓▓▓■▓▓▓▓▓▓▓■
▓■▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■
▓■▓▓▓■▓▓▓▓▓▓▓■▓▓▓▓▓▓▓■▓▓▓▓■
▓▓■▓▓▓▓▓▓▓■▓▓▓■▓▓▓■▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■■▓▓▓▓
▓▓■▓▓▓▓▓▓▓■▓▓▓▓▓▓▓■▓▓▓■▓▓▓▓
▓▓▓▓▓■▓▓▓■▓▓▓▓▓▓▓▓▓▓■▓▓▓▓▓▓
▓▓▓▓▓■▓▓▓■▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓■▓▓■▓▓▓■▓▓▓■▓▓▓▓▓
▓■▓▓▓▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓■▓▓▓▓■
▓■▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■
▓■▓▓▓■▓▓▓■▓▓▓■▓▓▓■▓▓▓■▓▓▓绿■
  ■▓▓▓■▓▓▓■▓▓▓■▓▓▓■▓▓▓■▓▓▓▓  



====================================================
我现在还带点自信,不过3:1 却实很鸭梨。 修改对顶角后,100代结果对应其他人了


[ 本帖最后由 523066680 于 2011-2-19 11:02 编辑 ]
作者: zhengboy2000    时间: 2011-2-19 11:20     标题: 回复 20楼 的帖子

如果四角不相邻的话,第100代的确跟您在20楼发布的一样。[attach]3495[/attach]
[attach]3495[/attach]
作者: netbenton    时间: 2011-2-19 11:21

原始图为第1代,


▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■▓
▓▓▓▓▓▓■▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■
▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓■■▓▓▓▓▓
■■▓▓▓▓▓▓■▓▓▓▓▓▓▓▓■▓▓■▓▓■■
■■■▓▓▓■▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓■
▓■▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓■■■▓▓▓▓
▓▓■■▓▓▓▓▓▓■▓▓▓■▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓■▓▓▓▓■▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓■▓▓■▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓■▓■▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
第100代


我原先是没有意思把对角的点作为相连的,因为这样,似乎就会打破“进化规则”了。这点还真的要好好研究下。


没想到自己的算法也是把对角的顶点算连接了,

[ 本帖最后由 netbenton 于 2011-2-19 11:45 编辑 ]
作者: zhengboy2000    时间: 2011-2-19 11:47     标题: 关于对角是否相邻的问题?

根据维基百科 http://en.wikipedia.org/wiki/Conway's_Game_of_Life 的解释,对角应该是相邻的,原文截图如下:
[attach]3496[/attach]
作者: terse    时间: 2011-2-19 11:55

那现在对角的点作为相连的呢?还是忽略它!
作者: 523066680    时间: 2011-2-19 12:04

OK ,就按现在这个结果, 也就是对顶角也影响。
仔细一看terse 那个截图少了第一行。 现在统一了。

到3月7日 的时间还真是……  等待其他人吧
http://gameoflife.free.fr/download_cn.htm
看到这张图,膜拜一下……




================================

我的 Intel Pentium4  516 : 2.93GHz
内存 DDR2 1.3G (插两条,256M+1G)  532MHZ

50秒

[ 本帖最后由 523066680 于 2011-2-19 12:59 编辑 ]
作者: terse    时间: 2011-2-19 12:06

优化了 连续显示 100代 20秒左右
配置  酷睿2 4400 @ 2.00GHz   2 GB DDR2 667MHz  sp3
作者: netbenton    时间: 2011-2-19 12:07

就认为是相连的吧,

关于这点的说明已经在顶楼更新。
还有,比赛代码上传方法,时间,公布时间等,也在一楼。
请大家留意下。

还有发 File 结果图时,无需截图,只需把相应的图文设置为“黑体”字体即可正常显示了

[ 本帖最后由 netbenton 于 2011-2-19 12:09 编辑 ]
作者: 523066680    时间: 2011-2-19 16:30

我把我27楼那个贴图里面的循环,一直往下延续的矩阵拼凑出来了
循环一下,果然挺有趣啊……

▓▓▓■▓▓▓▓▓▓▓▓
▓■▓■▓▓▓▓▓▓▓▓
▓▓■■▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓■▓▓▓▓
▓▓▓▓▓■▓■▓▓▓▓
▓▓▓▓▓▓■■▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓

[ 本帖最后由 523066680 于 2011-2-19 16:32 编辑 ]
作者: zhengboy2000    时间: 2011-2-19 16:38

这个也很NB啊,版主把初始阵列还原一下贴出来就好了。  :-)

作者: 523066680    时间: 2011-2-19 17:30     标题: 回复 31楼 的帖子

是同一个的不同尺寸嘛,你等着

我去啊,我弄了很久,他这个图有交错,跟图对比,害我自己搞对了又搞乱了#@!%……

[ 本帖最后由 523066680 于 2011-2-19 19:06 编辑 ]
作者: 523066680    时间: 2011-2-19 20:41

初始场面,反正是构成循环的
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■▓▓■▓▓▓▓■▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓■■▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■▓■▓▓▓▓▓■■▓▓▓■▓▓▓▓▓▓▓▓■■▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■■▓■▓▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓■■▓▓▓▓▓
▓■■▓▓▓▓▓▓▓▓▓▓▓▓■■▓■■▓▓▓▓▓▓■▓▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓■■▓▓▓▓▓▓▓▓▓▓▓▓■■▓■▓▓▓▓▓▓▓▓■▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
作者: terse    时间: 2011-2-20 12:23

我做了上面的怎么后来是这样的循环
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓■▓▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓■■■▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓■▓▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓■■■▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓■▓▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓■▓▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

作者: 523066680    时间: 2011-2-20 14:49     标题: 回复 34楼 的帖子

我是先抓出了关键部分,也就是能左右跑动,还碰撞产生一个小东西的。
============================================
刚刚再试了一下,要吐血了,模仿图片弄了那么久,结果还只是生成那个小东西=。=
没一会儿就打散了

[ 本帖最后由 523066680 于 2011-2-20 15:03 编辑 ]
作者: terse    时间: 2011-2-22 12:00

为积分  再优化 提升点效率
作者: caruko    时间: 2011-2-22 22:20

忘记设权限了。。
先删掉

[ 本帖最后由 caruko 于 2011-2-22 22:22 编辑 ]
作者: caruko    时间: 2011-2-22 22:25

只用了set for echo 3个命令,效率应该还可以=。=,如果不echo,直接得到第100代就更快一点了。我这里大概2分多钟算出来。
原来不用代码,等下直接贴结果。

第100代
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓■▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓■▓■▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓■■▓▓▓▓▓■▓■▓▓▓▓■■▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓■■▓▓▓▓■■▓■▓▓▓▓▓
▓▓▓▓▓▓▓▓■■▓▓▓▓■■▓▓■■▓▓▓▓▓
▓▓▓▓▓▓▓■▓■▓▓▓■▓▓■▓■■■▓▓▓▓
▓▓▓▓▓▓■■▓▓■■■▓▓▓■▓▓■■▓▓▓▓
▓▓▓▓▓▓▓▓▓▓■■■▓■▓■▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓■▓▓▓▓■▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓■▓■▓▓■▓▓▓▓▓▓▓▓▓▓
▓▓■■▓▓▓▓▓▓■■▓■■▓▓▓▓▓▓▓▓▓▓
▓▓■■▓▓▓▓▓▓▓■▓▓■▓▓▓▓▓▓▓▓▓▓
▓▓■▓▓▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓
▓■▓▓▓▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓
■▓■■▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓■■▓▓▓▓▓■▓▓■▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓■■■▓■▓■■▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓■▓▓■■■■▓▓■▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓■▓■▓▓▓■▓▓■▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓■▓▓▓▓■▓■▓▓▓▓▓▓▓▓▓▓▓


[ 本帖最后由 caruko 于 2011-2-22 23:05 编辑 ]
作者: caruko    时间: 2011-2-22 23:12

代码先上传吧 =。=
到时不知道还记得不,也可能没时间来。
已经更新过,按边角对接算的。

这个代码算法太慢了,已经另写了效率高很多的代码,这个就不设权限了,有意的可以看看。
作者: caruko    时间: 2011-2-22 23:19

=。= 已经按照边角对接修改过了..
输出速度大约是一副图2秒。
不输出的计算速度大约是1.5秒一代。
我的电脑是用了5年的本本,CPU P4M 1.7G的。

效率貌似难以提升了,所有IF判断后再赋值,都是用set /a直接得到结果,效率应该还可以才是。

如果计算中不需要输出,核心循环代码包括FOR(100)的括号在内,可以简化到4行。

[ 本帖最后由 caruko 于 2011-2-23 00:21 编辑 ]
作者: 523066680    时间: 2011-2-23 09:24     标题: 回复 40楼 的帖子

hia hia 那就跟整体机制有关。 继续膜拜某的 带刷屏到100代  20秒 。
也就是0.2一张,我内牛满面……
作者: caruko    时间: 2011-2-23 09:55

=.= 我的电脑纯输出2500行就得20秒啊,等会换个电脑试试。
这破机器开龙之谷,每次加载要5分钟,而别的电脑只要15秒。

还有边角问题,是只有4个顶点相连?还是上下边,左右边相连?

难道批处理的纯数值计算更慢?? 回头再想想有没别的办法,减少循环。
这是新的运行结果。

10:46:41.35
10:48:08.14
第100代
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■▓
▓▓▓▓▓▓■▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■
▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓■■▓▓▓▓▓
■■▓▓▓▓▓▓■▓▓▓▓▓▓▓▓■▓▓■▓▓■■
■■■▓▓▓■▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓■
▓■▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓■■■▓▓▓▓
▓▓■■▓▓▓▓▓▓■▓▓▓■▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓■▓▓▓▓■▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓■▓▓■▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓■▓■▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓


[ 本帖最后由 caruko 于 2011-2-23 10:52 编辑 ]
作者: terse    时间: 2011-2-23 11:03

运行速度和机器配置有关 我的 酷睿2 4400 @ 2.00GHz   2 GB DDR2 667MHz  sp3  现在运行 17秒
我相信 继续优化后 速度还可以提升的
作者: wayaoqiang    时间: 2011-2-23 14:01

稍微参与下,呵呵, 我贴下我的关键算法, 很菜, 转成批处理速度应该很慢吧
  1. for (i = 0; i < N; ++i)
  2. for (j = 0; j < N; ++j) {
  3. sum = list[(i+1+N)%N][(j+N)%N] + list[(i-1+N)%N][(j+N)%N] + list[(i+N)%N][(j+1+N)%N] + list[(i+N)%N][(j-1+N)%N];
  4. sum += list[(i+1+N)%N][(j+1+N)%N] + list[(i+1+N)%N][(j-1+N)%N] + list[(i-1+N)%N][(j-1+N)%N] + list[(i-1+N)%N][(j+1+N)%N];
  5. switch (sum) {
  6. case 2://不变
  7. backUp[i][j] = list[i][j]; break;
  8. case 3://生
  9. backUp[i][j] = 1; break;
  10. default://死
  11. backUp[i][j] = 0; break;
  12. }
  13. }
  14. for (i = 0; i < N; ++i)
  15. for (j = 0; j < N; ++j)
  16. list[i][j] = backUp[i][j];
复制代码

作者: caruko    时间: 2011-2-23 15:50

猜想,17秒*25,扣除输出时间,大约是我的运行时间,terse 可能一次计算只循环了25次。。
也就是一行一行的处理?
我也想想,有没可能做到。

[ 本帖最后由 caruko 于 2011-2-23 15:53 编辑 ]
作者: caruko    时间: 2011-2-23 16:19

=.=  仔细一想,经过验证,果然一行一行的计算可行,依靠4次移位来计算细胞和,循环25次得到和,再循环25次替换得到新细胞图。
不知道是不是terse一样的算法,等写出代码试试效率。

呃,不支持近30位的数值计算=。=,难道要切成4段算?

[ 本帖最后由 caruko 于 2011-2-23 16:52 编辑 ]
作者: caruko    时间: 2011-2-23 22:17

换了一种算法,破电脑跑了1分钟,换台双核的应该在40多秒,小有进步=。=

循环代码行数40行 #.#,算法不复杂,只可惜批处理不支持26个字符长度的数值计算,也还没找到好的大数计算方法,目前是把25位数分成4段处理的,导致多出大量的字符数值转换跟计算。

如果支持大数计算,可以节省1/3的时间,如果支持BIT(OR),还能节省1/3时间。

我再优化优化,还有某些地方得出的数值可重用,应该可以节省10多秒。 现在才迫切希望换成64位机来运行它 =.=。

[ 本帖最后由 caruko 于 2011-2-23 22:54 编辑 ]
作者: 523066680    时间: 2011-2-24 00:00     标题: 回复 47楼 的帖子

somebody总是在预想设备好的情况,
此处当我没说过   

[ 本帖最后由 523066680 于 2011-2-24 08:50 编辑 ]
作者: caruko    时间: 2011-2-24 00:09

优化了代码,运行时间大幅提升,电脑好点,或许可以进入20秒内了。如果能够直接支持26位长度的大数加法,估计只要15秒不到。
下面是运行结果。

第99代
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■▓▓▓■▓
▓▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓■▓■
▓▓▓▓▓▓■■■▓▓▓▓▓▓▓▓▓■▓▓▓▓▓■
■▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓■▓■■▓▓■■
▓■■▓■■■▓▓▓▓■■▓▓▓▓▓■■■▓▓▓▓
▓▓■■■■▓▓▓▓▓■■▓▓▓▓▓▓■▓▓▓▓▓
▓▓▓■▓▓▓▓▓▓■■■■■▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓■■▓■▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓■▓■▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■▓▓▓▓▓
第100代
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■▓
▓▓▓▓▓▓■▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■
▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓■■▓▓▓▓▓
■■▓▓▓▓▓▓■▓▓▓▓▓▓▓▓■▓▓■▓▓■■
■■■▓▓▓■▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓■
▓■▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓■■■▓▓▓▓
▓▓■■▓▓▓▓▓▓■▓▓▓■▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓■▓▓▓▓■▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓■▓▓■▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓■▓■▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
0:05:11.00--> 0:05:36.46


[ 本帖最后由 caruko 于 2011-2-24 00:10 编辑 ]
作者: caruko    时间: 2011-2-24 00:44

我的第一个算法是最普遍的,前面那个贴出C代码的算法=。=
只不过我用了大量诸如
判断超标
set /a "x=^!(%%x-1)*25+(%%x-1)" ,当X-1等于0,就让X=25,否着不变。
set /a "x=^!(%%x+1-26)+^!^!(%%x+1-26)*(%%x+1)" 当x+1等于26,就让X=1,否着不变。

重新赋值
set /a "new=^!(sum-3) | ^!(sum-2) * !old!"  ::sum=3,new=1; sum=2,new=old; else new=0
但最后发现,|  之前的可以提速,| 之后的计算,没有比if判断快。

第二个算法是猜想terse的效率,估计他是一行一行处理的,而不是每个坐标都处理。效率提升几十倍只能这么做。
作者: caruko    时间: 2011-2-24 18:54     标题: 参赛代码

突然发现结果竟然是错误的。
奇怪,修改了下。这楼删了。
上传的后面跟贴。

[ 本帖最后由 caruko 于 2011-3-8 20:58 编辑 ]
作者: wankoilz    时间: 2011-2-26 11:27

大概要25秒的样子(CPU:T5800 双核 2G,内存 1G ,Win7旗舰版)
第一代:
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓▓■■■▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓▓▓
▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓▓■■■▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■▓▓■■■▓▓▓▓▓■■▓▓▓▓▓■■■▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓▓■■■▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓■■▓▓▓▓▓■■▓▓▓▓▓■■
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■▓■■■▓▓▓▓▓■■▓▓▓▓▓■■■▓▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓
▓■■■▓▓▓▓▓■■■▓▓▓▓▓■■■▓▓▓▓▓

11:20:18.96
第100代:
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■▓
▓▓▓▓▓▓■▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓■
▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓■■▓▓▓▓▓
■■▓▓▓▓▓▓■▓▓▓▓▓▓▓▓■▓▓■▓▓■■
■■■▓▓▓■▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓■
▓■▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓■■■▓▓▓▓
▓▓■■▓▓▓▓▓▓■▓▓▓■▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓■▓▓▓▓■▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓■▓▓■▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓■▓■▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓■▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓

11:20:43.68
作者: terse    时间: 2011-2-26 11:46     标题: 回复 50楼 的帖子

算法应该差不多吧  这样应该简单点吧  set/a i=^!^!(%%i%%25)*%%i+1
作者: CrLf    时间: 2011-3-1 16:03

看来我连鼓励奖都拿不到了,杯具的三分钟,心都凉了...
作者: CrLf    时间: 2011-3-1 16:14

设想过转换成二进制进行位运算,也想过从格雷码获取灵感,甚至还想过穷举3个四位数(后三位不是0就是1)相加的所有可能,最终都没用上,还是用了最笨的办法...
数学和编程基础差,实在不擅长这种数学游戏式的批处理编程,期盼比赛结束时看各位高手的代码,学习学习,借鉴借鉴。
作者: CrLf    时间: 2011-3-2 23:06

终于发现100张图只要20秒的秘密了,简直让人无语至极...
作者: caruko    时间: 2011-3-3 00:36

我之前那个算2分多钟的代码,跟现在16秒的代码,实际算法差不了太多,计算量最多差个2-3倍,没有增加到十倍以上的程度。
但是现在的效率我自己也没想到,只能说,效率跟批处理的特性有关。
换一个语言来写,绝对没有这么大差距,甚至可能在批处理中算的慢的会更快。
作者: CrLf    时间: 2011-3-3 22:44     标题: 回复 43楼 的帖子

配置相近,不过我不是xp。改到现在,也在18秒上下徘徊,看来再改进下算法有希望争个第二第三
作者: netbenton    时间: 2011-3-7 07:39     标题: 上传作品提示

从今天起可以上传参赛作品了。
3月10日 23:59:59 以后上传的作品无效,以贴子最后的修改时间为准。

请再大家要看清楚一楼的参赛代码实现的标准

参赛回贴标题统一为:“参赛贴”
请参赛的朋友以附件形式上传,并设置阅读权限为240

3月11日~3月12日 会将所有参赛代码整理到顶楼,同时给出统一环境下的运行时间,并公示两天,

3月15日前,公布获奖名单。并兑现相应奖励。

[ 本帖最后由 netbenton 于 2011-3-7 07:47 编辑 ]
作者: 523066680    时间: 2011-3-7 08:44

哦哈哈, 速度最慢的人来啦,应该不会有人走同一条路线的。
这条路线贴矩阵倒是很方便。
时间50秒以上 ,  所以就没什么必要限制了。
作者: xiaoshiwei    时间: 2011-3-7 11:15     标题: 支持这样的赛事

虽然俺是小菜
        精神上支持一下

这样子的赛事会提高大家学习的兴趣
作者: terse    时间: 2011-3-7 11:57

稍改下 不见得快
作者: CrLf    时间: 2011-3-7 16:18

基于不同算法的能都交上吗?还是说一人只能交一份
作者: netbenton    时间: 2011-3-7 20:01     标题: re zm900612

一人只有一份有效,请选择运行速度最快的上传,
作者: CrLf    时间: 2011-3-7 21:22

明白了,有点为难,四种算法,各有优劣,还是慢慢挑吧...
追问一下,能否描述一下测试环境?比如:cpu频率?没运行cmd时的cpu空闲值是多少?测试时是同时运行多个bat呢还是一次只测一个呢?
希望比对一下,因为手上的几份代码对环境的依赖程度各异
作者: netbenton    时间: 2011-3-8 13:41     标题: re 楼上

zm900612 研究得还真仔细。

当然是要尽量的排除干扰的。

如果真的有两份代码运行时间很相近,只是因为cpu 的不同,或都操作系统的不同,而有先后变化的话,那就在每种环境下都运行一次,以时间之和来定胜负吧

[ 本帖最后由 netbenton 于 2011-3-8 13:44 编辑 ]
作者: CrLf    时间: 2011-3-8 13:52

好吧,那我提交最保守的方案好了。本想今天交的,但不巧又想到新算法,嘿嘿
作者: caruko    时间: 2011-3-8 21:02     标题: 参赛帖

修改了一下,以前是自己直接按图来赋值,改为读取原始图赋值,这样应该正规公平一些吧。
作者: CrLf    时间: 2011-3-9 13:02     标题: 参赛帖

尽人事,听天命,如此而已。

[ 本帖最后由 zm900612 于 2011-3-10 22:31 编辑 ]
作者: CrLf    时间: 2011-3-9 17:23

原来下载自己的附件不受权限约束啊...
作者: netbenton    时间: 2011-3-10 21:37     标题: 上传作品提醒

今是最后一天上传了,还有参赛作品没上传的朋友,请抓紧时间了。

3月10日 23:59:59 以后上传的作品无效,以贴子最后的修改时间为准。

请再大家要看清楚一楼的参赛代码实现的标准

参赛回贴标题统一为:“参赛贴”
请参赛的朋友以附件形式上传,并设置阅读权限为240

3月11日~3月12日 会将所有参赛代码整理到顶楼,同时给出统一环境下的运行时间,并公示两天,

3月15日前,公布获奖名单。并兑现相应奖励。

作者: cutebe    时间: 2011-3-10 22:52     标题: 参赛贴

也参加一下,不过挺慢的。
作者: netbenton    时间: 2011-3-11 21:20     标题: 公示参赛代码提示

参赛代码已经公示在一楼了,

公示两天后,若没有疑义,将兑现相应奖励。

初定获奖名单也已经出来了,欢迎大家的测评、监督、指正

代码的效率有点出乎意料之外,只是参赛的代码少了点,看来论坛还是不够活跃呀~

希望下次能看到更多的人参与~~~
作者: Batcher    时间: 2011-3-11 21:25     标题: 回复 73楼 的帖子

前三名的代码,每运行一个就重启一遍系统,这样得出的时间会不会更公平?
作者: CrLf    时间: 2011-3-12 11:46

呵呵,果然有前三,不负我多日幸苦。其实也属侥幸,算法效率估计大家差不了多少,速度快慢最终还是取决于整体性能
作者: caruko    时间: 2011-3-12 15:47

zm的果然很快啊
其实也知道25行的数据很多地方都是重复的,可以重复利用的地方非常多,然而想高重复利用起来计算的复杂度又变高,效率不一定更好,一直没有更好的解决办法,就那样了。
作者: netbenton    时间: 2011-3-15 19:16

按照料 batcher 所说的方法测试代码,排名并没有变化,

公示三天已过,得出本次竞赛最终结果为:

获奖名次      选手                大约用时

  第1名       zm900612      00:00:09:65
  第2名      
terse              00:00:14:12
  第3名       caruko           00:00:15:43



***  顶楼已经更新  ***
作者: a20150604    时间: 2020-8-18 13:44

本帖最后由 a20150604 于 2020-8-18 13:52 编辑

John Horton Conway (26 December 1937 – 11 April 2020)
His wife, Diana Conway, said his death, at a nursing home, was caused by Covid-19.


https://www.nytimes.com/2020/04/ ... ad-coronavirus.html

https://en.wikipedia.org/wiki/John_Horton_Conway





作者: Gin_Q    时间: 2020-12-23 17:51

本帖最后由 Gin_Q 于 2020-12-23 21:32 编辑
  1. # coding=utf-8
  2. # 更新窗口
  3. def upWindow():
  4.     global SHEET
  5.     for i in range(1,WIDTH-1):
  6.         for j in range(1,WIDTH-1):
  7.             print(SHEET[i][j], end='', flush=True)
  8.         print()
  9. # 计算
  10. def death(status, res):
  11.     global SHEET
  12.     global DATA
  13.     global WIDTH
  14.     global A
  15.     global B
  16.     for i in range(1,WIDTH-1):
  17.         for j in range(1,WIDTH-1):
  18.             # 检查
  19.             if SHEET[i][j] == status:
  20.                 if check(i,j) in res:
  21.                     DATA.append((i,j))
  22.                     
  23.     # 取出数据
  24.     if status == B: status = A
  25.     elif status == A: status = B
  26.     for n in DATA:
  27.         SHEET[n[0]][n[1]] = status
  28.     DATA.clear()
  29.     upSide()
  30.     upWindow()
  31.    
  32. # 检查周围点活着的数量
  33. def check(x, y):
  34.     global SHEET
  35.     global A
  36.     count = 0
  37.     if SHEET[x-1][y] == A:
  38.         count += 1
  39.     if SHEET[x-1][y-1] == A:
  40.         count += 1
  41.     if SHEET[x-1][y+1] == A:
  42.         count += 1
  43.     if SHEET[x][y+1] == A:
  44.         count += 1
  45.     if SHEET[x][y-1] == A:
  46.         count += 1
  47.     if SHEET[x+1][y-1] == A:   
  48.         count += 1
  49.     if SHEET[x+1][y] == A:   
  50.         count += 1
  51.     if SHEET[x+1][y+1] == A:   
  52.         count += 1
  53.     return count
  54. # 更新表格边框
  55. def upSide():
  56.     global SHEET
  57.     global WIDTH
  58.     # 交换‘四边’数据
  59.     for n in range(1,WIDTH-1):
  60.         SHEET[0][n] = SHEET[WIDTH-2][n]
  61.         SHEET[WIDTH-1][n] = SHEET[1][n]
  62.         SHEET[n][0] = SHEET[n][WIDTH-2]
  63.         SHEET[n][WIDTH-1] = SHEET[n][1]
  64.     # 角落
  65.     SHEET[0][0] = SHEET[WIDTH-2][WIDTH-2]
  66.     SHEET[WIDTH-1][WIDTH-1] = SHEET[1][1]
  67.     SHEET[0][WIDTH-1] = SHEET[WIDTH-2][1]
  68.     SHEET[WIDTH-1][0] = SHEET[1][WIDTH-2]
  69. # main
  70. # 生
  71. A = '■'
  72. # 死
  73. B = '▓'
  74. # 表格宽度
  75. WIDTH = 10
  76. # 表格列表
  77. SHEET = []
  78. # 数据暂存队列
  79. DATA = []
  80. # 初始化数据
  81. for n in range(WIDTH):
  82.     if n in [1,5]:
  83.         SHEET.append([B,B,A,A,A,B,B,B,B,B])
  84.     if n in [0,2,3,7,8]:
  85.         SHEET.append([B,B,B,B,B,B,B,B,B,B])
  86.     if n == 4:
  87.         SHEET.append([B,B,B,A,A,B,B,B,B,B])
  88.     if n == 6:
  89.         SHEET.append([B,B,B,A,B,B,B,B,B,B])
  90.     if n == 9:
  91.         SHEET.append([B,B,A,A,A,B,B,B,B,B])
  92. upWindow()
  93. count = 1
  94. while True:
  95.     print(f'第{count}次繁衍')
  96.     death(B, [3])
  97.     print(f'第{count}次死亡')
  98.     death(A, [0,1,4,5,6,7,8])
  99.     if count >= 6:break
  100.     count += 1
复制代码
这个步骤是先计算生,还是先计算死?
然后当前点 生了(死了)以后,是不是实时更新的呢(会影响下一个点,下一个点将计算前面那个点的状态)?
有些不解!
我计算的结果和给出答案有误!

# 四边是计算的缓存数据,请忽略
[attach]12964[/attach]
▓▓▓▓▓▓▓▓▓▓
▓▓■■■▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓
▓▓▓■■▓▓▓▓▓
▓▓■■■▓▓▓▓▓
▓▓▓■▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓
▓▓■■■▓▓▓▓▓

第一次繁衍
▓▓▓■▓▓▓▓▓▓
▓▓■■■▓▓▓▓▓
▓▓▓■▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓
▓▓■■■▓▓▓▓▓
▓▓■■■▓▓▓▓▓
▓▓■■■▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓
▓▓▓■▓▓▓▓▓▓
▓▓■■■▓▓▓▓▓

第一次死亡
▓▓▓■▓▓▓▓▓▓
▓▓■▓■▓▓▓▓▓
▓▓▓■▓▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓
▓▓■▓■▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓
▓▓■▓■▓▓▓▓▓
▓▓▓▓▓▓▓▓▓▓
▓▓▓■▓▓▓▓▓▓
▓▓■▓■▓▓▓▓▓

# 无计算缓存
▓■■■▓▓▓▓
▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓
▓▓■■▓▓▓▓
▓■■■▓▓▓▓
▓▓■▓▓▓▓▓
▓▓▓▓▓▓▓▓
▓▓▓▓▓▓▓▓

第一次繁衍
▓■■■▓▓▓▓
▓▓■▓▓▓▓▓
▓▓▓▓▓▓▓▓
▓■■■▓▓▓▓
▓■■■▓▓▓▓
▓■■■▓▓▓▓
▓▓▓▓▓▓▓▓
▓▓■▓▓▓▓▓

第一次死亡
▓■▓■▓▓▓▓
▓▓■▓▓▓▓▓
▓▓▓▓▓▓▓▓
▓■▓■▓▓▓▓
▓▓▓▓▓▓▓▓
▓■▓■▓▓▓▓
▓▓▓▓▓▓▓▓
▓▓■▓▓▓▓▓





欢迎光临 批处理之家 (http://bbs.bathome.net/) Powered by Discuz! 7.2