La sfida

Devi scrivere un programma completo che prende sette numeri da STDIN e stampa la storia bidimensionale dell'automa cellulare (CA) su STDOUT. Questo è il codice golf.

Formattazione dell'input L'input sarà di sette numeri interi / stringhe separati da virgole. Il primo numero è il numero della regola in base al codice Wolfram (il nome standard per ciascuna regola). La seconda è la configurazione iniziale iniziale. Il terzo e il quarto descrivono quale modello e quante volte deve essere aggiunto a sinistra della configurazione iniziale. come imbottitura. Il quinto e il sesto fanno lo stesso per il lato destro. L'ultimo numero è il numero di generazioni per eseguire la simulazione.

Quindi, un esempio di input è 90,11,0,4,0,4,5. Questo dovrebbe dire al tuo programma che stai eseguendo la regola 90 . Dovrebbe anche indicare al programma che si desidera che la configurazione iniziale sia 11con la stringa 0aggiunta 4 volte ad entrambe le estremità, quindi il modello iniziale effettivo è 0000110000. Indica inoltre al programma di eseguire questa simulazione per 5 generazioni.

Output Il programma deve stampare l'intera matrice di celle ogni generazione (separate da nuove righe), in modo che l'output sia il diagramma spazio-temporale della CA. Per ogni generazione, lo stato di ogni cella è determinato dal suo stato e dagli stati delle celle a sinistra e a destra immediate, secondo la regola fornita come input. La simulazione dovrebbe avvolgere i bordi. La prima cosa stampata dovrebbe essere l'array iniziale come gen. 0.

L'input 90,11,0,4,0,4,5dovrebbe risultare nel seguente output nel modo più preciso possibile.

0000110000
0001111000
0011001100
0111111110
1100000011
0110000110

Si noti che lo stato iniziale non è incluso nelle cinque generazioni. Si noti inoltre che la simulazione si avvolge attorno ai bordi.

Altri esempi

ingresso:

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

produzione:

0101110001
1011101000
0111010100
0110101010
0101010101

ingresso:

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

produzione:

10110
00000
00000

Ulteriori informazioni su come funzionano le CA 1D e su come sono numerate

Golfscript, 77 73 70 caratteri

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

Grazie a @Howard, che ha sottolineato come salvare 4 caratteri.

APL (153 caratteri)

∇ 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]
∇

E in forma meno leggibile, leggermente più corta:

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

Esempio:

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

Sono certo che ci sono margini di miglioramento (ho anche trovato alcune modifiche durante la scrittura di questo post!), Ma alcune di queste potrebbero comportare cambiamenti fondamentali e non sopporto più di fissare APL. La variante di APL utilizzata qui è Dyalog APL .

Rubino, 165 159 caratteri

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

Modifica: ho trovato alcuni posti per piccoli miglioramenti.

Esempio di esecuzione:

> 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 Modifica: oops. Dimenticato quellocalloc() vogliono due discussioni. Stava esplodendo con input più grandi.

301 Modifica: Ah HA! Usato miocalloc() boo-boo per salvare altri 2 byte aumentando la dimensione del blocco della memoria richiesta.

294 Modifica: rotto 300! Eliminato uno deistrcat() ottimizzato alcuni loop. Devo usare il munch massimo, che è tanto divertente da dire quanto l'uso.

292 Modifica: non è necessario +2 allocazione in memoria.

Ho usato la risposta di luser droog come idea di base, ma ho modificato l'algoritmo di wrapping, nonché un sacco di modifiche e factoring al di fuori delle costanti.

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 con spazi rimossi)

* Dropped 66 con l'aiuto di 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);
}

dattiloscritto

josh @ Z1 ~
$! m
fare ca
cc ca.c -o ca
ca.c: 1: 1: avviso: la definizione dei dati non ha tipo o classe di archiviazione
ca.c: in funzione 'principale':
ca.c: 2: 5: avviso: dichiarazione implicita incompatibile della funzione integrata 'scanf'
ca.c: 3: 7: avviso: dichiarazione implicita incompatibile della funzione integrata 'malloc'
ca.c: 3: 14: avviso: dichiarazione implicita incompatibile della funzione integrata 'strlen'
ca.c: 4: 5: avviso: dichiarazione implicita incompatibile della funzione integrata 'strcat'

josh @ Z1 ~
$ echo 90,11,0,4,0,4,5 | circa
-bash: ca: comando non trovato

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