代码高尔夫：康威的人生游戏

挑战：写出执行约翰·H·康威的生命元胞自动机游戏的最短程序。 [ 链接 ]

编辑：经过大约一周的比赛，我select了一个胜利者： pdehaan ，用perl打败了一个字符的Matlab解决scheme。

对于那些没有听说过“生命之游”的人，你会select一个网格（理想上是无限的）方格。 细胞可以活着（充满）或死（空）。 我们通过应用以下规则来确定哪些单元格在下一个时间点处于活动状态：

1. 任何有两个活着的邻居的活细胞都会死亡，好像是由于人口不足造成的。
2. 任何有三个以上活着的邻居的活细胞就会死亡，好像过度拥挤一样。
3. 任何有两三个活着的邻居的活细胞都活在下一代。
4. 任何死细胞与三个活的邻居成为一个活细胞，仿佛通过复制。

您的程序将读取一个40×80字符的ASCII文本文件作为命令行参数，以及要执行的迭代次数（N）。 最后，输出到ASCII文件out.txt N次迭代后的系统状态。

这是一个运行相关文件的例子：

in.txt：

................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ..................................XX............................................ ..................................X............................................. .......................................X........................................ ................................XXXXXX.X........................................ ................................X............................................... .................................XX.XX...XX..................................... ..................................XX...XX................................... ..................................XX.....X.................................... ...................................X.......XX................................... ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ 

迭代100次：

 Q:\>life in.txt 100 

结果输出（out.txt）

 ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ..................................XX............................................ ..................................XX.......................................... ....................................X........................................... ................................XXXXX.XX........................................ ................................X.....X......................................... .................................XX.XX...XX..................................... ..................................XX...XX................................... ..................................XX.....X.................................... ...................................X.......XX................................... ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ ................................................................................ 

规则：

• 您需要使用文件I / O来读取/写入文件。
• 你需要接受一个input文件和迭代次数作为参数
• 您需要以指定的格式生成out.txt（如果存在则覆盖）
• 你不需要处理董事会的边缘（环绕，无限网格等）
• 编辑：你需要在你的输出文件中有换行符。

获胜者将由字符数决定。

祝你好运！

Answer 1

perl，127 129 135个字符

pipe理剥离更多的字符…

 $/=pop;@b=split'',<>;map{$n=-1;@b=map{++$n;/ /?$_:($t=grep/X/,@b[map{$n+$_,$n-$_}1,80..82])==3|$t+/X/==3?X:'.'}@b}1..$/;print@b 

Answer 2

