رمز الغولف:كونواي لعبة الحياة

https://stackoverflow.com/questions/3499538

29-09-2019
|

سؤال

التحدي: كتابة أقصر البرنامج الذي ينفذ جون هـ.كونواي لعبة الحياة إنسان الخلوية.[الرابط]

تحرير: بعد حوالي أسبوع من المنافسة ، يجب تحديد المنتصر: pdehaan, بالنسبة إدارة للتغلب على مطلب حل واحد حرف مع بيرل.

بالنسبة لأولئك الذين لم تكن قد سمعت من لعبة الحياة ، كنت تأخذ الشبكة (مثالي لانهائي) من خلايا مربع.الخلايا يمكن أن يكون على قيد الحياة (شغل) أو ميتا (فارغة).نحدد الخلايا التي هي على قيد الحياة في الخطوة التالية من الوقت من خلال تطبيق القواعد التالية:

أي خلية حية مع أقل من اثنين من جيران الحي يموت ، كما إذا تسبب تحت السكان.
أي خلية حية مع أكثر من ثلاثة جيران الحي يموت ، كما لو كان بفعل الاكتظاظ.
أي خلية حية مع اثنين أو ثلاثة من جيرانه يعيشوا حياة إلى الجيل التالي.
أي خلية ميتة تماما مع ثلاثة جيران الحي تصبح الخلية الحية, كما لو كان عن طريق الاستنساخ.

البرنامج سوف تقرأ في 40x80 الطابع ملف نصي ASCII محددة بوصفها وسيطة سطر الأوامر ، وكذلك عدد التكرارات (ن) لأداء.وأخيرا ، فإنه سيتم إخراج إلى ملف ASCII out.txt دولة النظام بعد ن التكرار.

هنا هو مثال على تشغيل مع الملفات ذات الصلة:

in.txt:

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

تكرار 100 مرة:

Q:\>life in.txt 100

الناتجة الإخراج (out.txt)

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

القواعد:

تحتاج إلى استخدام ملف I/O قراءة/كتابة الملفات.
تحتاج إلى قبول ملف إدخال عدد من التكرارات كما الحجج
تحتاج إلى توليد out.txt (الكتابة إذا كان موجودا) في شكل محدد
لك لا تحتاج إلى التعامل مع حواف من المجلس (ملفوف, لانهائية الشبكات .الخ)
تحرير:لك هل تحتاج إلى أسطر في ملف الإخراج الخاص بك.

سيتم تحديد الفائز من قبل عدد الأحرف.

حظا سعيدا!

المحلول

بيرل ، 127 129 135 chars

تمكنت من تجريد شخصين أكثر ...

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

نصائح أخرى

الرياضيات 179 163 154 151 حرف

    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"] &

المساحات إضافة لسهولة القراءة

الاحتجاج مع

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

الرسوم المتحركة:

alt text

يمكنك أيضا الحصول على الرسم البياني متوسط عدد السكان على مر الزمن:

alt text

لطيفة نمط توليد الطائرات الشراعية من ويكيبيديا

AFAIK الرياضيات يستخدم إنسان الخلوية لتوليد أرقام عشوائية باستخدام المادة 30.

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

تحد إضافي: صانع 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 من المفترض أن تنشئ صورة GIF التي لا حصر لها بشكل غير محدود ، فإن GIF الخاص بي لا يحلق إلا مرة واحدة. ربما يكون هذا خطأ تم إصلاحه في إصدارات أحدث من Matlab. لذلك ، لجعل الرسوم المتحركة تدوم لفترة أطول وتسهيل رؤية خطوات التطور ، تركت تأخير الإطار بالقيمة الافتراضية (التي يبدو أنها حوالي نصف ثانية). إليك إخراج GIF باستخدام غوسبر طائرة شراعية نمط:

alt text

تحسينات

تحديث 1: غير المصفوفة b من نوع منطقي (أي "منطقي") إلى واحد رقمي للتخلص من بعض التحويلات.
تحديث 2: اختصر الكود لتحميل الملف واستخدم الوظيفة سحر كخدعة لإنشاء نواة الالتواء في عدد أقل من الشخصيات.
تحديث 3: تبسيط منطق الفهرسة ، استبداله ~~b+0 مع b/42, ، واستبدل 'same' مع 's' كحجة ل Conv2 (وما زال بشكل مدهش يعمل!).
تحديث 4: أعتقد أنه كان ينبغي علي البحث عبر الإنترنت أولاً ، منذ ذلك الحين لورين من Mathworks تم التدوين عن لعبة الجولف ولعبة الحياة في وقت سابق من هذا العام. لقد قمت بدمج بعض التقنيات التي تمت مناقشتها هناك ، والتي تطلب مني التغيير b العودة إلى مصفوفة منطقية.
تحديث 5: أ تعليق من Aslak Grinsted في منشور المدونة المذكور أعلاه ، تشير إلى خوارزمية أقصر لكل من المنطق وأداء الالتفاف (باستخدام الوظيفة Filter2) ، لذلك أنا "دمجت" (اقرأ "نسخ") اقتراحاته. ؛)
تحديث 6: قلصت حرفين من تهيئة b وأعيد صياغة المنطق في الحلقة لحفظ حرف واحد إضافي.
تحديث 7: أشار إريك سامبسون في رسالة بريد إلكتروني يمكنني استبدالها cell2mat مع char, ، حفظ 4 أحرف. شكرا إريك!

