Thử thách: Viết chương trình ngắn nhất triển khai tự động hóa di động Trò chơi Cuộc sống của John H. Conway . [ liên kết ]

CHỈNH SỬA: Sau khoảng một tuần cạnh tranh, tôi đã chọn được người chiến thắng: pdehaan , vì đã quản lý để đánh bại giải pháp Matlab bằng một ký tự với perl.

Đối với những người chưa từng nghe nói về Game of Life, bạn sẽ có một lưới ô vuông (lý tưởng là vô hạn). Các ô có thể sống (lấp đầy) hoặc chết (trống). Chúng tôi xác định ô nào còn sống trong bước thời gian tiếp theo bằng cách áp dụng các quy tắc sau:

1. Bất kỳ ô sống nào có ít hơn hai người hàng xóm còn sống sẽ chết, như thể do dân số ít hơn.
2. Bất kỳ phòng giam nào có nhiều hơn ba người hàng xóm còn sống sẽ chết, như thể do quá đông.
3. Bất kỳ ô sống nào có hai hoặc ba người hàng xóm sống tiếp tục sống cho thế hệ tiếp theo.
4. Bất kỳ tế bào chết nào có chính xác ba hàng xóm sống đều trở thành tế bào sống, như thể bằng cách sinh sản.

Chương trình của bạn sẽ đọc trong tệp văn bản ASCII 40x80 ký tự được chỉ định làm đối số dòng lệnh, cũng như số lần lặp (N) để thực hiện. Cuối cùng, nó sẽ xuất ra tệp ASCII out.txt trạng thái của hệ thống sau N lần lặp.

Đây là một ví dụ chạy với các tệp có liên quan:

in.txt:

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

Lặp lại 100 lần:

Q:\>life in.txt 100

Kết quả đầu ra (out.txt)

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

Những quy định:

• Bạn cần sử dụng I / O tệp để đọc / ghi tệp.
• Bạn cần chấp nhận một tệp đầu vào và số lần lặp làm đối số
• Bạn cần tạo out.txt (ghi đè nếu nó tồn tại) ở định dạng được chỉ định
• Bạn không cần phải xử lý các cạnh của bảng (bao quanh, lưới vô hạn. Vv)
• EDIT: Bạn làm cần phải có dòng mới trong tập tin đầu ra của bạn.

Người chiến thắng sẽ được xác định bằng số ký tự.

Chúc may mắn!

perl, 127 129 135 ký tự

Được quản lý để loại bỏ một vài ký tự khác ...

$/=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

Mathematica - 179 163 154 151 ký tự

    a = {2, 2, 2};
    s = Export["out.txt", 
       CellularAutomaton[{224, {2, {a, {2, 1, 2}, a}}, {1,1}}, 
                (ReadList[#1, Byte, RecordLists → 2>1] - 46)/ 42, #2]〚#2〛
       /. {0 → ".", 1 → "X"}, "Table"] &

Gọi bằng

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

Hoạt hình:

Bạn cũng có thể nhận được biểu đồ của dân số trung bình theo thời gian:

Một mẫu đẹp để tạo các trình lượn từ Wikipedia

AFAIK Mathematica sử dụng Cellular Automaton để tạo các số ngẫu nhiên bằng cách sử dụng Quy tắc 30.

MATLAB 7.8.0 (R2009a) - 174 171 161 150 138 131 128 124 ký tự

Cú pháp hàm: (124 ký tự)

Đây là phiên bản dễ đọc hơn (với các dòng mới và khoảng trắng không cần thiết được thêm vào để định dạng tốt hơn):

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),'')

Và đây là cách chương trình được chạy từ Cửa sổ lệnh MATLAB:

l('in.txt',100)

Cú pháp lệnh: (130 ký tự)

Sau một lời nhận xét về gọi chức năng với một cú pháp lệnh, tôi đào sâu hơn một chút và phát hiện ra rằng chức năng MATLAB có thể trên thực tế được gọi với một định dạng dòng lệnh (với một số hạn chế). Bạn học được điều gì mới mỗi ngày!

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),'')

