Die Herausforderung

Sie müssen ein vollständiges Programm schreiben, das aus STDIN sieben Zahlen entnimmt und die zweidimensionale Historie des Zellularautomaten (CA) an STDOUT ausgibt. Das ist Code Golf.

Eingabeformatierung der Eingabe handelt es sich um sieben durch Kommas getrennte Ganzzahlen / Zeichenfolgen. Die erste Zahl ist die Nummer der Regel gemäß Wolfram-Code (der Standardname für jede Regel). Die zweite ist die anfängliche Startkonfiguration. Die dritten und vierten beschreiben, welches Muster und wie oft es links von der Startkonfiguration angehängt werden soll. als Polsterung. Der fünfte und sechste machen dasselbe für die rechte Seite. Die letzte Zahl ist die Anzahl der Generationen, um die Simulation auszuführen.

Ein Beispiel für eine Eingabe ist also 90,11,0,4,0,4,5. Dies sollte Ihrem Programm mitteilen, dass Sie Regel 90 ausführen . Es sollte dem Programm auch mitteilen, dass bei der Erstkonfiguration 11die Zeichenfolge 0viermal an beide Enden angehängt werden soll, sodass das eigentliche Startmuster lautet 0000110000. Außerdem wird Ihr Programm angewiesen, diese Simulation für 5 Generationen auszuführen.

Ausgabe Ihr Programm sollte das gesamte Array von Zellen jeder Generation (durch Zeilenumbrüche getrennt) drucken, damit die Ausgabe das Raum-Zeit-Diagramm der Zertifizierungsstelle ist. Für jede Generation wird der Zustand jeder Zelle durch ihren Zustand und die Zustände der Zellen unmittelbar links und rechts gemäß der als Eingabe bereitgestellten Regel bestimmt. Die Simulation sollte sich um die Kanten wickeln. Das erste, was gedruckt wird, sollte das Startarray als gen sein. 0.

Die Eingabe 90,11,0,4,0,4,5sollte so genau wie möglich zur folgenden Ausgabe führen.

0000110000
0001111000
0011001100
0111111110
1100000011
0110000110

Beachten Sie, dass der Ausgangszustand in den fünf Generationen nicht enthalten ist. Beachten Sie auch, dass sich die Simulation um die Kanten schlängelt.

Mehr Beispiele

Eingang:

184,1100,01,2,01,1,4

Ausgabe:

0101110001
1011101000
0111010100
0110101010
0101010101

Eingang:

0,1011,1,0,0,1,2

Ausgabe:

10110
00000
00000

Weitere Informationen zur Funktionsweise und Nummerierung von 1D CAs

Golfscript, 77 73 70 Zeichen

','/)~\(~:?;~~*@@~*@+\+{1&}/]({[.,{.[3<?256+]{2base}/\~=\(+}*])n@)\+}*

Vielen Dank an @Howard, der darauf hingewiesen hat, wie man 4 Zeichen spart.

APL (153 Zeichen)

∇ cellularautomaton
  i               ← ⍞
  s               ← (i=',') / ⍳ ⍴i
  (b a x c)       ← {i[s[⍵]↓⍳s[⍵+1]-1]} ¨ ⍳4
  (z x x l x r n) ← ⍎i
  y               ← ⍎ ¨ ⊃ ,/ (l / ⊂a) , b , r / ⊂c
  (n+1) (⊃⍴,y) ⍴ '01'[1+⊃ ,/ y,{({(z ⊤⍨ 8/2)[8 - 2⊥¨ 3 ,/ (⊃⌽⍵),⍵,⊃⍵]}⍣⍵)y} ¨ ⍳n]
∇

Und in weniger lesbarer, etwas kürzerer Form:

i←⍞⋄s←(i=',')/⍳⍴i⋄b a x c←{i[s[⍵]↓⍳s[⍵+1]-1]}¨⍳4⋄z x x l x r n←⍎i⋄y←⍎¨⊃,/(l/⊂a),b,r/⊂c⋄'01'[1+⊃,/y,{({(z⊤⍨8/2)[8-2⊥¨3,/(⊃⌽⍵),⍵,⊃⍵]}⍣⍵)y}¨⍳n]⍴⍨(1+n),⊃⍴,y

Beispiel:

      cellularautomaton
26,00110,01,4,10,6,7
0101010100110101010101010
1000000011100000000000001
0100000110010000000000011
0010001101101000000000110
0101011001000100000001101
0000010110101010000011000
0000100100000001000110100
0001011010000010101100010

Ich bin sicher, dass es Raum für Verbesserungen gibt (ich habe sogar ein paar Änderungen gefunden, als ich diesen Beitrag geschrieben habe!), Aber einige davon könnten grundlegende Änderungen beinhalten, und ich kann es nicht mehr ertragen, APL anzustarren. Die hier verwendete Variante von APL ist Dyalog APL .

Ruby, 165 159 Zeichen

a=gets.split ?,
b=a.map &:to_i
c=(x=a[2]*b[3]+a[1]+a[4]*b[5]).chars.map &:hex
(0..b[6]).map{puts c*''
c=(1..w=x.size).map{|i|b[0]>>c[i-1]*2+c[i%w]+c[i-2]*4&1}}