روبي 1.9 - 189 178 159 155 153 chars

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

يحرر:يتعامل مع الخطوط الجديدة مع 4 chars أقل.
يمكن إزالة 7 آخرين (v<?.?v:) إذا سمحت لها بالتخلي عن الخطوط الجديدة عندما تصل الخلايا الحية إلى الحواف.

Python - 282 Chars

قد تحصل على الكرة المتداول ...

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

بيثون 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')

ربما لن تتمكن من نسخ هذا الرمز ولصقه والحصول عليه للعمل. من المفترض أن تكون لاتينية -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()))

نتيجة هذا هو ملف مصدر Python ساري المفعول 210. كل ما قمت به هنا هو استخدام ضغط الرمز البريدي على رمز مصدر بيثون الأصلي. الغش الحقيقي هو أنني أستخدم أحرف غير 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))

آسف على التمرير الأفقي ، ولكن جميع الخطوط الجديدة في ما سبق مطلوبة ، ولقد أحسبها كشخصية واحدة لكل منها.

لن أحاول قراءة الرمز الغولف. يتم اختيار الأسماء المتغيرة بشكل عشوائي لتحقيق أفضل ضغط. نعم انا جدي. يتبع نسخة أفضل من التنسيق والتعليق:

# 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 ، لكنني كنت أحاول توضيح ما كانت كل شريحة تغلقها.

هاسكل - 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

و#، 496

يمكنني تقليل هذا كثيرًا ، لكني أحب هذا لأنه لا يزال في الملعب وقابل للقراءة إلى حد ما.

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

تعديل

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

هذا انخفاض بنسبة 14 ٪ مع بعض الغولف الأساسي. لا يسعني إلا أن أشعر أنني أخسر باستخدام 2D-Array/Array of Of Strings بدلاً من صفيف 1D ، لكن لا تشعر بالقيام بذلك الآن. لاحظ كيف أقرأ الملف 3200 مرة بأناقة لتهيئة صفيف بلدي :)

روبي 1.8: ~~178~~ 175 chars

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

الخطوط الجديدة مهمة (على الرغم من أنه يمكن استبدال كل ذلك مع فاصلة فاصلة.)

يحرر: تم إصلاح مشكلة السطر الجديد ، وتقلص 3 chars.

جافا ، 441... 346

تحديث 1 إزالة داخلي إذا والمزيد من القبح
تحديث 2 إصلاح الخلل واكتسب شخصية
تحديث 3 باستخدام الكثير من الذاكرة والصفائف مع تجاهل بعض مشاكل الحدود. ربما يمكن حفظ عدد قليل من chars.
تحديث 4 أنقذ عدد قليل من الشورات. بفضل بالوس.
تحديث 5 بعض التغييرات البسيطة للذهاب إلى أقل من 400 وجعلها أكثر قبيحة قليلا.
تحديث 6 الآن ، قد تكون الأمور متشددة جدًا قد تقرأ بشكل جيد بالمبلغ الدقيق في GO. بالإضافة إلى عدد قليل من المدخرات.
تحديث 7 سلسلة الكتابة إلى الملف لحفظ char. بالإضافة إلى عدد قليل من البتات الفردية.

مجرد اللعب مع حل Balusc. سمعة محدودة تعني أنني لم أستطع إضافة أي شيء كتعليق له.

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

إصدار أكثر قابلية للقراءة (؟):

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

سكالا - ~~467~~ ~~364~~ 339 chars

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

يستخدم الحل التالي لغة البرمجة الخاصة بمجالك المخصص والتي أسميتها NULL:

في حال كنت تتساءل كيف يعمل هذا: تتكون لغتي من إحصاء واحد فقط لكل برنامج. يمثل العبارة معرف خيط Stackoverflow الذي ينتمي إلى مؤشر ترابط الجولف. يقوم المترجم الخاص بي بتجميع هذا في برنامج يبحث عن أفضل حل JavaScript (مع API SO) ، ويقوم بتنزيله ويديره في متصفح الويب.

يمكن أن يكون وقت التشغيل أفضل للمواضيع الجديدة (قد يستغرق الأمر بعض الوقت لأول إجابة JavaScript التي تظهر) ، ولكن في الاتجاه الصعودي لا يتطلب سوى القليل من مهارات الترميز.

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)

ج - 300

فقط تساءلت عن مدى انخفاض حجم حلتي Java الأصغر والأقبية في C. إلى 300 بما في ذلك الخطوط الجديدة للبوت المسبقة. يترك تحرير الذاكرة لنظام التشغيل! يمكن أن يحفظ ~ 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(;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);
}

النكاف: 314 chars

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

جافا ، 556 532 517 496 472 433 428 420 418 381 chars

تحديث 1: استبدال 1st StringBuffer بواسطة Appendable والثاني من قبل char[]. أنقذ 24 chars.
تحديث 2: وجدت طريقة أقصر لقراءة الملف في char[]. أنقذ 15 شارز.
تحديث 3: استبدال واحد if/else بواسطة ?: ودمجت char[] و int إعلانات. أنقذ 21 شارز.
تحديث 4: استبدال (int)f.length() و c.length بواسطة s. أنقذ 24 chars.
تحديث 5: إجراء تحسينات حسب تلميحات molehill. كان الرائد هو ترميز طول الشار حتى أتمكن من التخلص منه File. أنقذ 39 chars.
تحديث 6: إعادة إنشاء طفيفة. أنقذ 6 chars.
تحديث 7: استبدال Integer#valueOf() بواسطة new Integer() وأعيد إعادة البناء للحلقة. أنقذ 8 chars.
تحديث 8: تحسين حساب الجوار. حفظ 2 chars.
تحديث 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();
 }
}

الإغلاق بعد الكتابة أمر إلزامي ، وإلا يتم ترك الملف فارغًا. كان من الممكن أن ينقذ 21 شارسًا آخر.

علاوة على ذلك ، يمكنني أيضًا حفظ شار آخر عند استخدامه 46 بدلاً من '.', ، لكن كل من Javac و Eclipse يهزون بخطأ في التجميع احتمال فقدان الدقة. اشياء غريبة.

ملاحظة: هذا يتوقع ملف إدخال مع \n الخطوط الجديدة ، لا \r\n كما يستخدم Windows افتراضيًا!

بي أتش بي - 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"] لكلا args. جميل واحد دون
محدث += و -= هذا جعلني /Facepalm heh غير قادر على تصديق أنني فاتني ذلك
محدث إخراج الملف لاستخدام file_put_contents () صيد جيد آخر من دون
محدث تم إزالة تهيئة VARS $ Q و $ w لم يتم استخدامها

ص 340 chars

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

أشعر أنه من الغش قليلاً أن يكون لديك حزمة إضافة في الأوتوماتا الفعلية بالنسبة لك ، لكنني ذاهب معها لأنني ما زلت مضطرًا للتجول مع المصفوفات والأشياء للقراءة في الملف مع "X" بدلاً من 1.

هذا هو أول "رمز الجولف" ، مثير للاهتمام ....

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

نسخة منقحة إلى حد ما ، استبدال بعض المنطق مع جدول بحث+بعض الحيل البسيطة الأخرى:

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

ماذا ، لا توجد إدخالات بيرل حتى الآن؟

$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

محاولة جافا أخرى ، 361 chars

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

تشبه إلى حد كبير نسخة Molehill. لقد حاولت استخدام مهرج فيرتر مختلف وحساب جيران الخلية دون متغير إضافي. للأسف، RandomAccessFile هو اسم طويل جدًا وهو مطلوب منك تمرير وضع الوصول إلى الملف.

الصدأ - 469 حرفًالا أعرف ما إذا كان ينبغي عليّ نشر هذا هنا ، (هذا المنشور يبلغ من العمر 3 سنوات) ولكن على أي حال ، تجربتي في هذا ، في الصدأ (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);}

بالنسبة للأشخاص المهتمين ، إليك الكود قبل بعض الجولف العدواني:

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

ét Voilà قد ترغب في استخدام ملف HTML هذا. لا يوجد إدخال ملف ، ولكن النص الذي يقوم بالمهمة! هناك أيضا بعض HTML والبدء والأسهم. الروتين الرئيسي لديه 235 حرفًا فقط. إنه محدد يدويًا.

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

أحد الأنماط الكلاسيكية

***
..*
.*

تم إنشاء الصورة الرمزية الخاصة بي باستخدام الإصدار الخاص بي من لعبة الحياة باستخدام هذا النمط والقاعدة (لاحظ أنه ليس 23/3):

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

IMHO - كما تعلمت لعبة حياة كونواي ، لم تكن الخدعة تكتب رمزًا قصيرًا ، ولكن الكود الذي يمكن أن يقوم بأشكال الحياة المعقدة بسرعة. باستخدام النمط الكلاسيكي أعلاه وعالم ملفوف يبلغ 594،441 خلية ، كان أفضل ما يمكنني فعله على الإطلاق هو حوالي 1000 جيل / ثانية.

نمط بسيط آخر

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

والزاحف

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

مرخصة بموجب: CC-BY-SA مع الإسناد

لا تنتمي إلى StackOverflow