Và đây là cách chương trình được chạy từ Cửa sổ lệnh MATLAB:

l in.txt 100

Thách thức bổ sung: Trình tạo GIF có thể tweet - 136 ký tự

Tôi nghĩ vui rằng tôi sẽ xem liệu tôi có thể kết xuất đầu ra thành tệp GIF thay vì tệp văn bản hay không, trong khi vẫn giữ số lượng ký tự dưới 140 (tức là "có thể tweet"). Đây là mã được định dạng độc đáo:

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')

Mặc dù IMWRITE được cho là tạo một GIF lặp lại vô hạn theo mặc định, nhưng GIF của tôi chỉ lặp lại một lần. Có lẽ đây là một lỗi đã được sửa trong các phiên bản mới hơn của MATLAB. Vì vậy, để làm cho hoạt ảnh kéo dài hơn và làm cho các bước tiến hóa dễ nhìn hơn, tôi đã để độ trễ khung hình ở giá trị mặc định (dường như khoảng nửa giây). Đây là đầu ra GIF bằng cách sử dụng mẫu Gosper Glider Gun :

Cải tiến

• Cập nhật 1: Đã thay đổi ma trận btừ kiểu logic (tức là "boolean") thành kiểu số để loại bỏ một vài chuyển đổi.
• Cập nhật 2: Đã rút ngắn mã tải tệp và sử dụng hàm MAGIC như một thủ thuật để tạo nhân chập với ít ký tự hơn.
• Cập nhật 3: Đơn giản hóa logic lập chỉ mục, thay thế ~~b+0bằng b/42và thay thế 'same'bằng 's'làm đối số cho CONV2 (và đáng ngạc nhiên là nó vẫn hoạt động!).
• Cập nhật 4: Tôi đoán tôi nên tìm kiếm trực tuyến trước, vì Loren từ The MathWorks đã viết blog về chơi gôn và Trò chơi của cuộc sống vào đầu năm nay. Tôi đã kết hợp một số kỹ thuật được thảo luận ở đó, yêu cầu tôi thay đổi btrở lại ma trận logic.
• Cập nhật 5: Một nhận xét từ Aslak Grinsted về bài đăng trên blog được đề cập ở trên gợi ý một thuật toán thậm chí còn ngắn hơn cho cả logic và thực hiện tích chập (sử dụng hàm FILTER2 ), vì vậy tôi đã "kết hợp" (đọc "sao chép") các đề xuất của anh ấy. ;)
• Cập nhật 6: Cắt hai ký tự từ lần khởi tạo bvà làm lại logic trong vòng lặp để lưu thêm 1 ký tự.
• Cập nhật 7: Eric Sampson đã chỉ ra trong e-mail mà tôi có thể thay thế cell2matbằng char, lưu 4 ký tự. Cảm ơn Eric!

Ruby 1.9 - 189 178 159 155 153 ký tự

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[i-j,3]}.to_s.count ?X]||?.}*''}
File.new('out.txt',?w)<<c

Chỉnh sửa: Xử lý dòng mới với ít hơn 4 ký tự.
Có thể xóa thêm 7 ( v<?.?v:) nếu bạn cho phép nó chặn dòng mới khi các ô sống chạm đến các cạnh.

Python - 282 ký tự

cũng có thể làm cho quả bóng lăn ...

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,k-o))&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))

Python 2.x - 210/234 ký tự

Được rồi, mã 210 ký tự là một loại gian lận.

#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')

Bạn có thể sẽ không thể sao chép và dán mã này và làm cho nó hoạt động. Nó được cho là Latin-1 (ISO-8859-1), nhưng tôi nghĩ rằng nó đã bị biến thành Windows-1252 ở đâu đó trên đường đi. Ngoài ra, trình duyệt của bạn có thể nuốt một số ký tự không phải ASCII.

