जीवन और थकान का खेल

Question

स्टीवी का गेम ऑफ लाइफ और थकान काफी प्रसिद्ध कॉनवे के गेम ऑफ लाइफ से काफी मिलता-जुलता है ।

---

Stewie's Game of Life and Fatigue (GoLF) का ब्रह्माण्ड वर्ग कोशिकाओं का एक अनंत द्वि-आयामी ऑर्थोगोनल ग्रिड है, जिनमें से प्रत्येक तीन संभव अवस्थाओं में से एक में जीवित, मृत या थका हुआ है। प्रत्येक कोशिका अपने आठ पड़ोसियों के साथ बातचीत करती है, जो कि क्षैतिज, लंबवत या तिरछे आसन्न हैं। प्रत्येक चरण में, निम्नलिखित संक्रमण होते हैं:

• दो से कम जीवित पड़ोसियों के साथ कोई भी जीवित कोशिका मर जाती है, जैसे कि अंडरपॉपीलेशन के कारण।
• दो या तीन जीवित पड़ोसियों के साथ कोई भी जीवित कोशिका अगली पीढ़ी पर रहती है।
• तीन से अधिक जीवित पड़ोसियों के साथ कोई भी जीवित कोशिका मर जाती है, जैसे कि ओवरपॉपुलेशन द्वारा।
• ठीक तीन जीवित पड़ोसियों के साथ कोई भी मृत कोशिका एक जीवित कोशिका बन जाती है, जैसे कि प्रजनन द्वारा।
• कोई भी कोशिका जो लगातार दो पीढ़ियों से जीवित है, जैसे कि थकान से मर जाती है। यह अगली पीढ़ी तक फिर से जीवन को नहीं जगा सकता है
• इनपुट ग्रिड की सीमा के बाहर कोई भी कोशिका मृत है, जैसे कि वह एक चट्टान से गिर गया हो।

---

चुनौती:

आपकी चुनौती आयामों की एक ग्रिड लेने के लिए है n-by-m एक GoLF की प्रारंभिक स्थिति का प्रतिनिधित्व करती है, और एक पूर्णांक पी , और पी पीढ़ी के बाद खेल की स्थिति का उत्पादन करती है।

नियम:

• इनपुट और आउटपुट प्रारूप वैकल्पिक हैं, लेकिन इनपुट / आउटपुट ग्रिड में समान प्रतिनिधित्व होना चाहिए
• आप जीवित और मृत कोशिकाओं का प्रतिनिधित्व करने के लिए किसी भी मुद्रण योग्य प्रतीकों का चयन कर सकते हैं (मैं 1जीवित कोशिकाओं और 0मृत कोशिकाओं के लिए उपयोग करूँगा )।
• आप चुन सकते हैं कि आपके पास 0 या 1-अनुक्रमित है। उदाहरणों में, p=1एक चरण के बाद राज्य का मतलब है।
• प्रत्येक भाषा में सबसे छोटा कोड जीतता है
• सेलुलर स्वचालन के लिए अंतर्निहित फ़ंक्शन की अनुमति है

---

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

उदाहरणों में, मैंने केवल इनपुट ग्रिड को इनपुट में शामिल किया है, पी में नहीं । मैंने विभिन्न पी- वैल्यू के लिए आउटपुट प्रदान किए हैं। आप केवल उस ग्रिड को आउटपुट करेंगे जो किसी दिए गए इनपुट p के साथ जाती है ।

Input:
0   0   0   0   0
0   0   1   0   0
0   0   1   0   0
0   0   1   0   0
0   0   0   0   0

--- Output ---
p = 1
0   0   0   0   0
0   0   0   0   0
0   1   1   1   0
0   0   0   0   0
0   0   0   0   0

p = 2
0   0   0   0   0
0   0   1   0   0
0   0   0   0   0
0   0   1   0   0
0   0   0   0   0

p = 3 -> All dead
---

Input:
0   1   0   0   0   0
0   0   1   0   0   0
1   1   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

--- Output ---
p = 1
0   0   0   0   0   0
1   0   1   0   0   0
0   1   1   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

p = 2
0   0   0   0   0   0
0   0   0   0   0   0
1   0   0   0   0   0
0   1   1   0   0   0
0   0   0   0   0   0
0   0   0   0   0   0
0   0   0   0   0   0

p = 3
0   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   0   0   0   0
0   0   0   0   0   0
0   0   0   0   0   0

p = 4 -> All dead
Input
0   1   1   0   1   1   0
1   1   0   1   1   1   1
0   1   0   0   0   1   0
0   0   0   1   1   0   1
1   0   0   1   0   1   1
0   0   1   1   0   1   1
1   1   0   0   0   0   1

--- Output ---
p = 1
1   1   1   0   0   0   1
1   0   0   1   0   0   1
1   1   0   0   0   0   0
0   0   1   1   0   0   1
0   0   0   0   0   0   0
1   0   1   1   0   0   0
0   1   1   0   0   1   1

p = 2
1   0   0   0   0   0   0
0   0   0   0   0   0   0
1   0   0   1   0   0   0
0   1   1   0   0   0   0
0   1   0   0   0   0   0
0   0   0   0   0   0   0
0   0   1   1   0   0   0   

p = 3
0   0   0   0   0   0   0
0   0   0   0   0   0   0
0   1   1   0   0   0   0
1   1   0   0   0   0   0
0   1   1   0   0   0   0
0   0   1   0   0   0   0
0   0   0   0   0   0   0

p = 4
0   0   0   0   0   0   0
0   0   0   0   0   0   0
1   1   1   0   0   0   0
1   0   0   0   0   0   0
1   0   1   0   0   0   0
0   1   1   0   0   0   0
0   0   0   0   0   0   0

p = 5
0   0   0   0   0   0   0
0   1   0   0   0   0   0
1   0   0   0   0   0   0
0   0   1   0   0   0   0
1   0   0   0   0   0   0
0   1   0   0   0   0   0
0   0   0   0   0   0   0

p = 6
0   0   0   0   0   0   0
0   0   0   0   0   0   0
0   1   0   0   0   0   0
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

p = 7
0   0   0   0   0   0   0
0   0   0   0   0   0   0
0   0   0   0   0   0   0
1   1   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

p = 8
0   0   0   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
0   1   0   0   0   0   0
0   0   0   0   0   0   0
0   0   0   0   0   0   0

p = 9 -> All dead

_{हां, मुझे पता है कि सभी प्रारंभिक बीज सभी कोशिकाओं में मृत नहीं होंगे।}

Comments

आपको शायद स्पष्ट करना चाहिए कि संक्रमण आइटम 5 को "एक ही समय में" 1--4 आइटम के रूप में लागू किया जाता है, अर्थात, यह 1--4 लागू होने से पहले राज्य पर आधारित है

— लुइस

" कोशिकाएं, जिनमें से प्रत्येक दो संभावित राज्यों में से एक है, जीवित या मृत " ऐसा लगता है कि जानबूझकर विकृत परिभाषा दी गई है कि बाद में थकान नियम केवल एक मानक परिमित ऑटोमोटन में व्यक्त किया जा सकता है, प्रत्येक कोशिका में तीन राज्य (मृत, नव) होते हैं जीवित, लगातार दो पीढ़ियों के लिए)

— पीटर टेलर

अगर कोई चाहता है तो इसके लिए मेरे पास एक Golly नियम है।

— कैलक्यूलेटरफल

GoD बजाना, एह?

— अदम

Answer 1

MATL , 34 30 25 बाइट्स

5 बाइट्स @CalculatorFeline द्वारा एक सुझाव के लिए धन्यवाद हटा दिया गया !

0ii:"wy*~wt3Y6QZ+5:7mb*]&

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

इनपुट एक मैट्रिक्स और एक संख्या है। मैट्रिक्स ;पंक्ति विभाजक के रूप में उपयोग करता है । तीन परीक्षण मामलों के लिए मेट्रिसेस के रूप में दर्ज किया गया है

[0 0 0 0 0; 0 0 1 0 0; 0 0 1 0 0; 0 0 1 0 0;0 0 0 0 0]
[0 1 0 0 0 0; 0 0 1 0 0 0; 1 1 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 1 1 0 1 1 0; 1 1 0 1 1 1 1; 0 1 0 0 0 1 0; 0 0 0 1 1 0 1; 1 0 0 1 0 1 1; 0 0 1 1 0 1 1; 1 1 0 0 0 0 1]

व्याख्या

0     % Push 0. This represents the generation previous to the input one. Actually
      % This should be an array of zeros, but thanks to broadcasting it is
      % equivalent (and saves bytes)
i     % Input: array with starting generation
i     % Input: number of iterations, p.
      % STACK (bottom to top): 0, array with initial generation, p
:"    % Do the following p times
      %   STACK: previous gen, current gen
  wy  %   Swap, duplicate from below
      %   STACK: current gen, previous gen, current gen
  *~  %   Multiply element-wise, negate. This creates a mask of cells that do not 
      %   die of fatigue (they were 0 in the current or in the previous generation)
      %   STACK: current gen, fatigue mask
  wt  %   Swap, duplicate
      %   STACK: Fatigue mask, current gen, current gen
  3Y6 %   Push predefined literal: 8-neighbourhood: [1 1 1; 1 0 1; 1 1 1]
      %   STACK: Fatigue mask, current gen, current gen, 8-neighbourhood
  Q   %   Add 1 element-wise. This gives [2 2 2; 2 1 2; 2 2 2], which will be
      %   used as convolution kernel. Active cells with 2 neighbours will give 5;
      %   inactive cells with 3 neighbours will give 6; and active cells with 3
      %   neighbours will give 7
      %   STACK: Fatigue mask, current gen, current gen, convolution kernel
  Z+  %   2D convolution, keeping size
      %   STACK: Fatigue mask, current gen, convolution result
  5:7 %   Push array [5 6 7]
  m   %   Ismember, element-wise. Cells that give true will survive, unless fatigued
      %   STACK: Fatigue mask, current gen, cells that can survive
  b   %   Bubble up
      %   STACK: Current gen, cells that can survive, fatigue mask
  *   %   Multiply element-wise. This tells which cells survive considering fatigue.
      %   The result is the new generation
      %   STACK: "Current" gen which now becomes old, "new" gen which now becomes
      %   current
]     % End 
&     % Specify that implicit display will show only top of the stack

Comments

क्या आप 3Y6और अधिक विस्तार से बता सकते हैं ? इसके अलावा, अगर कर्नेल का मध्य तत्व था .5, तो आप बस के साथ सीजीओएल की जांच कर सकते हैं 2<value<4। मदद हो सकती है।

— कैलक्यूलेटरफैनलाइन

@CalculatorFeline बहुत अच्छा सुझाव है, धन्यवाद! इसने 5 बाइट बचाने के लिए, दो बार मास्क का उपयोग किया और फिर परीक्षण किया 5<=value<=7। के रूप में 3Y6, यह सिर्फ एक पूर्वनिर्धारित शाब्दिक है। वहाँ भी है 1Y6, जो 4-पड़ोस है

— लुइस मेंडो

हुह। वह वास्तव में काम किया। साफ।

— कैलक्यूलेटरफल

Answer 2

एपीएल (डायलॉग क्लासिक 16.0) , 59 बाइट्स

⌊{((3∊⌊{⍵,⍵-c}+/,⍵)∧.1>1|c)×(.1×c)+1⌈c←2 2⌷⍵}⎕U233A 3 3⍣⎕⊢⎕

इसे ऑनलाइन आज़माएं! (क्लासिक 15.0 पर अनुकरण किया गया)

---

एपीएल (डायलॉग यूनिकोड 16.0) , 85 बाइट्स

⌊{((3∊⌊{⍵,⍵-c}+/,⍵)∧.1>1|c)×(.1×c)+1⌈c←2 2⌷⍵}⌺3 3⍣⎕⊢⎕

