Ogni cellula in un automa cellulare simile alla vita ha bisogno solo di un po 'di rappresentarlo poiché può essere solo viva o morta. Ciò significa che ci sono solo due colori; piuttosto noioso.

Le immagini normali hanno 24 bit per pixel (8 in ciascuno di RGB). Ciò significa che in un'immagine normale con pixel come celle potresti simulare 24 giochi realistici contemporaneamente!

Sfida

Il tuo compito è quello di scrivere un programma che applicherà una generazione delle regole di un automa cellulare realistico a un'immagine di profondità a 24 bit (in qualsiasi formato ben noto che ti piace) e produrre l'immagine risultante.

Ognuno dei 24 layer utilizzerà lo stesso set di regole realistiche, rigorosamente all'interno del proprio layer. I 24 livelli non interagiscono tra loro.

Anche

• Gli zeri sono cellule morte e quelli sono cellule vive.
• Le condizioni al contorno sono periodiche (formano un toro).
• Qualsiasi dimensione dell'immagine dovrebbe funzionare.

Input Output

Il tuo programma deve contenere 3 argomenti, tramite stdin o riga di comando (o l'equivalente più vicino della tua lingua):

1. Il nome del file immagine di input.
2. Una stringa delle cifre da 0 a 8 in ordine crescente che indica quando nascono nuove celle:
   • Se la cifra d è nella stringa allora le cellule morte animarsi quando hanno d vicini viventi.
   • Esempio: 3è vita normale - Le cellule morte con esattamente 3 vicini viventi prendono vita.
3. Una stringa delle cifre da 0 a 8 in ordine crescente che indica quando sopravvivono le celle esistenti:
   • Se la cifra d è nella stringa allora cellule viventi con d vicini viventi sopravvivono alla generazione successiva, altrimenti muoiono.
   • Esempio: 23è vita normale - Solo le cellule con esattamente 2 o 3 vicini sopravvivono al turno successivo.

Si noti che il quartiere di Moore viene sempre utilizzato. Leggi questo o questo per maggiori informazioni su ciò che definisce con precisione un automa realistico e molti interessanti set di regole.

L'immagine di output di 1 generazione successiva deve essere visualizzata o salvata come out.png( bmpo qualsiasi altra cosa).

Presentazione

Vince il codice più breve in byte.

Per alcune serie di regole non banali è necessario includere almeno un'immagine di prova e le sue tre generazioni successive immediate. Usa il tuo avatar e le normali regole di vita se non riesci a pensare a qualcosa di meglio.

Se ti piace, puoi usare questa Gosper Glider Gun in cui gli unici frammenti viventi sono nel livello verde 128 (funzionerà solo nella vita normale):

Pubblicare sequenze interessanti o persino animazioni è fortemente incoraggiato.

MATLAB: 275

Il mio preferito dei parametri che ho provato è 45678, 568che a seguito di una graduale disintegrazione si traduce in un cielo di stelle scintillanti. Questa immagine raffigura "la disintegrazione della persistenza della memoria".

Codice di produzione gif senza licenza (accetta PNG senza estensione):

B = input('B', 's') - 48;
S = input('S', 's') - 48;
f0 = input('file: ', 's');
frames = 60;

f = sprintf('%s.png',f0);
fout = sprintf('%s.gif',f0);
first = 1;
img = imread(f);
for i = 1:60
    out = img * 0;
    [r, c, turd] = size(img);
    for b=0:7
        bimg = ~~bitand(img,2^b);
        pimg = [bimg,bimg,bimg;bimg,bimg,bimg;bimg,bimg,bimg];
        fun = @(ro,co) pimg(r+ro:r+r+ro-1,c+co:c+c+co-1,:);
        sum = fun(0,0)+fun(0,1)+fun(0,2)+fun(1,0)+fun(1,2)+fun(2,0)+fun(2,1)+fun(2,2);
        bnew = uint8(bimg & ismember(sum,S) | ~bimg & ismember(sum, B));
        out = out + 2^b * bnew;
    end
    %imwrite(out,'out.png');
       if first
           [img1,img2] = rgb2ind(img,256);
           imwrite(img1,img2,fout,'gif','Loop',Inf);
          imwrite(img1,img2,fout,'gif','WriteMode','append');
           first = 0;
       end
       img = out;
       [img1,img2] = rgb2ind(img,256);
       imwrite(img1,img2,fout,'gif','WriteMode','append');%,'DelayTime', 2*delay);
end

Codice golfed che accetta un nome file completo (che può essere GIF, JPEG e forse altre cose) e scrive in out.png:

I=@()input('','s');B=I();S=I();i=imread(I());o=0;[r,c,t]=size(i);for b=0:7
g=~~bitand(i,2^b);p=repmat(g,3);F=@(z,Z)p(r+z:r+r+z-1,c+Z:c+c+Z-1,:);M=@(A)ismember(F(0,0)+F(0,1)+F(0,2)+F(1,0)+F(1,2)+F(2,0)+F(2,1)+F(2,2),A-48);o=o+2^b*uint8(g&M(S)|~g&M(B));end
imwrite(o,'out.png')

Un fatto in precedenza scoperto è che i parametri 12, 1possono essere utilizzati per generare un Sierpinski tappeto-come frattale. Eccone uno con un punto seme posizionato casualmente in ogni bit:

Mathematica, 359