Vì vậy, nếu nó không hoạt động, bạn có thể tạo tệp từ các ký tự 7-bit cũ:

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()))

Kết quả của việc này là một tệp nguồn Python 210 ký tự hợp lệ. Tất cả những gì tôi đã làm ở đây là sử dụng nén zip trên mã nguồn Python ban đầu. Gian lận thực sự là tôi đang sử dụng các ký tự không phải ASCII trong chuỗi kết quả. Nó vẫn là mã hợp lệ, nó chỉ rườm rà.

Phiên bản không nén nặng 234 ký tự, tôi nghĩ vẫn đáng nể.

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))

Xin lỗi về cuộn ngang, nhưng tất cả các dòng mới ở trên là bắt buộc và tôi đã tính mỗi dòng là một ký tự.

Tôi sẽ không cố gắng đọc mã chơi gôn. Các tên biến được chọn ngẫu nhiên để đạt được độ nén tốt nhất. Vâng tôi rất nghiêm túc. Một phiên bản được định dạng và nhận xét tốt hơn như sau:

# 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))

Xin lỗi, Pythonistas, vì định dạng dấu ngoặc C-ish, nhưng tôi đang cố nói rõ mỗi dấu ngoặc đóng là gì.

Haskell - 284 272 232 chars

import System
main=do f:n:_<-getArgs;s<-readFile f;writeFile"out.txt"$t s$read n
p '\n'_='\n'
p 'X'2='X'
p _ 3='X'
p _ _='.'
t r 0=r
t r n=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

F #, 496

Tôi có thể giảm điều này rất nhiều, nhưng tôi thích điều này vì nó vẫn ở trong sân bóng và khá dễ đọc.

open System.IO
let mutable a:_[,]=null
let N y x=
 [-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 y x 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

BIÊN TẬP

428

Theo yêu cầu, đây là cú đâm tiếp theo của tôi:

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

Đó là mức giảm 14% với một số môn chơi gôn cơ bản. Tôi không thể không cảm thấy rằng tôi đang thua khi sử dụng mảng 2D / mảng chuỗi thay vì mảng 1D, nhưng không cảm thấy muốn thực hiện biến đổi đó ngay bây giờ. Lưu ý cách tôi đọc tệp một cách thanh lịch 3200 lần để khởi tạo mảng của mình :)

Ruby 1.8: 178 175 ký tự

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

Các dòng mới rất quan trọng (mặc dù tất cả đều có thể được thay thế bằng dấu chấm phẩy /.)

Chỉnh sửa: đã khắc phục sự cố dòng mới và cắt 3 ký tự.

Java, 441 ... 346

• Cập nhật 1 Loại bỏ bên trong nếu và xấu hơn
• Cập nhật 2 Đã sửa lỗi và nhận được một nhân vật
• Cập nhật 3 Sử dụng nhiều bộ nhớ và mảng hơn trong khi bỏ qua một số vấn đề về ranh giới. Có lẽ một vài ký tự có thể được lưu.
• Cập nhật 4 Đã lưu một vài ký tự. Cảm ơn BalusC.
• Cập nhật 5 Một vài thay đổi nhỏ để giảm xuống dưới 400 và làm cho nó xấu hơn một chút.
• Cập nhật 6 Bây giờ, mọi thứ được mã hóa cứng cũng có thể đọc với số lượng chính xác trong một lần. Thêm một vài khoản tiết kiệm nữa.
• Cập nhật 7 Chuỗi ghi vào tệp để lưu một ký tự. Cộng với một vài bit lẻ.

Chỉ chơi xung quanh với giải pháp của BalusC. Danh tiếng hạn chế có nghĩa là tôi không thể thêm bất cứ điều gì làm bình luận cho anh ấy.

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[j-n]/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();}}

Phiên bản (?) Dễ đọc hơn:

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[j-n]/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();
 }
}

Scala - 467 364 339 ký tự

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}}

