Die Herausforderung: Schreiben Sie das kürzeste Programm, das den zellularen Automaten Game of Life von John H. Conway implementiert . [ Link ]

EDIT: Nach ungefähr einer Woche Wettbewerb habe ich einen Sieger ausgewählt: pdehaan , der es geschafft hat, die Matlab-Lösung mit Perl um einen Charakter zu schlagen .

Für diejenigen, die noch nichts von Game of Life gehört haben, nehmen Sie ein Gitter (idealerweise unendlich) aus quadratischen Zellen. Zellen können lebendig (gefüllt) oder tot (leer) sein. Wir bestimmen, welche Zellen im nächsten Schritt der Zeit leben, indem wir die folgenden Regeln anwenden:

1. Jede lebende Zelle mit weniger als zwei lebenden Nachbarn stirbt, als ob sie durch eine Unterbevölkerung verursacht würde.
2. Jede lebende Zelle mit mehr als drei lebenden Nachbarn stirbt wie durch Überfüllung.
3. Jede lebende Zelle mit zwei oder drei lebenden Nachbarn lebt für die nächste Generation weiter.
4. Jede tote Zelle mit genau drei lebenden Nachbarn wird wie durch Reproduktion zu einer lebenden Zelle.

Ihr Programm liest eine ASCII-Textdatei mit 40 x 80 Zeichen ein, die als Befehlszeilenargument angegeben ist, sowie die Anzahl der auszuführenden Iterationen (N). Schließlich wird der Status des Systems nach N Iterationen in eine ASCII-Datei out.txt ausgegeben.

Hier ist ein Beispiellauf mit relevanten Dateien:

in.txt:

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

100 Mal iterieren:

Q:\>life in.txt 100

Resultierende Ausgabe (out.txt)

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

Die Regeln:

• Sie müssen Datei-E / A verwenden, um die Dateien zu lesen / schreiben.
• Sie müssen eine Eingabedatei und die Anzahl der Iterationen als Argumente akzeptieren
• Sie müssen out.txt (angegeben, falls vorhanden) im angegebenen Format generieren
• Sie müssen sich nicht mit den Kanten der Platine befassen (umlaufende, unendliche Gitter usw.).
• EDIT: Sie tun müssen Zeilenumbrüche in der Ausgabedatei haben.

Der Gewinner wird anhand der Anzahl der Charaktere ermittelt.

Viel Glück!

Perl, 127 129 135 Zeichen

Hat es geschafft, ein paar weitere Charaktere auszuziehen ...

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

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

Rufen Sie mit auf

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

Animation:

Sie können auch ein Diagramm der mittleren Bevölkerung über die Zeit erhalten:

Ein schönes Muster zum Generieren von Segelflugzeugen aus Wikipedia

AFAIK Mathematica verwendet einen Zellularautomaten, um nach Regel 30 Zufallszahlen zu generieren .

MATLAB 7.8.0 (R2009a) - 174 171 161 150 138 131 128 124 Zeichen

Funktionssyntax: (124 Zeichen)

Hier ist die besser lesbare Version (mit unnötigen Zeilenumbrüchen und Leerzeichen zur besseren Formatierung):

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

Und so wird das Programm über das MATLAB-Befehlsfenster ausgeführt:

l('in.txt',100)

Befehlssyntax: (130 Zeichen)

Nach einem Kommentar über Funktionen mit einer Befehlssyntax Aufruf, grub ich ein wenig tiefer und fand heraus , dass MATLAB - Funktionen können in der Tat werden aufgerufen mit einem Befehlszeilenformat (mit einigen Einschränkungen). Sie lernen jeden Tag etwas Neues!

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

Und so wird das Programm über das MATLAB-Befehlsfenster ausgeführt:

l in.txt 100

Zusätzliche Herausforderung: Tweetbarer GIF-Hersteller - 136 Zeichen

Ich dachte zum Spaß, ich würde sehen, ob ich die Ausgabe in eine GIF-Datei anstatt in eine Textdatei kopieren könnte, während die Zeichenanzahl immer noch unter 140 bleibt (dh "tweetbar"). Hier ist der schön formatierte Code:

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

