Code Golf: Conways Spiel des Lebens

76

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!

language-agnostic  code-golf  rosetta-stone  conways-game-of-life 
— hb2pencil
quelle
22
Das ist so ein toller Code Golf! Und ich glaube fest daran, dass es zu SO gehört. Ich habe vor ein paar Tagen eine großartige Implementierung in APL gefunden: youtube.com/watch?v=a9xAKttWgP4
— Victor Hurdugaci
Akzeptable Idee, aber Sie müssen sie verschärfen. meta.stackexchange.com/questions/24242/…
— zaf
4
Die relative Popularität ist eine schlechte Metrik für Golf. Perl bekommt immer viele Stimmen, auch wenn es nicht das kürzeste ist und auch wenn es nicht den Spezifikationen entspricht. Sie sollten sich an die Anzahl der Zeichen halten. Menschen mit ausführlicheren Sprachen können immer noch miteinander konkurrieren
— John La Rooy
2
Oh mein Gott, das ist beängstigend. Genau in diesem Moment wollte ich genau den gleichen Wettbewerb posten. : O
— Vincent
2
Gibt es Zeilenumbrüche in der Eingabedatei?
— Gabe

Antworten:

24

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
— pdehaan
quelle
2
Sehr schön! Sie haben es geschafft, ein paar spezialisierte Sprachen mit einer allgemeineren zu schlagen. :)
— hb2pencil
4
schreibt dies in 'out.txt'?
— AShelly
2
@b=<>=~/./gspart 3 weitere char
— mob
40

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"] &
Zur besseren Lesbarkeit hinzugefügte Leerzeichen

Rufen Sie mit auf

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

Animation:

Alt-Text

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

Alt-Text

Ein schönes Muster zum Generieren von Segelflugzeugen aus Wikipedia

aa

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

— Belisarius
quelle
1
Basierend auf der Animation scheint sich das nicht richtig zu entwickeln.
— Gnovice
62
Eine eingebaute CellularAutomatonFunktion scheint die Herausforderung zu meistern.
— AShelly
@gnovice yep. Es gab einen Fehler ... tnx!
— Dr. Belisarius
17
@AShelly Ich denke, Code-Golf-Herausforderungen können in beide Richtungen unternommen werden.> Optimieren Sie ein nicht gut angepasstes Werkzeug oder finden Sie ein gutes Werkzeug
— Dr. belisarius
2
@Adrian Verschiedene Herausforderungen in verschiedenen Sprachen. In Mathematica
— bereitet
33

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:

Alt-Text

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!
— gnovice
quelle
@AShelly: Nachdem ich ein bisschen mehr gegraben hatte, stellte ich fest, dass es möglich ist, MATLAB-Funktionen mit einer Befehlssyntax aufzurufen (was ich vorher nicht für möglich gehalten hatte). Ich habe diese andere Lösung zu meiner Antwort hinzugefügt. Es werden nur 6 Zeichen hinzugefügt.
— Gnovice
30

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.

— Mladen Jablanović
quelle
19
Warten Sie einfach, bis Perl Jungs kommen ...;)
— Mladen Jablanović
1
@ hb2pencil, Mladen, ich glaube nicht, dass eine Code-Golf-Antwort jemals akzeptiert wurde, bevor mindestens ein Perl-Eintrag eingereicht wurde :)
— John La Rooy
Ich sehe, dass sich die Konkurrenz verschärft, also werde ich warten. Vielen Dank!
— hb2pencil
Ich denke, Sie können 12 Zeichen subtrahieren, indem Sie die 3. Zeile durch ersetzen v<13?v:l==3||v-l==?T?X:?.}}. Aber ich habe nicht 1.9 installiert, um es zu testen.
— AShelly
Ich glaube nicht, dass man v(eine Zeichenfolge) mit einer Ganzzahl vergleichen kann .
— Mladen Jablanović
20

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))
— Gnibbler
quelle
6
Es bricht mir das Herz, wenn ich sehe, dass Python so verschleiert ist. P Gute Arbeit :)
— Ashley Grenon
1
Verschleiert? Ich fand das ziemlich sauber? ;)
— Kyle Rosendo
1
Aber 2.7 (und 3.x) akzeptieren geschweifte Klammern für das Mengenverständnis, set(...)können also durch ersetzt werden {...}, und das Ersetzen range(3e3)durch range(3000)ergibt eine Nettoverbesserung von 2 Zeichen.
— Don O'Donnell
20

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.

— P Papa
quelle
1
+1 Gut gemacht, Unicode ist ein faires Spiel für Codegolf auf SO - überhaupt keine "Art von Betrug"
— John La Rooy
open(f).readlines()sollte als gesetzt werden list(open(f)). Äquivalent und sechs Zeichen kürzer minimiert und 3 Bytes kürzer gezippt und seltsamerweise 4 Zeichen kürzer gezippt mit EOL bei EOF, was es 206 (gezippt mit EOL) und 228 (minimiert ohne EOL) macht.
— Chris Morgan
14

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
— Alexander Konstantinov
quelle
10

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

— Brian
quelle
Bitte reduzieren Sie es sehr, ich bin neugierig!
— Landei
10

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.