Tôi nghĩ rằng có nhiều chỗ để cải thiện ...

[Chỉnh sửa] Vâng, đó là:

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}}

[Chỉnh sửa] Và tôi có cảm giác vẫn còn nhiều thứ phải vắt kiệt ...

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}}

Giải pháp sau sử dụng ngôn ngữ lập trình miền cụ thể tùy chỉnh của riêng tôi mà tôi đã gọi là NULL:

3499538

Trong trường hợp bạn đang tự hỏi điều này hoạt động như thế nào: Ngôn ngữ của tôi chỉ bao gồm một trạng thái cho mỗi chương trình. Câu lệnh đại diện cho một ID luồng StackOverflow thuộc một luồng mã gôn. Trình biên dịch của tôi biên dịch này thành một chương trình tìm kiếm giải pháp javascript tốt nhất (với API SO), tải xuống và chạy nó trong trình duyệt web.

Thời gian chạy có thể tốt hơn cho các chủ đề mới (có thể mất một thời gian để câu trả lời Javascript được ủng hộ đầu tiên xuất hiện), nhưng về mặt tích cực, nó chỉ yêu cầu rất ít kỹ năng viết mã.

Javascript / Node.js - 233 236 ký tự

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)

C - 300

Chỉ tự hỏi giải pháp java của tôi có thể nhỏ hơn và xấu hơn bao nhiêu trong C. Giảm xuống còn 300 bao gồm các dòng mới cho các bit tiền xử lý. Giải phóng bộ nhớ cho hệ điều hành! Có thể tiết kiệm ~ 20 bằng cách giả sử hệ điều hành cũng sẽ đóng và xóa tệp.

#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(;j-b-i;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);
}

MUMPS: 314 ký tự

L(F,N,R=40,C=80)
    N (F,N,R,C)
    O F:"RS" U F D  C F
    .F I=1:1:R R L F J=1:1:C S G(0,I,J)=($E(L,J)="X")
    F A=0:1:N-1 F I=1:1:R F J=1:1:C D  S G(A+1,I,J)=$S(X=2:G(A,I,J),X=3:1,1:0)
    .S X=0 F i=-1:1:1 F j=-1:1:1 I i!j S X=X+$G(G(A,I+i,J+j))
    S F="OUT.TXT" O F:"WNS" U F D  C F
    .F I=1:1:R F J=1:1:C W $S(G(N,I,J):"X",1:".") W:J=C !
    Q

Java, 556 532 517 496 472 433 428 420 418 381 ký tự

• Cập nhật 1 : thay thế 1 StringBufferbằng Appendablevà 2 bằng char[]. Đã lưu 24 ký tự.

• Cập nhật 2: đã tìm thấy một cách ngắn hơn để đọc tệp vào char[]. Đã lưu 15 ký tự.

• Cập nhật 3: thay thế một if/elsebằng ?:và hợp nhất char[]và intkhai báo. Đã lưu 21 ký tự.

• Cập nhật 4: thay thế (int)f.length()và c.lengthbởi s. Đã lưu 24 ký tự.

• Cập nhật 5: đã thực hiện các cải tiến theo gợi ý của Molehill. Major một đang mã hóa độ dài ký tự để tôi có thể loại bỏ File. Đã lưu 39 ký tự.

• Cập nhật 6: tái cấu trúc nhỏ. Đã lưu 6 ký tự.

• Cập nhật 7: thay thế Integer#valueOf()bằng new Integer()và cấu trúc lại cho vòng lặp. Đã lưu 8 ký tự.

• Cập nhật 8: Cải thiện tính toán hàng xóm. Đã lưu 2 ký tự.

• Cập nhật 9: Đọc tệp được tối ưu hóa vì độ dài tệp đã được mã hóa cứng. Đã lưu 37 ký tự.

 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();}}

Phiên bản dễ đọc hơn:

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();
 }
}

Việc đóng sau khi viết là hoàn toàn bắt buộc, nếu không tệp sẽ trống. Nếu không, nó sẽ lưu thêm 21 ký tự.