Bearbeiten: Ich habe einige Stellen für kleine Verbesserungen gefunden.

Beispiellauf:

> 30,1,0,20,0,20,20
00000000000000000000100000000000000000000
00000000000000000001110000000000000000000
00000000000000000011001000000000000000000
00000000000000000110111100000000000000000
00000000000000001100100010000000000000000
00000000000000011011110111000000000000000
00000000000000110010000100100000000000000
00000000000001101111001111110000000000000
00000000000011001000111000001000000000000
00000000000110111101100100011100000000000
00000000001100100001011110110010000000000
00000000011011110011010000101111000000000
00000000110010001110011001101000100000000
00000001101111011001110111001101110000000
00000011001000010111000100111001001000000
00000110111100110100101111100111111100000
00001100100011100111101000011100000010000
00011011110110011100001100110010000111000
00110010000101110010011011101111001100100
01101111001101001111110010001000111011110
11001000111001111000001111011101100010001

C 303 305 301 294 292

305 Edit: oops. Ich habe vergessen, dass calloc()das zwei Argumente erfordert. Es explodierte bei größerem Input.

301 Edit: Ah HA! Benutzt my calloc()boo-boo, um 2 weitere Bytes zu sparen, indem die Blockgröße des angeforderten Speichers erhöht wird.

294 Edit: 300 gebrochen! Beseitigte eines der strcat()s und optimierte ein paar Schleifen. Ich muss maximal munch verwenden, was genauso viel Spaß macht wie use.

292 Edit: Benötigte die +2Zuweisung im Speicher nicht.

Ich benutzte die Antwort von luser droog als Grundidee, änderte aber den Wrapping-Algorithmus sowie viele Optimierungen und Faktorisierungen von Konstanten.

r,A,C,n,j;main(){char*s,*p,*t,a[9],b[9],c[9];scanf("%d,%[01],%[01],%d,%[01],%d,%d",&r,b,a,&A,c,&C,&n);for(s=calloc(A+++C,9);A--;)strcat(s,A?a:b);for(;C--;)strcat(s,c);p=strdup(s);for(C=strlen(s);A++<n;puts(s),t=p,p=s,s=t)for(j=C;j--;)p[j]=(1<<(s[j?j-1:C-1]*4+s[j]*2+s[(j+1)%C])-336)&r?49:48;}

r,A,C,n,j;
main(){
    char*s,*p,*t,a[9],b[9],c[9];
    scanf("%d,%[01],%[01],%d,%[01],%d,%d",&r,b,a,&A,c,&C,&n);
    for(s=calloc(A+++C,9);A--;)
        strcat(s,A?a:b);
    for(;C--;)
        strcat(s,c);
    p=strdup(s);
    for(C=strlen(s);A++<n;puts(s),t=p,p=s,s=t)
        for(j=C;j--;)
            p[j]=(1<<(s[j?j-1:C-1]*4+s[j]*2+s[(j+1)%C])-336)&r?49:48;
}

C (487 484 418 mit Leerzeichen entfernt)

* Fiel 66 mit Hilfe von JoeFish *

C,A,r,n,j;main(){char*s,*p,*t,a[9],b[9],c[9];
    scanf("%d,%[01],%[01],%d,%[01],%d,%d",&r,b,a,&A,c,&C,&n);
    s=malloc(strlen(a)*A+strlen(b)+strlen(c)*C+3);*s=0;
    strcat(s,"0");
    for(;A--;)strcat(s,a);
    strcat(s,b);
    for(;C--;)strcat(s,c);
    strcat(s,"0");
    p=malloc((C=strlen(s)-1)+2);
    for(;n--;){
    *s=s[C-1];
    s[C]=0;
    puts(s+1);
    s[C]=s[1];
    for(j=1;s[j+1];j++)
        p[j]=(1<<(s[j-1]-48)*4+(s[j]-48)*2+s[j+1]-48)&r?49:48;
    t=p;p=s;s=t;
    }
    s[C]=0;
    puts(s+1);
}

Typoskript

Josh @ Z1 ~
$! m
machen ca
cc ca.c -o ca
ca.c: 1: 1: Warnung: Die Datendefinition hat keinen Typ oder keine Speicherklasse
ca.c: In der Funktion 'main':
ca.c: 2: 5: Warnung: Inkompatible implizite Deklaration der eingebauten Funktion 'scanf'
ca.c: 3: 7: Warnung: Inkompatible implizite Deklaration der eingebauten Funktion 'malloc'
ca.c: 3: 14: Warnung: Inkompatible implizite Deklaration der eingebauten Funktion 'strlen'
ca.c: 4: 5: Warnung: Inkompatible implizite Deklaration der eingebauten Funktion 'strcat'

Josh @ Z1 ~
$ echo 90,11,0,4,0,4,5 | ca
-bash: ca: Befehl nicht gefunden

Josh @ Z1 ~
$ echo 90,11,0,4,0,4,5 | ./ca
0000110000
0001111000
0011001100
0111111110
1100000011
0110000110