— AShelly
quelle
Zeilen in der Ausgabedatei scheinen nicht getrennt zu sein.
— Mladen Jablanović
Sie sind es nicht - aber sie werden perfekt in meiner 80-Zeichen-Konsole angezeigt.
— AShelly
Sie müssen Zeilenumbrüche haben. Es tut mir leid, dass ich nicht ausdrücklich darauf hingewiesen habe.
— hb2pencil
10

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();
 }
}
— Molehill
quelle
String statt char [] ist teurer, aber das spielt beim Code-Golf keine Rolle! Schön :)
— BalusC
Beachten Sie, dass die Gesamtlänge der Datei / Zeichen nicht 2754 Zeichen beträgt.
— BalusC
@BallusC Danke, ich habe es geschafft, nur 34 Zeilen anstatt aller 40 zu kopieren!
— Molehill
Das ist in der Tat ein echtes Erinnerungsfresser! Übrigens --ikann reingehen new char[i--*t]und b[l++]+=(char)jkann einfach sein b[l++]=(char)j. Das spart weitere 3 Zeichen.
— BalusC
Übrigens: Warum haben Sie das entfernt &n+j<s? Dies würde zu AIOBE führen, wenn die Eingabedatei wirklich 3240 Zeichen lang ist. Mehr Optimierung: Schauen Sie sich an, wie ich die Datei einlese char[], Ihre kann durch ersetzt werden while(l<t)b[l++]=(char)r.read();, spart 4 Zeichen.
— BalusC
9

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}}
— Landei
quelle
2
Du hast mich dazu gebracht, den Scala Wikipedia-Artikel zu lesen. Was für eine schöne Sprache! :)
— Vincent
2
Ja, so ist es. Es hat mein Leben verändert.
— Landei
7

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.

— Adrian Grigore
quelle
4
@Platinum Azure: Du meinst, jemand anderes hatte diese Idee schon einmal? Ehrlich gesagt habe ich es nicht in einem anderen Thread gesehen.
— Adrian Grigore
3
Nun, ich denke, große Köpfe denken gleich ;-). Im Gegensatz zur obigen Lösung kann meine Lösung jedoch praktisch alle Code-Golf-Herausforderungen lösen, während die obige nur "Hello World" drucken kann.
— Adrian Grigore
2
Es ist nicht vollständig, es kann keinen abstrakten Code interpretieren. Es funktioniert nicht unbedingt jedes Mal, da es möglicherweise nie eine gültige (Javascript-) Lösung gibt. Es sollte nicht auf Code Golf sein.
— Callum Rogers
2
Hey, das ist nur mein Dolmetscher. Enthalten die Javascript-Lösungen die Zeichenanzahl für die Javascript-Engine? ;-)
— Adrian Grigore
4
Ich dachte, das wäre ein Witz, bis ich alle ernsthaften Kommentare gelesen habe.
— Kirk.burleson
5

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)
— MooGoo
quelle
5

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);
}
— Maulwurfshügel
quelle
5

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
— Clayton
quelle
2
Das ist eine schreckliche Sprache. Schöne Anzahl an Charakteren.
— hb2pencil
4

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!

— BalusC
quelle
Sie können einfach den neuen FileWriter (out.txt) .write (c) verwenden, um einige Zeichen zu sagen. Leider können Sie nicht die gesamte Variable einspannen, da write () dies nicht zurückgibt. Wenn Sie eine Klasse zum Schreiben von Dateien finden, die dies tut, könnten erhebliche Einsparungen erzielt werden. Außerdem mag ich Ihre Verwendung von Würfen - alles, um diese schrecklichen erzwungenen Fänge zu vermeiden.
— Welpe
3

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
— Nathan
quelle
list ($ n, $ l) = $ _SERVER ['argv'];
— Don Wilson
ÄNDERUNG: $ o = fopen ("out.txt", "w"); fwrite ($ o, implode ("\ n", $ a)); fclose ($ o); TO: file_put_contents ("out.txt", implode ("\ n", $ a));
— Don Wilson
ÄNDERUNG: $ t = $ t-ord ($ v [$ i]); TO: $ t- = ord ($ v [$ i]);
— Don Wilson
ÄNDERUNG: $ t = $ t + ord ($ f [$ k + $ m] [$ i + $ h]); TO $ t + = ord ($ f [$ k + $ m] [$ i + $ h]);
— Don Wilson
2

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

— Paul Hurleyuk
quelle
2

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';}}
— invers
quelle
1
Einige Tipps: Sie müssen die Argumente nicht für main argc und argv aufrufen. Versuchen Sie stattdessen c und v. Versuchen Sie auch, den ternären Operator anstelle von if / else zu verwenden. Gut zu sehen, dass C ++ vertreten ist. :)
— hb2pencil
1

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

— Bogdev
quelle
1

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.

— Robert
quelle
1

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);
}
— OlivierH
quelle
1

é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>
— Redestructa
quelle
0

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

........................*...........
......................*.*...........
............**......**............**
...........*...*....**............**
**........*.....*...**..............
**........*...*.**....*.*...........
..........*.....*.......*...........
...........*...*....................
............**......................
— dbasnett
quelle
10
Ich denke, vielleicht haben Sie den Punkt der Code-Golf-Fragen falsch verstanden.
— Gnovice
Hier ist eine Sammlung von Mustern für den Fall, dass Sie süchtig werden, wie ich es vor einigen Jahren getan habe argentum.freeserve.co.uk/lex.htm
— dbasnett
@gnovice - nein, aber es war ein Thema, mit dem ich viel Spaß hatte. Die zellularen Automaten mögen eine lustige, kürzeste Codefrage sein, aber es ist auch ein lustiges Thema für sich. Ich werde jetzt raus.
— Dbasnett
1
Wenn Sie Erfahrung in einer Sprache haben, die hier nicht vertreten ist, empfehle ich Ihnen, einen Code-Golf-Eintrag einzureichen - alle werden geschätzt, auch wenn er in Bezug auf die Länge etwas hinter den anderen zurückbleibt. :)
— hb2pencil
Nur der Automatencode besteht aus fast 2000 Zeilen. Die Zeichnungs- / Bearbeitungsdatei (grafisch) / Musterdatei behandelt möglicherweise 2000 weitere. Also ich denke ich wäre
— überdurchschnittlich
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.