Hơn nữa, tôi cũng có thể lưu thêm một ký tự nữa khi tôi sử dụng 46thay vì sử dụng '.', nhưng cả javac và Eclipse đều bị giật với lỗi biên dịch Có thể mất độ chính xác . Những thứ kỳ lạ.

Lưu ý: điều này mong đợi một tệp đầu vào có \ndòng mới, không phải \r\nnhư Windows sử dụng mặc định!

PHP - 365 328 322 ký tự.

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 )); 

Tôi chắc rằng điều này có thể được cải thiện nhưng tôi tò mò không biết nó sẽ như thế nào trong PHP. Có thể điều này sẽ truyền cảm hứng cho những người có kinh nghiệm chơi golf nhiều hơn một chút.

• Đã cập nhật danh sách sử dụng () thay vì $ var = $ _SERVER ["argv"] cho cả hai args. Đẹp một Don
• Đã cập nhật + = và - = cái này khiến tôi / facepalm heh không thể tin được là tôi đã bỏ lỡ nó
• Đã cập nhật đầu ra tệp để sử dụng file_put_contents () một cách tốt khác của Don
• Đã cập nhật quá trình khởi tạo đã xóa của vars $ q và $ w chúng không được sử dụng

R 340 ký tự

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()

Tôi cảm thấy hơi gian lận khi có một gói bổ sung thực hiện dữ liệu tự động thực tế cho bạn, nhưng tôi sẽ sử dụng nó vì tôi vẫn phải loay hoay với các ma trận và nội dung để đọc trong tệp với 'X' thay vì 1.

Đây là 'mã gôn' đầu tiên của tôi, thú vị ...

c ++ - 492 454 386

mã đầu tiên của tôi chơi gôn;)

#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';}}

Một phiên bản sửa đổi đôi chút, thay thế một số logic bằng tra cứu bảng + một vài thủ thuật nhỏ khác:

#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';}}

Perl - 214 ký tự

Cái gì, chưa có mục perl nào?

$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

Chạy với:

conway.pl infile #times

Một nỗ lực Java khác, 361 ký tự

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);}}};}}

Và dễ đọc hơn một chút

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);
            }
        }};
    }
}

Rất giống với phiên bản của Molehill. Tôi đã cố gắng sử dụng một FileWriter khác và để đếm các hàng xóm của ô mà không có biến bổ sung. Thật không may, RandomAccessFilelà một cái tên khá dài và bạn bắt buộc phải vượt qua chế độ truy cập tệp.

RUST - 469 ký tự Không biết tôi có nên đăng bài này ở đây không, (bài này đã được 3 năm) nhưng dù sao, tôi cũng cố gắng về điều này, trong gỉ (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);}

Đối với những người quan tâm, đây là mã trước khi chơi gôn nặng:

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);
}

Bạn có thể muốn sử dụng tệp html này. không có đầu vào tệp, nhưng một vùng văn bản thực hiện công việc! cũng có một số html và khởi tạo và vars. quy trình chính chỉ có 235 ký tự. Đó là JS được thu nhỏ bằng tay.

<!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[y-l*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>

Một trong những mẫu cổ điển

***
..*
.*

Hình đại diện của tôi đã được tạo bằng cách sử dụng phiên bản Trò chơi Cuộc sống của tôi bằng cách sử dụng mẫu và quy tắc này (lưu ý rằng nó không phải là ngày 23/3):

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

IMHO - khi tôi biết được Trò chơi cuộc sống của Conway, mẹo không phải là viết mã ngắn, mà là mã có thể thực hiện các dạng sống phức tạp một cách nhanh chóng. Sử dụng mô hình cổ điển ở trên và một thế giới bao gồm 594.441 ô, điều tốt nhất tôi có thể làm là khoảng 1.000 thế hệ / giây.

Một mẫu đơn giản khác

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

Và tàu lượn

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