Mathematica – 179 163 154 151字符

     a = {2,2,2};
     s =导出[“out.txt”， 
        CellularAutomaton [{224，{2，{a，{2,1,2}，}}，{1,1}}， 
                 （ReadList [＃1，Byte，RecordLists→2> 1]  -  46）/ 42，＃2] [＃2 =
        /。  {0→“。”，1→“X”}，“表”

为了便于阅读，添加了空格

用…调用

  s["c:\life.txt", 100] 

animation：

你也可以得到一段时间内平均人口的图表：

从维基百科生成滑翔机的一个很好的模式

AFAIK Mathematica使用细胞自动机来使用规则30 生成随机数 。

Answer 3

MATLAB 7.8.0（R2009a） – 174 171 161 150 138 131 128 124个字符

函数语法：（124个字符）

以下是易于阅读的版本（为了更好的格式，添加了不必要的换行符和空格）：

 function l(f,N), b=char(importdata(f))>46; for c=1:N, b=~fix(filter2(ones(3),b)-b/2-3); end; dlmwrite('out.txt',char(b*42+46),'') 

下面是从MATLAB命令窗口运行程序的过程：

 l('in.txt',100) 

命令语法：（130个字符）

在用命令语法调用函数的注释之后，我深入地挖了一下，发现MATLAB函数事实上可以用命令行格式 （有一些限制）来调用 。 你每天学习新的东西！

 function l(f,N), b=char(importdata(f))>46; for c=1:eval(N), b=~fix(filter2(ones(3),b)-b/2-3); end; dlmwrite('out.txt',char(b*42+46),'') 

下面是从MATLAB命令窗口运行程序的过程：

 l in.txt 100 

额外挑战：Tweetable GIF制造商 – 136个字符

我觉得好玩，我会看到，如果我可以转储输出到GIF文件，而不是文本文件，而仍然保持字符数低于140（即“tweetable”）。 这里是格式良好的代码：

 function l(f,N), b=char(importdata(f))>46; k=ones(3); for c=1:N+1, a(:,:,:,c)=kron(b,k); b=~fix(filter2(k,b)-b/2-3); end; imwrite(~a,'out.gif') 

虽然IMWRITE应该创build一个默认无限循环的GIF，但我的GIF只循环一次。 也许这是一个已经在更新版本的MATLAB中修复的bug。 所以，为了使animation持续更长的时间，并使演化步骤更容易看到，我将帧延迟保留在默认值（似乎是大约半秒）。 下面是使用Gosper Glider枪型的GIF输出：

---

改进

• 更新1：将matrixb从逻辑（即“布尔”）types更改为数字，以摆脱一些转换。
• 更新2：缩短加载文件的代码，并使用函数MAGIC作为一种技巧，以较less的字符创build卷积内核。
• 更新3：简化了索引逻辑，用b/42代替~~b+0 ，用's'代替CONV2作为参数（同样令人惊讶的仍然奏效！）。
• 更新4：我想我应该先在网上search，因为来自The MathWorks的Loren在今年早些时候就高尔夫和生命游戏发表了博文 。 我整合了一些在那里讨论的技术，这要求我把b改回逻辑matrix。
• 更新5： 来自Aslak Grinsted对上述博客文章的评论，提出了一个更短的逻辑algorithm和执行卷积（使用函数FILTER2 ），所以我“并入”（读“复制”）他的build议。 ;）
• 更新6：修改b的初始化中的两个字符，并重新编写循环中的逻辑以保存1个附加字符。
• 更新7： Eric Sampson在一封电子邮件中指出，我可以用charreplacecell2mat ，保存4个字符。 谢谢埃里克！

Answer 4

Ruby 1.9 – 189 178 159 155 153个字符

 f,n=$* c=IO.read f n.to_i.times{i=0;c=c.chars.map{|v|i+=1 v<?.?v:('...X'+v)[[83,2,-79].map{|j|c[ij,3]}.to_s.count ?X]||?.}*''} File.new('out.txt',?w)<<c 

编辑：处理换行符less于4个字符。
如果允许它在活动单元到达边缘时打破换行符，可以删除7个以上（ v<?.?v: ：）。

Answer 5

Python – 282个字符

不妨把球打滚…

 import sys _,I,N=sys.argv;R=range(3e3);B=open(I).read();B=set(k for k in R if'A'<B[k]) for k in R*int(N): if k<1:b,B=B,set() c=sum(len(set((k+o,ko))&b)for o in(1,80,81,82)) if(c==3)+(c==2)*(k in b):B.add(k) open('out.txt','w').write(''.join('.X\n'[(k in B)-(k%81<1)]for k in R)) 

Answer 6

Python 2.x – 210/234个字符

好吧，210个字符的代码是有点作弊的。

 #coding:l1 exec'xÚ=ŽA\nÂ@E÷sŠº1ƒÆscS‰ØL™Æª··âî¿GÈÿÜ´1iÖ½;Sçu.~H®J×Þ-‰Ñ%ª.wê,šÖ§J®d꘲>cÉZË¢V䀻Eîa¿,vKAËÀå̃<»Gce‚ÿ‡ábUt¹)G%£êŠ…óbÒüíÚ¯GÔ/n×Xši&ć:})äðtÏÄJÎòDˆÐÿG¶'.decode('zip') 

您可能无法复制和粘贴此代码并使其正常工作。 它应该是Latin-1（ISO-8859-1），但是我认为它在某种程度上变成了Windows-1252。 此外，您的浏览器可能会吞下一些非ASCII字符。

所以，如果它不起作用，你可以从普通的7位字符生成文件：

 s = """ 23 63 6F 64 69 6E 67 3A 6C 31 0A 65 78 65 63 27 78 DA 3D 8E 41 5C 6E C2 40 0C 45 F7 73 8A BA 31 13 AD 83 15 11 11 C6 73 08 63 17 05 53 89 D8 4C 99 C6 AA B7 B7 AD E2 EE BF 47 C8 FF DC B4 31 69 D6 BD 3B 53 E7 75 2E 7E 48 AE 4A D7 DE 90 8F 2D 89 AD D1 25 AA 2E 77 16 EA 2C 9A D6 A7 4A AE 64 EA 98 B2 3E 63 C9 5A CB A2 56 10 0F E4 03 80 BB 45 16 0B EE 04 61 BF 2C 76 0B 4B 41 CB C0 E5 CC 83 03 3C 1E BB 47 63 65 82 FF 87 E1 62 55 1C 74 B9 29 47 25 A3 EA 03 0F 8A 07 85 F3 62 D2 FC ED DA AF 11 47 D4 2F 6E D7 58 9A 69 26 C4 87 3A 7D 29 E4 F0 04 74 CF C4 4A 16 CE F2 1B 44 88 1F D0 FF 47 B6 27 2E 64 65 63 6F 64 65 28 27 7A 69 70 27 29 """ with open('life.py', 'wb') as f: f.write(''.join(chr(int(i, 16)) for i in s.split())) 

这个结果是一个有效的210个字符的Python源文件。 我在这里完成的所有工作都是在原始Python源代码上使用zip压缩。 真正的骗子是我在结果string中使用非ASCII字符。 这仍然是有效的代码，这只是麻烦。

未压缩的版本在234个字符，我认为这仍然是可敬的。

 import sys f,f,n=sys.argv e=open(f).readlines() p=range for v in p(int(n)):e=[''.join('.X'[8+16*(e[t][i]!='.')>>sum(n!='.'for v in e[t-1:t+2]for n in v[i-1:i+2])&1]for i in p(80))for t in p(40)] open('out.txt','w').write('\n'.join(e)) 

对不起水平滚动，但上面的所有换行都是必需的，我已经把它们统计为一个字符。

我不会去读高尔夫的代码。 variables名是随机select的，以达到最好的压缩效果。 是的，我很认真。 一个更好的格式和评论版本如下：

 # get command-line arguments: infile and count import sys ignored, infile, count = sys.argv # read the input into a list (each input line is a string in the list) data = open(infile).readlines() # loop the number of times requested on the command line for loop in range(int(count)): # this monstrosity applies the rules for each iteration, replacing # the cell data with the next generation data = [''.join( # choose the next generation's cell from '.' for # dead, or 'X' for alive '.X'[ # here, we build a simple bitmask that implements # the generational rules. A bit from this integer # will be chosen by the count of live cells in # the 3x3 grid surrounding the current cell. # # if the current cell is dead, this bitmask will # be 8 (0b0000001000). Since only bit 3 is set, # the next-generation cell will only be alive if # there are exactly 3 living neighbors in this # generation. # # if the current cell is alive, the bitmask will # be 24 (8 + 16, 0b0000011000). Since both bits # 3 and 4 are set, this cell will survive if there # are either 3 or 4 living cells in its neighborhood, # including itself 8 + 16 * (data[y][x] != '.') # shift the relevant bit into position >> # by the count of living cells in the 3x3 grid sum(character != '.' # booleans will convert to 0 or 1 for row in data[y - 1 : y + 2] for character in row[x - 1 : x + 2] ) # select the relevant bit & 1 ] # for each column and row for x in range(80) ) for y in range(40) ] # write the results out open('out.txt','w').write('\n'.join(data)) 

对不起，Pythonistas的C-ish括号格式，但我试图清楚每个括号是什么closures。

Answer 7

哈斯克尔 – 284 272 232字符

 import System main=do f:n:_<-getArgs;s<-readFile f;writeFile"out.txt"$ts$read n p '\n'_='\n' p 'X'2='X' p _ 3='X' p _ _='.' tr 0=r trn=t[p(r!!m)$sum[1|d<-1:[80..82],s<-[1,-1],-m<=d*s,m+d*s<3240,'X'==r!!(m+d*s)]|m<-[0..3239]]$n-1 

Answer 8

F＃，496

我可以减less很多，但是我仍然喜欢这个，因为它仍然处于良好的可读性。

 open System.IO let mutable a:_[,]=null let N yx= [-1,-1;-1,0;-1,1;0,-1;0,1;1,-1;1,0;1,1] |>Seq.sumBy(fun(i,j)->try if a.[y+i,x+j]='X' then 1 else 0 with _->0) [<EntryPoint>] let M(r)= let b=File.ReadAllLines(r.[0]) a<-Array2D.init 40 80(fun y x->b.[y].[x]) for i=1 to int r.[1] do a<-Array2D.init 40 80(fun y x-> match N yx with|3->'X'|2 when a.[y,x]='X'->'X'|_->'.') File.WriteAllLines("out.txt",Array.init 40(fun y-> System.String(Array.init 80(fun x->a.[y,x])))) 0 

编辑

428

根据要求，这是我的下一个刺：

 open System let mutable a,k=null,Array2D.init 40 80 [<EntryPoint>] let M r= a<-k(fun y x->IO.File.ReadAllLines(r.[0]).[y].[x]) for i=1 to int r.[1] do a<-k(fun y x->match Seq.sumBy(fun(i,j)->try if a.[y+i,x+j]='X'then 1 else 0 with _->0)[-1,-1;-1,0;-1,1;0,-1;0,1;1,-1;1,0;1,1]with|3->'X'|2 when a.[y,x]='X'->'X'|_->'.') IO.File.WriteAllLines("out.txt",Array.init 40(fun y->String(Array.init 80(fun x->a.[y,x])))) 0 

一些基本的高尔夫比赛减less了14％。 我不禁觉得我失去了使用二维数组/string数组而不是一维数组，但不想现在做这种转换。 请注意我如何优雅地读取文件3200次初始化我的arrays:)

Answer 9

Ruby 1.8： 178 175个字符

 f,n=$*;b=IO.read f n.to_i.times{s=b.dup s.size.times{|i|t=([82,1,-80].map{|o|b[io,3]||''}*'').count 'X' s[i]=t==3||b[i]-t==?T??X:?.if s[i]>13};b=s} File.new('out.txt','w')<<b 

换行符是重要的（尽pipe所有的都可以用分号来代替）。

编辑：修复换行问题，并修剪3个字符。

Answer 10

Java， 441 … 346

---

• 更新1删除内部如果更多的丑陋
• 更新2修正了一个bug并获得了一个angular色
• 更新3使用更多的内存和数组，同时忽略一些边界问题。 大概几个字可以保存。
• 更新4保存了几个字符。 感谢BalusC。
• 更新5在400以下进行一些小的改动，使其变得更加丑陋。
• 更新6现在硬编码的东西可能会一次读取确切的数量。 再加上几个节省。
• 更新7将写入连接到文件以保存字符。 再加上几个奇数位。

---

只是玩弄BalusC的解决scheme。 有限的声誉意味着我不能添加任何东西作为他的评论。

 class M{public static void main(String[]a)throws Exception{int t=3240,j=t,i=new Integer(a[1])*t+t;char[]b=new char[i+t],p={1,80,81,82};for(new java.io.FileReader(a[0]).read(b,t,t);j<i;){char c=b[j],l=0;for(int n:p)l+=b[j+n]/88+b[jn]/88;b[j+++t]=c>10?(l==3|l+c==90?88:'.'):c;}new java.io.FileWriter("out.txt").append(new String(b,j,t)).close();}} 

更可读（？）版本：

 class M{ public static void main(String[]a)throws Exception{ int t=3240,j=t,i=new Integer(a[1])*t+t; char[]b=new char[i+t],p={1,80,81,82}; for(new java.io.FileReader(a[0]).read(b,t,t);j<i;){ char c=b[j],l=0; for(int n:p)l+=b[j+n]/88+b[jn]/88; b[j+++t]=c>10?(l==3|l+c==90?88:'.'):c; } new java.io.FileWriter("out.txt").append(new String(b,j,t)).close(); } } 

Answer 11

斯卡拉 – 467 364 339字符

 object G{def main(a:Array[String]){val l=io.Source.fromFile(new java.io.File(a(0)))getLines("\n")map(_.toSeq)toSeq val f=new java.io.FileWriter("out.txt") f.write((1 to a(1).toInt).foldLeft(l){(t,_)=>(for(y<-0 to 39)yield(for(x<-0 to 79)yield{if(x%79==0|y%39==0)'.'else{val m=t(y-1) val p=t(y+1);val s=Seq(m(x-1),m(x),m(x+1),t(y)(x-1),t(y)(x+1),p(x-1),p(x),p(x+1)).count('X'==_) if(s==3|(s==2&t(y)(x)=='X'))'X'else'.'}})toSeq)toSeq}map(_.mkString)mkString("\n")) f.close}} 

我觉得还有很大的提升空间

[编辑]是的，它是：

 object G{def main(a:Array[String]){var l=io.Source.fromFile(new java.io.File(a(0))).mkString val f=new java.io.FileWriter("out.txt") var i=a(1).toInt while(i>0){l=l.zipWithIndex.map{case(c,n)=>if(c=='\n')'\n'else{val s=Seq(-83,-82,-81,-1,1,81,82,83).map(_+n).filter(k=>k>=0&k<l.size).count(l(_)=='X') if(s==3|(s==2&c=='X'))'X'else'.'}}.mkString i-=1} f.write(l) f.close}} 

[编辑]我有感觉还有更多挤出来…

 object G{def main(a:Array[String]){val f=new java.io.FileWriter("out.txt") f.write(((1 to a(1).toInt):\(io.Source.fromFile(new java.io.File(a(0))).mkString)){(_,m)=>m.zipWithIndex.map{case(c,n)=> val s=Seq(-83,-82,-81,-1,1,81,82,83)count(k=>k+n>=0&k+n<m.size&&m(k+n)=='X') if(c=='\n')c else if(s==3|s==2&c=='X')'X'else'.'}.mkString}) f.close}} 

Answer 12

下面的解决scheme使用我自己定制的域特定的编程语言，我称之为NULL：

 3499538 

如果你想知道这是如何工作的话：我的语言只包含一个程序的一个语句。 该语句表示属于代码高尔夫线程的StackOverflow线程ID。 我的编译器把它编译成一个寻找最好的javascript解决scheme的程序（用SO API），下载并在networking浏览器中运行它。

运行时对于新线程来说可能会更好（可能需要一些时间才会出现第一个高效的Javascript回答），但是在积极的方面它只需要很less的编码技能。

Answer 13

Javascript / Node.js – 233 236个字符

 a=process.argv f=require('fs') m=46 t=f.readFileSync(a[2]) while(a[3]--)t=[].map.call(t,function(c,i){for(n=g=0;e=[-82,-81,-80,-1,1,80,81,82][g++];)t[i+e]>m&&n++ return c<m?c:c==m&&n==3||c>m&&n>1&&n<4?88:m}) f.writeFile('out.txt',t) 

Answer 14

C – 300

---

只是想知道我的Java解决scheme可以进入多less更小和更less的C.减less到300，包括预处理器位的换行符。 让内存释放到操作系统！ 可以通过假设操作系统closures并刷新文件来保存〜20。

 #include<stdio.h> #include<stdlib.h> #define A(N)j[-N]/88+j[N]/88 int main(int l,char**a){ int t=3240,i=atoi(a[2])*t+t; char*b=malloc(i+t),*j; FILE*f; fread(j=b+t,1,t,fopen(a[1],"r")); for(;jbi;j++[t]=*j>10?l==3|l+*j==90?88:46:10) l=A(1)+A(80)+A(81)+A(82); fwrite(j,1,t,f=fopen("out.txt","w")); fclose(f); } 

Answer 15

MUMPS：314个字符

 L(F,N,R=40,C=80) N (F,N,R,C) OF:"RS" UFDCF .FI=1:1:RRLFJ=1:1:CSG(0,I,J)=($E(L,J)="X") FA=0:1:N-1 FI=1:1:RFJ=1:1:CDSG(A+1,I,J)=$S(X=2:G(A,I,J),X=3:1,1:0) .SX=0 F i=-1:1:1 F j=-1:1:1 I i!j SX=X+$G(G(A,I+i,J+j)) SF="OUT.TXT" OF:"WNS" UFDCF .FI=1:1:RFJ=1:1:CW $S(G(N,I,J):"X",1:".") W:J=C ! Q 

Answer 16

Java， 556 532 517 496 472 433 428 420 418 381字符

---

• 更新1 ：通过Appendablereplace第一个StringBuffer ，用char[]replace第二个StringBuffer 。 保存了24个字符。

• 更新2：发现一个更短的方式来读取文件到char[] 。 保存了15个字符。

• 更新3：replace一个if/else by ?:和合并的char[]和int声明。 保存了21个字符。

• 更新4：用s代替(int)f.length()和c.length 。 保存了24个字符。

• 更新5：根据Molehill的提示进行了改进。 主要是硬编码的字符长度，以便我可以摆脱File 。 保存了39个字符。

• 更新6：小的重构。 保存了6个字符。

• 更新7：用new Integer()replaceInteger#valueOf() new Integer()并重构for循环。 保存了8个字符。

• 更新8：改进的邻居计算。 保存了2个字符。

• 更新9：优化文件读取，因为文件长度已经被硬编码。 保存了37个字符。

---

  import java.io.*;class L{public static void main(String[]a)throws Exception{int i=new Integer(a[1]),j,l,s=3240;int[]p={-82,-81,-80,-1,1,80,81,82};char[]o,c=new char[s];for(new FileReader(a[0]).read(c);i-->0;c=o)for(o=new char[j=s];j-->0;){l=0;for(int n:p)l+=n+j>-1&n+j<s?c[n+j]/88:0;o[j]=c[j]>13?l==3|l+c[j]==90?88:'.':10;}Writer w=new FileWriter("out.txt");w.write(c);w.close();}} 

---

更可读的版本：

 import java.io.*; class L{ public static void main(String[]a)throws Exception{ int i=new Integer(a[1]),j,l,s=3240; int[]p={-82,-81,-80,-1,1,80,81,82}; char[]o,c=new char[s]; for(new FileReader(a[0]).read(c);i-->0;c=o)for(o=new char[j=s];j-->0;){ l=0;for(int n:p)l+=n+j>-1&n+j<s?c[n+j]/88:0; o[j]=c[j]>10?l==3|l+c[j]==90?88:'.':10; } Writer w=new FileWriter("out.txt");w.write(c);w.close(); } } 

写完后closures是过时的强制，否则文件留空。 否则会另外保存21个字符。

此外，当我使用46而不是'.'时，我还可以节省一个字符'.' ，但是javac和Eclipse都会出现编译错误， 可能会导致精度下降 。 奇怪的东西。

---

注意：这个预期input文件带有\n换行符，而不是\r\n默认使用Windows！

Answer 17

PHP – 365 328 322个字符。

---

 list(,$n,$l) = $_SERVER["argv"]; $f = file( $n ); for($j=0;$j<$l;$j++){ foreach($f as $k=>$v){ $a[$k]=""; for($i=0;$i < strlen( $v );$i++ ){ $t = 0; for($m=-1;$m<2;$m++){ for($h=-1;$h<2;$h++){ $t+=ord($f[$k + $m][$i + $h]); } } $t-=ord($v[$i]); $a[$k] .= ( $t == 494 || ($t == 452 && ord($v[$i])==88)) ? "X" : "." ; } } $f = $a; } file_put_contents("out.txt", implode("\n", $a )); 

我相信这可以改善，但我很好奇它会在PHP中看起来像什么。 也许这会激发一些有更多代码高尔夫体验的人。

• 两个参数更新了使用list（）而不是$ var = $ _SERVER [“argv”]。 好的唐
• 更新 + =和 – =这一个让我/ facepalm不能相信我错过了
• 更新的文件输出使用file_put_contents（） 另一个好的渔获
• 更新已删除的variables的初始化$ q和$ w他们没有被使用

Answer 18

R 340字符

 cgc<-function(i="in.txt",x=100){ require(simecol) z<-file("in.txt", "rb") y<-matrix(data=NA,nrow=40,ncol=80) for(i in seq(40)){ for(j in seq(80)){ y[i,j]<-ifelse(readChar(z,1) == "X",1,0) } readChar(z,3) } close(z) init(conway) <- y times(conway)<-1:x o<-as.data.frame(out(sim(conway))[[100]]) write.table(o, "out.txt", sep="", row.names=FALSE, col.names=FALSE) } cgc() 

我觉得有一个附加包可以为你做实际的自动机，但是我会继续使用它，因为我仍然不得不使用matricies和东西来读取文件中的'X'而不是1。

这是我的第一个'代码高尔夫球'，有趣….

Answer 19

c ++ – 492 454 386

---

我的第一个代码高尔夫;）

 #include<fstream> #define B(i,j)(b[i][j]=='X') int main(int i,char**v){for(int n=0;n<atoi(v[2]);++n){std::ifstream f(v[1]);v[1]="out.txt";char b[40][83];for(i=0;i<40;++i)f.getline(b[i],83);std::ofstream g("out.txt");g<<b[0]<<'\n';for(i=1;i<39;++i){g<<'.';for(int j=1;j<79;++j){int k=B(i-1,j)+B(i+1,j)+B(i,j-1)+B(i,j+1)+B(i-1,j-1)+B(i+1,j+1)+B(i+1,j-1)+B(i-1,j+1);(B(i,j)&&(k<2||k>3))?g<<'.':(!B(i,j)&&k==3)?g<<'X':g<<b[i][j];}g<<".\n";}g<<b[0]<<'\n';}} 

一个稍微修改的版本，用表查找replace一些逻辑+一些其他的小技巧：

 #include<fstream> #define B(x,y)(b[i+x][j+y]=='X') int main(int i,char**v){for(int n=0;n<atoi(v[2]);++n){std::ifstream f(v[1]);*v="out.txt";char b[40][83], O[]="...X.....";for(i=0;i<40;++i)f>>b[i];std::ofstream g(*v);g<<b[0]<<'\n';for(i=1;i<39;++i){g<<'.';for(int j=1;j<79;++j){O[2]=b[i][j];g<<O[B(-1,0)+B(1,0)+B(0,-1)+B(0,1)+B(-1,-1)+B(1,1)+B(1,-1)+B(-1,1)];}g<<".\n";}g<<b[0]<<'\n';}} 

Answer 20

Perl – 214个字符

什么，没有perl条目呢？

 $i=pop;@c=<>;@c=map{$r=$_;$u='';for(0..79) {$K=$_-1;$R=$r-1;$u.=((&N.(&N^"\0\W\0").&N)=~y/X// |(substr$c[$r],$_,1)eq'X')==3?'X':'.';}$u}keys@c for(1..$i); sub N{substr$c[$R++],$K,3}open P,'>','out.txt';$,=$/;print P@c 

运行：

  conway.pl infile #times 

Answer 21

另一个Java尝试，361个字符

 class L{public static void main(final String[]a)throws Exception{new java.io.RandomAccessFile("out.txt","rw"){{int e=88,p[]={-1,1,-80,80,-81,81,-82,82},s=3240,l=0,i=new Byte(a[1])*s+s,c;char[]b=new char[s];for(new java.io.FileReader(a[0]).read(b);i>0;seek(l=++l%s),i--){c=b[l];for(int n:p)c+=l+n>=0&l+n<s?b[l+n]/e:0;write(c>13?(c==49|(c|1)==91?e:46):10);}}};}} 

而且更可读一点

 class L { public static void main(final String[]a) throws Exception { new java.io.RandomAccessFile("out.txt","rw"){{ int e=88, p[]={-1,1,-80,80,-81,81,-82,82},s=3240,l=0,i=new Byte(a[1])*s+s,c; char[] b = new char[s]; for (new java.io.FileReader(a[0]).read(b);i>0;seek(l=++l%s),i--) { c=b[l]; for (int n:p) c+=l+n>=0&l+n<s?b[l+n]/e:0; write(c>13?(c==49|(c|1)==91?e:46):10); } }}; } } 

Very similar to Molehill's version. I've tried to use a different FileWriter and to count the cell's neighbors without an additional variable. Unfortunately, RandomAccessFile is a pretty long name and it is required that you pass an file access mode.

Answer 22

RUST – 469 characters Don't know if I should post this here, (this post is 3 years old) but anyway, my try on this, in rust (0.9):

 use std::io::fs::File;fn main(){ let mut c=File::open(&Path::new(std::os::args()[1])).read_to_end(); for _ in range(0,from_str::<int>(std::os::args()[2]).unwrap()){ let mut b=c.clone();for y in range(0,40){for x in range(0,80){let mut s=0; for z in range(x-1,x+2){for t in range(y-1,y+2){ if z>=0&&t>=0&&z<80&&t<40&&(x !=z||y !=t)&&c[t*81+z]==88u8{s +=1;}}} b[y*81+x]=if s==3||(s==2&&c[y*81+x]==88u8){88u8} else {46u8};}}c = b;} File::create(&Path::new("out.txt")).write(c);} 

For people interested, here is the code before some agressive golfing:

 use std::io::fs::File; fn main() { let f = std::os::args()[1]; let mut c = File::open(&Path::new(f)).read_to_end(); let n = from_str::<int>(std::os::args()[2]).unwrap(); for _ in range(0,n) { let mut new = c.clone(); for y in range(0,40) { for x in range(0,80) { let mut sum = 0; for xx in range(x-1,x+2){ for yy in range(y-1,y+2) { if xx >= 0 && yy >= 0 && xx <80 && yy <40 && (x != xx || y != yy) && c[yy*81+xx] == 88u8 { sum = sum + 1; } } } new[y*81+x] = if sum == 3 || (sum == 2 && c[y*81+x] == 88u8) {88u8} else {46u8}; } } c = new; } File::create(&Path::new("out.txt")).write(c); } 

Answer 23

ét voilà you may want to use this html file. no file input, but a textarea that does the job! there is also some html and initiation and vars. the main routine has only 235 characters. It's hand-minified JS.

 <!DOCTYPE html> <html><body><textarea id="t" style="width:600px;height:600px;font-family:Courier"> </textarea></body><script type="text/javascript">var o,c,m=new Array(3200), k=new Array(3200),y,v,l,p;o=document.getElementById("t");for(y=0;y<3200;y++) {m[y]=Math.random()<0.5;}setInterval(function(){p="";for(y=0;y<3200;y++){c=0; for(v=-1;v<2;v+=2){c+=m[y-1*v]?1:0;for(l=79;l<82;l++)c+=m[yl*v]?1:0;} k[y]=c==3||m[y]&&c==2;}p="";for(y=0;y<3200;y++){p+=(y>0&&y%80==0)?"\n":""; m[y]=k[y];p+=(m[y]?"O":"-");}o.innerHTML=p;},100);</script></html> 

Answer 24

One of the classic patterns

 *** ..* .* 

My avatar was created using my version of the Game of Life using this pattern and rule(note that it is not 23/3):

 #D Thanks to my daughter Natalie #D Try at cell size of 1 #R 8/1 #P -29 -29 .********************************************************* *.*******************************************************.* **.*****************************************************.** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** ****************************.*.**************************** *********************************************************** ****************************.*.**************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** *********************************************************** **.*****************************************************.** *.*******************************************************.* .********************************************************* 

IMHO – as I learned Conway's Game of Life the trick wasn't writing short code, but code that could do complex life forms quickly. Using the classic pattern above and a wrapped world of 594,441 cells the best I could ever do was around 1,000 generations / sec.

Another simple pattern

 ********** . ................* .................** ................**.......********** 

And gliders

 ........................*........... ......................*.*........... ............**......**............** ...........*...*....**............** **........*.....*...**.............. **........*...*.**....*.*........... ..........*.....*.......*........... ...........*...*.................... ............**......................