i=InputString;f=Transpose;b=(p=FromDigits/@Characters@#&)@i[];s=p@i[];Map[FromDigits[#,2]&/@#~ArrayReshape~{3,8}&,f[(g=#;{#,Total[g~RotateRight~#&/@Drop[Join@@Table[{i,j},{i,-1,1},{j,-1,1}],{5}],1]}~f~{3,1,2}/.{l_,n_}:>Boole[l<1&&!b~FreeQ~n||l>0&&!s~FreeQ~n])&/@Apply[Join,IntegerDigits[ImageData[Import@i[],y="byte"],2,8],{2}]~f~{2,3,1},{3,1,2}],{2}]~Image~y

Sto ricevendo input dai prompt di stringa nell'ordine (1) regole di nascita, (2) regole di sopravvivenza, (3) nome del file e sto visualizzando il risultato proprio in Mathematica.

Questo dovrebbe essere in grado di gestire i formati più diffusi, purché il file abbia effettivamente una profondità di 24 bit.

Ecco una versione in qualche modo ungolfed:

i = InputString;
f = Transpose;
b = (p = FromDigits /@ Characters@# &)@i[];
s = p@i[];
Map[
  FromDigits[#,2] & /@ #~ArrayReshape~{3, 8} &,
  f[
   (
      g = #;
      {#, 
         Total[g~RotateRight~# & /@ 
           Drop[Join @@ Table[{i, j}, {i, -1, 1}, {j, -1, 1}], {5}], 
          1]}~f~{3, 1, 2} /. {l_, n_} :> 
        Boole[l < 1 && ! b~FreeQ~n || l > 0 && ! s~FreeQ~n]
      ) & /@ 
    Apply[Join, 
      IntegerDigits[ImageData[Import@i[], y = "byte"], 2, 8], {2}]~
     f~{2, 3, 1},
   {3, 1, 2}
   ],
  {2}
  ]~Image~y

Ecco due esempi usando l'avatar di Rainbolt :

20 generazioni usando il Game of Life standard [3,23]:

20 generazioni usando [456,34567]:

Ed ecco una GIF delle prime 200 generazioni di quest'ultima regola. La GIF salta ogni terzo fotogramma, perché altrimenti non potrei comprimerlo al di sotto di 2 MB:

Python 2, 427

Per coloro che non hanno Mathematica;)

import Image as I
t=raw_input
r=range
A=I.open(t())
G=map(int,t())
S=map(int,t())
w,h=A.size
B=I.new('RGB',(w,h))
A=[[map(int,("{:08b}"*3).format(*A.load()[x,y]))for y in r(h)]for x in r(w)]
for x in r(w):
 for y in r(h):
  p=''
  for i in r(24):
    c=A[x][y][i]
    n=sum(A[(x+k-1)%w][(y+j-1)%h][i]for j in r(3)for k in r(3))-c
    p+=str(~~[n in G,n in S][c])
  B.load()[x,y]=tuple(int(p[i*8:i*8+8],2)for i in r(3))
B.save('out.bmp')

Richiede il nome file, quindi i casi di nascita, quindi i casi di sopravvivenza. Quindi, per le normali regole di vita, potresti inserire test.bmp, quindi 3, 23(senza virgolette o nulla di necessario).

Ho usato la formattazione delle stringhe per indicizzare e ricombinare i bit di colore, anche se temo che probabilmente non sia ottimale.

Nota che è piuttosto lento.

Esempio

Vita alta e grande arte si mescolano giusto? (Regola 36/ 23.)

Originale / Generazione 1

Generazione 2 / Generazione 3

Java, 1085 byte

import java.awt.image.*;import java.io.*;import javax.imageio.*;class F{static int n(boolean[][][]a,int x,int y,int z){int k=0;for(X=Math.max(x-1,0);X<Math.min(x+2,w);X++)for(Y=Math.max(y-1,0);Y<Math.min(y+2,h);Y++)if(a[X][Y][z])k++;return k-(a[x][y][z]?1:0);}static int p(String k){return Integer.parseInt(k,2);}static int w,h,x,y,z,X,Y;public static void main(String[]a)throws Exception{BufferedImage i=ImageIO.read(new File(a[0]));w=i.getWidth();h=i.getHeight();boolean[][][]G=new boolean[w][h][24];for(x=0;x<w;x++)for(y=0;y<h;y++){String k="".format("%24s",Integer.toBinaryString(0xFFFFFF&i.getRGB(x,y)));for(z=0;z<24;z++){G[x][y][z]=k.charAt(z)>48;}}for(x=0;x<w;x++)for(y=0;y<h;y++){String r="",g="",b="",k;for(z=0;z<8;){k=""+n(G,x,y,z);r+=(-1!=(G[x][y][z++]?a[1].indexOf(k):a[2].indexOf(k)))?1:0;}for(;z<16;){k=""+n(G,x,y,z);g+=(-1!=(G[x][y][z++]?a[1].indexOf(k):a[2].indexOf(k)))?1:0;}for(;z<24;){k=""+n(G,x,y,z);b+=(-1!=(G[x][y][z++]?a[1].indexOf(k):a[2].indexOf(k)))?1:0;}i.setRGB(x,y,new java.awt.Color(p(r),p(g),p(b)).getRGB());}ImageIO.write(i,"png",new File("out.png"));}}

Esempi (regola 368/245):

Gen 0:

Gen 1:

Gen 2:

Gen 3:

Gen 4: