जीवन के नियमों को बदलें

Question

जीवन की तरह सेलुलर ऑटोमेटोन सेलुलर ऑटोमेटोन हैं जो कॉनवे के गेम ऑफ लाइफ के समान हैं, इसमें वे (सैद्धांतिक रूप से) बड़े पैमाने पर बड़े वर्ग ग्रिड पर काम करते हैं, जहां प्रत्येक सेल में ठीक 8 पड़ोसी होते हैं, और 2 राज्यों में से एक है, अर्थात् जीवित और मृत। ।

हालाँकि, ये लाइक-जैसे संस्करण एक महत्वपूर्ण तरीके से भिन्न होते हैं: किसी दिए गए सेल के नियम जीवित रहते हैं और किसी दिए गए सेल के नियम अगली पीढ़ी के लिए जीवित रहते हैं।

उदाहरण के लिए, क्लासिक गेम ऑफ लाइफ नियम का उपयोग करता है B3/S23, जिसका अर्थ है कि एक नया जन्म लेने के लिए 3 जीवित कोशिकाएं लेता है, और जीवित रहने के लिए या तो 2 या 3 जीवित पड़ोसी। इस चुनौती के लिए, हम मान लेंगे कि पड़ोसियों में खुद को शामिल नहीं किया गया है, इसलिए प्रत्येक सेल में ठीक 8 पड़ोसी हैं।

आपका कार्य है, एक प्रारंभिक कॉन्फ़िगरेशन, एक जन्म नियम, एक उत्तरजीविता नियम और एक धनात्मक पूर्णांक (चलाने के लिए पीढ़ियों की संख्या), उन नियमों का उपयोग करते हुए जीवन-संबंधी ऑटोमेटन का अनुकरण करें, जो कम से कम संभव कोड में दी गई पीढ़ियों की संख्या के लिए उपयोग करते हैं। । प्रारंभिक कॉन्फ़िगरेशन एक वर्ग मैट्रिक्स / 2-आयामी सरणी या एक बहु-तार स्ट्रिंग होगा, जिसे आप चुन सकते हैं। दूसरों को किसी भी उचित प्रारूप और विधि में दिया जा सकता है।

उदाहरण के लिए, यदि जन्म नियम 12345678(कोई जीवित पड़ोसी) था, तो जीवित रहने का नियम था 2357और शुरुआती कॉन्फ़िगरेशन था

0 0 0 0 0
0 0 0 0 0
0 0 1 0 0
0 0 0 0 0
0 0 0 0 0

अगली दो पीढ़ियाँ होंगी

Generation 1:           Generation 2:

0 0 0 0 0               1 1 1 1 1
0 1 1 1 0               1 1 0 1 1
0 1 0 1 0               1 0 1 0 1
0 1 1 1 0               1 1 0 1 1
0 0 0 0 0               1 1 1 1 1

यदि दी गई पीढ़ियों की संख्या 10 थी, तो उत्पादन कुछ लाइनों के साथ होगा

0 1 1 1 0
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
0 1 1 1 0

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

यह एक कोड-गोल्फ है इसलिए सबसे छोटा कोड जीतता है।

परीक्षण के मामलों

ये उपयोग B/Sकिए गए नियमों को इंगित करने के लिए नोटेशन का उपयोग करते हैं

B2/S2, generations = 100कॉन्फ़िगरेशन:

1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0

आउटपुट:

0 0 0 0 0 0 0 0
0 1 0 0 0 0 1 0
1 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0

---

B1357/S2468, generations = 12कॉन्फ़िगरेशन:

1 0 1 0 1 0
0 1 1 0 1 0
1 0 0 0 0 0
0 0 0 0 0 1
1 1 1 1 1 0
0 1 1 0 0 1

आउटपुट:

0 1 0 0 0 0
0 1 1 1 1 0
0 1 0 1 1 0
1 1 1 0 0 0
0 0 1 1 1 0
0 1 1 0 0 0

यदि आपको अधिक परीक्षण मामलों को उत्पन्न करने की आवश्यकता है, तो आप इस अद्भुत सिम्युलेटर का उपयोग कर सकते हैं । कृपया बोर्ड आकार को सीमित करना सुनिश्चित करें

Comments

क्या सिमुलेशन टॉरॉयडल है?

— आउटगॉल्फ

@EriktheOutgolfer नहीं, जैसा कि मैट्रिक्स (सैद्धांतिक रूप से) आकार में अनंत है

— caird coinheringaahing

इसके अलावा, क्या हम मान सकते हैं कि दी गई मैट्रिक्स वर्गाकार है?

— एर्गेल्फ़र

@EriktheOutgolfer "असीम रूप से बड़े चौकोर ग्रिड"

— caird coinheringaahing

लेकिन यह नहीं कहता कि आप यह मान सकते हैं कि ... में संपादन करेंगे।

— एरिक आउटगोल्फर

Answer 1

MATL , 24 23 बाइट्स

xx:"tt3Y6Z+1Gm<8M2Gmb*+

इनपुट हैं:

• जन्म के नियम के साथ सरणी
• अस्तित्व के नियम के साथ सरणी
• पीढ़ियों की संख्या
• ;पंक्ति विभाजक के रूप में उपयोग करते हुए, प्रारंभिक सेल विन्यास के साथ मैट्रिक्स ।

इसे ऑनलाइन आज़माएं! या परीक्षण के मामले देखें: 1 , 2 ।

कुछ बाइट्स के लिए आप ASCII कला में विकास देख सकते हैं ।

व्याख्या

xx      % Take two inputs implicitly: birth and survival rules. Delete them
        % (but they get copied into clipboard G)
:"      % Take third input implicitly: number of generations. Loop that many times
  tt    %   Duplicate twice. This implicitly takes the initial cell configuration
        %   as input the first time. In subsequent iterations it uses the cell 
        %   configuration from the previous iteration
  3Y6   %   Push Moore neighbourhood: [1 1 1; 1 0 1; 1 1 1]
  Z+    %   2D convolution, maintaining size
  1G    %   Push first input from clipboard G: birth rule
  m     %   Ismember: gives true for cells that fulfill the birth rule
  <     %   Less than (element-wise): a cell is born if it fulfills the birth rule
        %   *and* was dead
  8M    %   Push result of convolution again, from clipboard M
  2G    %   Push second input from clipboard G: survival rule
  m     %   Ismember: gives true for cells that fulfill the survival rule
  b     %   Bubble up the starting cell configuration
  *     %   Multiply (element-wise): a cell survives if it fulfills the survival
        %   rule *and* was alive
  +     %   Add: a cell is alive if it has been born or has survived, and those
        %   are exclusive cases. This produces the new cell configuration
        % Implicit end loop. Implicit display

Comments

क्या आप इनपुट के क्रम को बदलकर बाइट्स बचा सकते हैं? xxशुरू में मेरे लिए एक सा बेकार लगता है ...

— एरिक Outgolfer

@EriktheOutgolfer मैं नहीं देखता कि कैसे। मुझे पहले दो को बाद में उन्हें कई बार (एक प्रति पुनरावृत्ति) पुन: उपयोग करने की आवश्यकता है, और अन्य इनपुट पहले से ही अब निहित हैं

— लुइस मेंडू

ओह तो "डिलीट" इनपुट्स उन्हें किसी प्रकार की इनपुट सूची में जोड़ता है?

— एर्ग आउटफोलर

@EriktheOutgolfer हां। MATL इनपुट इंटरेक्टिव है, जिसका अर्थ है कि प्रोग्राम को पहले से पता नहीं है कि कितने इनपुट हैं। यहां, खाली स्टैक को हटाने से इनपुट को स्पष्ट रूप से लिया जाता है। एक बार लेने के बाद, प्रत्येक इनपुट को क्लिपबोर्ड G में कॉपी किया जाता है, और उन्हें बाद में पुनर्प्राप्त किया जा सकता है।

— लुइस मेंडो

Answer 2

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 144 122 बाइट्स

CellularAutomaton[{Tr[2^#&/@Flatten@MapIndexed[2#+2-#2[[1]]&,{#2,#3},{2}]],{2,{{2,2,2},{2,1,2},{2,2,2}}},{1,1}},#,{{#4}}]&

इसे ऑनलाइन आज़माएं!

उदाहरण का उपयोग:

%[RandomInteger[1, {10, 10}], {2, 3}, {3}, 5]

एक शुरुआत के रूप में 10x10 यादृच्छिक ग्रिड का उपयोग करता है, 2 या 3 पड़ोसियों के साथ जीवित रहता है, 3 पड़ोसियों के साथ जन्म लेता है, 5 पुनरावृत्तियों पर परिणाम होता है।

Comments

बहुत बुरा

— बिल्टइन

मैं एक 9-पड़ोसी समग्र नियम के साथ अंतर्निहित "सेल्युलरऑटोमाटन" का उपयोग कर रहा हूं। अधिकांश कोड अस्तित्व / जन्म इनपुट को एक नियम संख्या में परिवर्तित करता है।

— केली लोल्डर

Answer 3

आर , 256 बाइट्स

function(x,B,S,r){y=cbind(0,rbind(0,x,0),0)
n=dim(y)[1]
z=c(1,n)
f=function(h){w=-1:1
b=h%%n+1
a=(h-b+1)/n+1
'if'(a%in%z|b%in%z,0,sum(x[w+b,w+a])-x[b,a])}
while(r){x=y
for(i in 1:n^2){u=f(i-1)
y[i]=u%in%B
y[i]=(y[i]&!x[i])|(x[i]&(u%in%S))}
r=r-1}
y[-z,-z]}

इसे ऑनलाइन आज़माएं!

अफसोस की बात यह है कि यह उतना गोल्फ नहीं दिखता जितना कि मुझे उम्मीद थी।

इनपुट : एक आर मैट्रिक्स, और चुनौती पैरामीटर। आउटपुट : आर पीढ़ियों के बाद मैट्रिक्स।

एल्गोरिथ्म सीमाओं को संभालने के लिए शून्य के साथ मैट्रिक्स को पैड करता है। फिर, पुनरावृति: 1) यह जन्म नियम और 2 को लागू करता है) यह पहले से मौजूद कोशिकाओं को मारता है जो सर्वाइवल नियम को पारित नहीं करता था। लौटते समय गद्दी हटा दी जाती है।

Comments

अच्छा बाइट काउंट!

— Giuseppe

मैं इसे 217 बाइट्स में लाने में कामयाब रहा, लेकिन अगर हम बिल्कुल एक और गोल्फ पा सकते हैं, तो हम इसे प्राप्त कर सकते हैं 216जो कम से कम एक क्यूब है ...

— Giuseppe

Answer 4

पायथन 2 , 156 149 146 बाइट्स

lambda R,g,c:g and f(R,g-1,[[`sum(sum(l[y+y/~y:y+2])for l in c[x+x/~x:x+2])-c[x][y]`in R[c[x][y]]for y,_ in e(c)]for x,_ in e(c)])or c
e=enumerate

इसे ऑनलाइन आज़माएं!

इनपुट लेता है:

• Rules: [birth,survial]सूची के रूप में नियम string। उदा। ( ['135','246'])
• generations: int
• configuration: स्क्वायर 2D सरणी 1/0याTrue/False

का 2d सरणी देता है True/False