जीवन रंगीन हो सकता है!

Question

जीवन की तरह सेल्युलर ऑटोमोबोन की प्रत्येक कोशिका को केवल इसका प्रतिनिधित्व करने के लिए एक बिट की आवश्यकता होती है क्योंकि यह केवल जीवित या मृत हो सकती है। इसका मतलब है कि केवल दो रंग हैं; बहुत उबाऊ है।

सामान्य छवियों में 24 बिट प्रति पिक्सेल (आरजीबी में से प्रत्येक में 8) हैं। पिक्सल के साथ एक सामान्य छवि में इसका मतलब यह है कि कोशिकाओं को आप एक ही बार में 24 जीवन जैसे खेल का अनुकरण कर सकते हैं!

चुनौती

आपका कार्य एक प्रोग्राम लिखना है जो जीवन के नियमों की एक पीढ़ी-जैसे सेलुलर ऑटोमेटन को 24-बिट डेप्थ इमेज (किसी भी प्रसिद्ध प्रारूप में जो आपको पसंद है) पर लागू होगा, और परिणामी छवि को आउटपुट करेगा।

24 परतों में से प्रत्येक एक ही जीवन-समान नियम का उपयोग करेगा, सख्ती से यह अपनी परत के भीतर है। 24 परतें एक-दूसरे के साथ बातचीत नहीं करती हैं।

भी

• शून्य मृत कोशिकाएं हैं और जीवित कोशिकाएं हैं।
• सीमा की स्थिति आवधिक हैं (एक टोरस का गठन)।
• किसी भी छवि आयाम को काम करना चाहिए।

इनपुट आउटपुट

आपके कार्यक्रम को 3 तर्क में लेने की जरूरत है, स्टडिन या कमांड लाइन (या आपकी भाषा के निकटतम समकक्ष) के माध्यम से:

1. इनपुट छवि फ़ाइल का नाम।
2. बढ़ते हुए क्रम में 0 से 8 अंकों की एक स्ट्रिंग जो नई कोशिकाओं के पैदा होने पर निरूपित करती है:
   • यदि अंक d स्ट्रिंग में है तो मृत कोशिकाएं जीवित हो जाती हैं जब उनके पास d जीवित पड़ोसी होते हैं।
   • उदाहरण: 3सामान्य जीवन है - ठीक 3 जीवित पड़ोसियों के साथ मृत कोशिकाएं जीवन में आती हैं।
3. बढ़ते हुए क्रम में 0 से 8 अंकों की एक स्ट्रिंग जो मौजूदा कोशिकाओं के जीवित रहने पर दर्शाती है:
   • यदि अंक d स्ट्रिंग में है तो d जीवित पड़ोसियों के साथ जीवित कोशिकाएं अगली पीढ़ी तक जीवित रहती हैं, अन्यथा वे मर जाती हैं।
   • उदाहरण: 23सामान्य जीवन है - केवल 2 या 3 पड़ोसियों के साथ ही कोशिकाएं अगले दौर में जीवित रहती हैं।

ध्यान दें कि मूर पड़ोस हमेशा उपयोग किया जाता है। पढ़ें इस या इस का ठीक क्या एक जीवन की तरह आटोमैटिक मशीन और कई दिलचस्प rulesets को परिभाषित करता है के बारे में अधिक जानकारी के लिए।

1-पीढ़ी-बाद की आउटपुट छवि को या तो out.png(या bmpया जो भी) के रूप में प्रदर्शित या सहेजा जाना चाहिए ।

प्रस्तुत करने

बाइट्स में सबसे छोटा कोड जीतता है।

आपको कुछ गैर-तुच्छ नियमों के लिए कम से कम एक परीक्षण छवि और इसकी तीन तत्काल बाद की पीढ़ियों को शामिल करना आवश्यक है। यदि आप कुछ बेहतर नहीं सोच सकते तो अपने अवतार और सामान्य जीवन के नियमों का उपयोग करें।

यदि आप चाहें, तो आप इस गोस्पर ग्लाइडर गन का उपयोग कर सकते हैं, जहां केवल जीवित बिट्स हरी 128 परत में हैं (यह केवल सामान्य जीवन में काम करना सुनिश्चित करता है):

दिलचस्प दृश्यों या एनिमेशन को पोस्ट करने से बहुत प्रोत्साहन मिलता है।

Comments

मुझे लगता है कि यह एक डुप्लिकेट है - केवल नए हिस्से एक और फ़ाइल प्रारूप से पढ़ रहे हैं और परतों को विभाजित कर रहे हैं - दोनों बुनियादी हैं और खुद से कोई चुनौती नहीं है।