इसे ऑनलाइन आज़माएं! (यूनिकोड 15.0 पर अनुकरण)

---

ग्रिड के लिए संकेत और फिर पी के लिए । पी पीढ़ियों के बाद नए ग्रिड प्रिंट करता है ।

ध्यान दें कि यह नए ⌺(स्टैंसिल) आदिम का उपयोग करता है जो क्लासिक वर्ण सेट में शामिल नहीं है, इसलिए एक छोटा संस्करण और एक कम-संस्करण संस्करण।

पालन ​​करने के लिए स्पष्टीकरण ...

Comments

एपीएल का डिस्प्ले फॉर्मेट अच्छा है :-)

— लुइस मेंडो

@LuisMendo वास्तव में, यह "एपीएल" नहीं है, बल्कि दुभाषिया इस एपीएल फ़ंक्शन को कॉलबैक करता है जब यह आउटपुट करना चाहता है। फ़ंक्शन तब विश्लेषण करता है कि हम उसके अनुसार क्या आउटपुट और संशोधित करना चाहते हैं। displayसमारोह के लिए स्पष्टीकरण यहाँ है ।

— अदम

Answer 3

गॉली नियमुलाडर, 295 बाइट्स

@RULE Y
@TABLE
n_states:3
neighborhood:Moore
symmetries:permute
var z={1,2}
var y=z
var x=z
var w=z
var u=z
var a={0,z}
var b=a
var c=a
var d=a 
var e=a
var f=a
var g=a 
var h=a
0,z,y,x,0,0,0,0,0,1
z,a,0,0,0,0,0,0,0,0
z,y,x,w,u,a,b,c,d,0
2,a,b,c,d,e,f,g,h,0
1,a,b,c,d,e,f,g,h,2
@COLORS
2 255 0 0

इनपुट ग्रिड को चिपकाया जाना चाहिए, सीमाएं रूलेन में हैं (जैसे 5* * 3है Y:P5,3), अग्रिम करने के लिए जगह दबाएं।

Answer 4

जावा 8, 333 बाइट्स

int[][]G(int p,int[][]s){for(int h=s.length,w=s[0].length,y,x,n,a,b,t[][]=new int[h][w],i=0;i++<2*p;)for(y=0;y<h;++y)for(x=0;x<w;++x)if(i%2>0){for(n=0,a=y-2;++a<y+2;)for(b=x-2;++b<x+2;)n+=a>=0&a<h&b>=0&b<w&(a!=y|b!=x)&&s[a][b]>0?1:0;t[y][x]=s[y][x]<1?n==3?1:0:n<2|n>3|s[y][x]>1?0:2;}else s[y][x]=i==2*p&t[y][x]>1?1:t[y][x];return s;}

स्पष्टीकरण:

int[][]G(int p,int[][]s){
    for(int h=s.length,w=s[0].length,y,x,n,a,b,t[][]=new int[h][w],       //height, width, vars, temp array
            i=0;i++<2*p;)                                                 //for 2*generations: 1. calculate in temporary t, 2. copying to s
        for(y=0;y<h;++y)                                                  //for each row
            for(x=0;x<w;++x)                                              //for each column
                if(i%2>0){                                                //1. calculate
                    for(n=0,a=y-2;++a<y+2;)                               //n = number of alive cells around [y][x]. row above, at and below y
                        for(b=y-2;++b<y+2;)                               //column left, at and right of x
                            n+=a>=0&a<h&b>=0&b<w&(a!=y|b!=x)&&s[a][b]>0?1:0;    //if within bounds and not the cell itself, add 1 if alive.
                    t[y][x]=s[y][x]<1?n==3?1:0:n<2|n>3|s[y][x]>1?0:2;     //save next state in temporary, depending on rules. alive cells become 2.
                }
                else                                                      //2. copy temporary t to s
                    s[y][x]=i==2*p&t[y][x]>1?1:t[y][x];                   //if last generation, replace 2 by 1
    return s;
}