Obwohl IMWRITE ein GIF erstellen soll, das standardmäßig unendlich viele Schleifen enthält, wird mein GIF nur einmal wiederholt. Möglicherweise ist dies ein Fehler, der in neueren Versionen von MATLAB behoben wurde. Um die Animation länger zu halten und die Evolutionsschritte besser sichtbar zu machen, habe ich die Bildverzögerung auf dem Standardwert belassen (der ungefähr eine halbe Sekunde zu betragen scheint). Hier ist die GIF-Ausgabe mit dem Gosper Glider Gun- Muster:

Verbesserungen

• Update 1: Die Matrix wurde geändertb von einem logischen (dh "booleschen") Typ in einen numerischen Typ , um einige Konvertierungen zu vermeiden.
• Update 2: Der Code zum Laden der Datei wurde verkürzt und die Funktion MAGIC verwendet als Trick verwendet, um den Faltungskern mit weniger Zeichen zu erstellen.
• Update 3: Vereinfachte die Indizierungslogik ersetzt ~~b+0mit b/42und ersetzt 'same'mit 's'als Argument an CONV2 (und es überraschenderweise noch gearbeitet!).
• Update 4: Ich denke, ich hätte zuerst online suchen sollen, da Loren von The MathWorks Anfang dieses Jahres über Golf und das Spiel des Lebens gebloggt hat. Ich habe einige der dort diskutierten Techniken integriert, sodass ich bzu einer logischen Matrix zurückkehren musste.
• Update 5: Ein Kommentar von Aslak Grinsted zu dem oben genannten Blog-Beitrag schlägt einen noch kürzeren Algorithmus sowohl für die Logik als auch für die Durchführung der Faltung vor (unter Verwendung der Funktion FILTER2 ), sodass ich seine Vorschläge "aufgenommen" (gelesen "kopiert") habe. ;)
• Update 6: Zwei Zeichen aus der Initialisierung von abgeschnitten bund die Logik in der Schleife überarbeitet, um 1 zusätzliches Zeichen zu speichern.
• Update 7: Eric Sampson wies in einer E-Mail darauf hin, durch die ich ersetzen konnte, cell2matwobei char4 Zeichen gespeichert wurden. Danke Eric!

Ruby 1.9 - 189 178 159 155 153 Zeichen

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

Bearbeiten: Behandelt Zeilenumbrüche mit 4 Zeichen weniger.
Kann 7 weitere ( v<?.?v:) entfernen, wenn Sie zulassen, dass Zeilenumbrüche blockiert werden, wenn die lebenden Zellen die Ränder erreichen.

Python - 282 Zeichen

könnte genauso gut den Ball ins Rollen bringen ...

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 Zeichen

Okay, der 210-stellige Code ist eine Art Betrug.

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

Sie werden diesen Code wahrscheinlich nicht kopieren, einfügen und zum Laufen bringen können. Es soll Latin-1 (ISO-8859-1) sein, aber ich denke, es wurde irgendwo auf dem Weg in Windows-1252 pervertiert. Darüber hinaus verschluckt Ihr Browser möglicherweise einige der Nicht-ASCII-Zeichen.

Wenn es also nicht funktioniert, können Sie die Datei aus einfachen alten 7-Bit-Zeichen generieren:

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

Das Ergebnis ist eine gültige Python-Quelldatei mit 210 Zeichen. Alles, was ich hier getan habe, ist die komprimierte Komprimierung des ursprünglichen Python-Quellcodes. Der eigentliche Cheat ist, dass ich in der resultierenden Zeichenfolge Nicht-ASCII-Zeichen verwende. Es ist immer noch gültiger Code, es ist nur umständlich.

Die nicht komprimierte Version wiegt 234 Zeichen, was meiner Meinung nach immer noch respektabel ist.

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

Entschuldigung für die horizontale Schriftrolle, aber alle Zeilenumbrüche oben sind erforderlich, und ich habe sie jeweils als ein Zeichen gezählt.

Ich würde nicht versuchen, den Golfcode zu lesen. Die Variablennamen werden zufällig ausgewählt, um die beste Komprimierung zu erzielen. Ja, es ist mein Ernst. Es folgt eine besser formatierte und kommentierte Version:

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

Entschuldigung, Pythonistas, für die C-ish-Klammerformatierung, aber ich habe versucht, klar zu machen, was jede Klammer schloss.

Haskell - 284 272 232 Zeichen

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

Ich könnte das sehr reduzieren, aber ich mag das, da es immer noch im Stadion ist und ziemlich lesbar.

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

BEARBEITEN

428

Auf Anfrage hier mein nächster Stich:

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

Das ist eine 14% ige Ermäßigung bei einigen grundlegenden Golfspielen. Ich kann nicht anders, als das Gefühl zu haben, dass ich durch die Verwendung eines 2D-Arrays / Arrays von Strings anstelle eines 1D-Arrays verliere, aber ich habe jetzt keine Lust, diese Transformation durchzuführen. Beachten Sie, wie ich die Datei 3200 Mal elegant gelesen habe, um mein Array zu initialisieren :)

Ruby 1.8: 178 175 Zeichen

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

Zeilenumbrüche sind von Bedeutung (obwohl alle mit Semikolons ersetzt werden können.)

Bearbeiten: Das Newline-Problem wurde behoben und 3 Zeichen wurden gekürzt.

Java, 441 ... 346

• Update 1 Inneres Wenn und mehr Hässlichkeit entfernt
• Update 2 Ein Fehler wurde behoben und ein Charakter erhalten
• Update 3 Verwenden Sie viel mehr Speicher und Arrays, während Sie einige Grenzprobleme ignorieren. Wahrscheinlich könnten ein paar Zeichen gespeichert werden.
• Update 4 Einige Zeichen gespeichert. Danke an BalusC.
• Update 5 Ein paar kleinere Änderungen, um unter 400 zu fallen und es nur ein bisschen hässlicher zu machen.
• Update 6 Jetzt sind die Dinge so fest codiert, dass Sie auch die genaue Menge auf einmal lesen können. Plus ein paar weitere Einsparungen.
• Update 7 Verketten Sie das Schreiben in die Datei, um ein Zeichen zu speichern. Plus ein paar ungerade Bits.

Einfach mit der Lösung von BalusC herumspielen. Eingeschränkter Ruf bedeutet, dass ich seinem Kommentar nichts hinzufügen konnte.

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

Lesbarere (?) Version:

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 Zeichen

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

Ich denke, es gibt viel Raum für Verbesserungen ...

[Bearbeiten] Ja, es ist:

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

[Bearbeiten] Und ich habe das Gefühl, es gibt noch mehr herauszudrücken ...

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

Die folgende Lösung verwendet meine eigene domänenspezifische Programmiersprache, die ich NULL genannt habe:

3499538

Falls Sie sich fragen, wie das funktioniert: Meine Sprache besteht nur aus einer Aussage pro Programm. Die Anweisung repräsentiert eine StackOverflow-Thread-ID, die zu einem Code-Golf-Thread gehört. Mein Compiler kompiliert dies zu einem Programm, das nach der besten Javascript-Lösung (mit der SO-API) sucht, diese herunterlädt und in einem Webbrowser ausführt.

Die Laufzeit könnte für neue Threads besser sein (es kann einige Zeit dauern, bis die erste hochgestufte Javascript-Antwort angezeigt wird), aber auf der anderen Seite sind nur sehr geringe Programmierkenntnisse erforderlich.

Javascript / Node.js - 233 236 Zeichen

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

Ich habe mich nur gefragt, wie viel kleiner und hässlicher meine Java-Lösung in C sein könnte. Reduziert sich auf 300, einschließlich der Zeilenumbrüche für die Präprozessor-Bits. Lässt den Speicher für das Betriebssystem frei! Könnte ~ 20 speichern, wenn angenommen wird, dass das Betriebssystem die Datei auch schließt und leert.

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

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 Zeichen

• Update 1 : 1. StringBufferdurch Appendableund 2. durch ersetzt char[]. 24 Zeichen gespeichert.

• Update 2: Es wurde eine kürzere Möglichkeit zum Einlesen von Dateien gefunden char[]. 15 Zeichen gespeichert.

• Update 3: ersetzt if/elsedurch ?:und zusammengeführt char[]und intDeklarationen. 21 Zeichen gespeichert.

• Update 4: ersetzt (int)f.length()und c.lengthdurch s. 24 Zeichen gespeichert.

• Update 5: Verbesserungen gemäß den Hinweisen von Molehill vorgenommen. Major eins hat die Zeichenlänge hartcodiert, damit ich sie loswerden konnte File. 39 Zeichen gespeichert.

• Update 6: Minor Refactoring. 6 Zeichen gespeichert.

• Update 7: ersetzt Integer#valueOf()durch new Integer()und überarbeitet für Schleife. 8 Zeichen gespeichert.

• Update 8: Verbesserte Nachbarberechnung. 2 Zeichen gespeichert.

• Update 9: Optimiertes Lesen von Dateien, da die Dateilänge bereits fest codiert ist. 37 Zeichen gespeichert.

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

Lesbarere Version:

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

Das Schließen nach dem Schreiben ist unbedingt erforderlich, andernfalls bleibt die Datei leer. Es hätte sonst weitere 21 Zeichen gespart.

Außerdem könnte ich ein weiteres Zeichen speichern, wenn ich es 46anstelle von verwende '.', aber sowohl javac als auch Eclipse ruckeln mit einem Kompilierungsfehler. Möglicher Genauigkeitsverlust . Komisches Zeug.

Hinweis: Dies erwartet eine Eingabedatei mit \nZeilenumbrüchen, nicht \r\nwie Windows standardmäßig verwendet!

PHP - 365 328 322 Zeichen.

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

Ich bin sicher, dass dies verbessert werden kann, aber ich war gespannt, wie es in PHP aussehen würde. Vielleicht inspiriert dies jemanden, der etwas mehr Erfahrung mit Code-Golf hat.

• Aktualisierte Verwendungsliste () anstelle von $ var = $ _SERVER ["argv"] für beide Argumente. Netter Don
• Aktualisiert + = und - = dieses hat mich / facepalm dazu gebracht, nicht zu glauben, dass ich es verpasst habe
• Die Dateiausgabe wurde aktualisiert , um file_put_contents () zu verwenden. Ein weiterer guter Fang von Don
• Aktualisierte entfernte Initialisierung der Vars $ q und $ w, die nicht verwendet wurden

R 340 Zeichen

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

Ich finde es etwas betrügerisch, ein Add-In-Paket zu haben, das die eigentlichen Automaten für Sie erledigt, aber ich mache mit, weil ich immer noch mit Matrizen und Sachen herumschlagen musste, um die Datei mit 'X' anstelle von 1 einzulesen.

Dies ist mein erster 'Code Golf', interessant ....

c ++ - 492 454 386

mein erster Code Golf;)

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

Eine etwas überarbeitete Version, die einen Teil der Logik durch eine Tabellensuche und einige andere kleinere Tricks ersetzt:

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

Was, noch keine Perl-Einträge?

$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

Laufen Sie mit:

conway.pl infile #times

Ein weiterer Java-Versuch, 361 Zeichen

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

Und etwas lesbarer

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

Sehr ähnlich zu Molehills Version. Ich habe versucht, einen anderen FileWriter zu verwenden und die Nachbarn der Zelle ohne eine zusätzliche Variable zu zählen. Leider RandomAccessFileist der Name ziemlich lang und es ist erforderlich, dass Sie einen Dateizugriffsmodus übergeben.

ROST - 469 Zeichen Ich weiß nicht, ob ich das hier posten soll (dieser Beitrag ist 3 Jahre alt), aber trotzdem, mein Versuch, in Rost (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);}

Für Interessierte ist hier der Code vor aggressivem Golfen:

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à möchten Sie möglicherweise diese HTML-Datei verwenden. Keine Dateieingabe, sondern ein Textbereich, der den Job macht! Es gibt auch einige HTML und Initiation und Vars. Die Hauptroutine hat nur 235 Zeichen. Es ist handminimiertes 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[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>

Eines der klassischen Muster

***
..*
.*

Mein Avatar wurde mit meiner Version des Game of Life nach diesem Muster und dieser Regel erstellt (beachten Sie, dass es nicht 23/3 ist):

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

IMHO - als ich Conways Spiel des Lebens lernte, war der Trick nicht, Kurzcode zu schreiben, sondern Code, der komplexe Lebensformen schnell erstellen kann. Unter Verwendung des obigen klassischen Musters und einer Welt mit 594.441 Zellen war das Beste, was ich jemals tun konnte, etwa 1.000 Generationen / Sek.

Ein weiteres einfaches Muster

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

Und Segelflugzeuge

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