— हावर्ड

@ हावर्ड लेकिन क्या आप छवियों को देखने में रुचि नहीं रखते हैं?

हाँ। PPCG.SE दर्द और पीड़ा का एक स्थान है, मजेदार और सुंदर चित्र नहीं । यदि वह बोनस विचार को एक आवश्यकता बनाता है, तो निश्चित रूप से प्रश्न मूल रूप से पर्याप्त होना चाहिए?

— फ़्लैंक

समुदाय का स्पष्ट हित यह है कि कार्यक्रमों को अन्य प्रश्नों के उत्तर से मामूली बदलाव के साथ कॉपी-पेस्ट नहीं किया जाना चाहिए। यह साइट "मुझे लगता है कि यह मजेदार हो सकता है, इसलिए यह ठीक है" के आधार पर काम नहीं करता है। वह 4 का है।

— पीटर टेलर

@ मुझे नहीं लगता कि यह अब एक डुप्लिकेट के रूप में गिना जाता है। निश्चित रूप से अगर codegolf.stackexchange.com/questions/34505/simulate-rule-110 और codegolf.stackexchange.com/questions/4370/… सह-अस्तित्व कर सकते हैं तो यह बिल्कुल भी डुप्लिकेट नहीं है।

— केल्विन के शौक

Answer 1

MATLAB: 275

मेरे द्वारा कोशिश किए गए मापदंडों का मेरा पसंदीदा है 45678, 568जो क्रमिक विघटन के बाद टिमटिमाते तारों के एक आकाश में परिणाम करता है। यह छवि दर्शाती है, "स्मृति की दृढ़ता का विघटन।"

अस्वाभाविक gif- उत्पादन कोड (बिना विस्तार के PNG स्वीकार करता है):

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

गोल्फ कोड जो एक पूर्ण फ़ाइल नाम (जो GIF, JPEG और शायद अन्य सामान हो सकता है) को स्वीकार करता है और उसे लिखता है 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')

एक पहले की खोज की तथ्य यह है कि मानकों है 12, 1एक सिएरपिन्स्की कालीन की तरह भग्न उत्पन्न करने के लिए इस्तेमाल किया जा सकता। यहाँ प्रत्येक बिट में एक बेतरतीब ढंग से रखा बीज बिंदु है:

Answer 2

गणितज्ञ, ३५ ९

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

मैं क्रम (1) जन्म नियमों में स्ट्रिंग संकेतों से इनपुट ले रहा हूं, (2) उत्तरजीविता नियम, (3) फ़ाइल नाम, और मैं मैथमेटिका में परिणाम सही प्रदर्शित कर रहा हूं।

यह सबसे लोकप्रिय प्रारूपों से निपटने में सक्षम होना चाहिए, जब तक कि फ़ाइल में वास्तव में 24-बिट गहराई हो।

यहाँ कुछ असम्बद्ध संस्करण है:

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

यहाँ दो उदाहरण Rainbolt अवतार का उपयोग कर रहे हैं :

जीवन के मानक खेल का उपयोग करते हुए 20 पीढ़ियाँ [3,23]:

20 पीढ़ियों का उपयोग [456,34567]:

और यहाँ बाद के शासन की पहली 200 पीढ़ियों का GIF है। जीआईएफ हर तीसरे फ्रेम को छोड़ देता है, क्योंकि मैं इसे 2 एमबी से कम नहीं कर सकता था, अन्यथा:

Comments

क्या एक दिलचस्प नियम

— पर हेकेलर सेप

Answer 3

अजगर 2, 427

उन लोगों के लिए जिनके पास गणित नहीं है;)

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

यह फ़ाइल नाम, फिर जन्म के मामलों, फिर जीवित रहने के मामलों के लिए संकेत देता है। तो सामान्य जीवन नियमों के लिए, आप इनपुट कर सकते हैं test.bmp, फिर 3, 23(कोई उद्धरण या आवश्यक कुछ भी नहीं)।

मैंने स्ट्रिंग फ़ॉर्मेटिंग का उपयोग अनुक्रमित करने के लिए किया और रंग बिट्स को पुन: संयोजित किया, हालांकि मुझे डर है कि शायद इष्टतम नहीं है।

ध्यान दें कि यह बहुत धीमा है।

उदाहरण

उच्च जीवन और महान कला का मिश्रण सही है? (नियम 36/ 23।)

मूल / पीढ़ी १

जनरेशन 2 / जनरेशन 3

Answer 4

जावा, 1085 बाइट्स

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

उदाहरण (नियम 368/245):

जनरल 0:

जनरल 1:

जनरल 2:

जनरल 3:

जनरल 4: