संदूषण का अंतिम चरण

10

5x5 के प्राप्तकर्ता के अंदर एक वायरस होता है। जैसा कि हम जानते हैं कि यह अपने संदूषण को कैसे फैलाता है, आपका मिशन संदूषण के अंतिम चरण का उत्पादन करना है।

प्राप्तकर्ता

यह 5x5 के दो आयामी सरणी के रूप में प्रतिनिधित्व करेगा:

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

जहां 1एक ऐसी स्थिति का अर्थ है जहां वायरस पहले ही दूषित हो चुका है, और 0एक स्थिति दूषित नहीं है।

वायरस कैसे फैलता है

  1. दूषित स्थिति साफ नहीं हो सकती।
  2. एक साफ स्थिति अगले चरण में तभी दूषित होगी जब इसके आस-पास के कम से कम दो स्थान (उत्तर, पूर्व, दक्षिण और पश्चिम की कोशिकाएं) दूषित हों।
  3. संदूषण का अंतिम चरण तब होता है जब कोई अधिक स्वच्छ कोशिकाएं दूषित नहीं हो सकती हैं।

नमूना

उपरोक्त वर्णित प्राप्तकर्ता के संदूषण के चरण 1 के रूप में उपयोग करना, चरण 2 होगा:

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

संदूषण का चरण 3 होगा:

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

संदूषण का चरण 4 होगा:

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

और चरण 5 (इस उदाहरण में, अंतिम एक) होगा:

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

चुनौती

संदूषण के एक चरण के रूप में देखते हुए, आपको संदूषण के अंतिम चरण का उत्पादन करना चाहिए।

आपको पूर्ण कार्यक्रम या फ़ंक्शन लिखने की अनुमति है। आप इनपुट को सरणी / सूची के रूप में ले सकते हैं, अलग संख्या के रूप में, या स्ट्रिंग के रूप में भी। सबसे अच्छा तरीका है कि अपनी भाषा में फिट बैठता है चुनता है।

बाइट्स जीत में सबसे छोटा जवाब!

एक और परीक्षण के मामले

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

Output:
1 1 0 0 1
1 1 0 0 1
1 1 0 0 1
1 1 0 0 1
1 1 0 0 1

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

Output:
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1

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

Output:
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1

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

Output:
0 1 0 0 0
0 0 0 0 1
0 0 1 0 0
1 0 0 0 0
0 0 0 1 0
code-golf  binary-matrix 
— हटा दिया
स्रोत
1
1 0 1आउटपुट में कैसे हो सकता है? क्या केंद्र शून्य दो 1s से सटे नहीं है ?
— लिन
@Lynn .. मैंने अपडेट किया है;) ... इसके लिए खेद है
— हटा दिया
1
क्या आप 1 0 0 1 0 \ 0 0 1 0 1 \ 0 0 0 0 0 \ 1 0 0 0 0 \ 0 0 1 0 0परीक्षण के मामले के रूप में जोड़ सकते हैं ?
— कॉनर ओ'ब्रायन
@ CᴏɴᴏʀO'Bʀɪᴇɴ। जोड़ा गया धन्यवाद
— हटा दिया
2
अब तक के सभी परीक्षण मामलों में केवल पूर्ण पंक्ति और कॉलम खाली हैं। मेरा सुझाव है 0 1 0 0 0 \ 0 0 0 0 1 \ 0 0 1 0 0 \ 1 0 0 0 0 \ 0 0 0 1 0, जो अपरिवर्तित रहता है।
— xnor

जवाबों:

12

चूँकि यह मूल रूप से एक सेल्यूलर ऑटोमैटोन की बात है जो मैं आपको देता हूँ।

गॉली क्विकलाइफ़ नियम, 10 बाइट्स

01234/234V

नियम को इनपुट करें, ग्रिड को गॉली में पेस्ट करें, पैटर्न चलाएं। परिणामी पैटर्न आउटपुट है।

स्पष्टीकरण:

01234 Survive on any number of neighbors
     /234 Born on >2 neighbors
         V Only directly adjacent neighbors count

या यदि आप एक पूर्ण नियम नियम, 89 बाइट्स पर जोर देते हैं:

@RULE X
@TABLE
n_states:2
neighborhood:vonNeumann
symmetries:permute
011001
011101
011111

रूलेनम एक्स है, पहले की तरह ही कदम।

— CalculatorFeline
स्रोत
3
— लिन
1
Golly क्विकलाइफ अनुकरण B3/S23कर सकता है जो कुछ भी कर सकता है! ... लेकिन इसके पास सख्त इनपुट प्रारूप है (जैसे पूरा कार्यक्रम इनपुट में शामिल है (आप इसे कैसे करेंगे?))। लेकिन क्यों FUN रन?
— कैलक्यूलेटर
खैर, हमें सिर्फ एक सवाल के लिए इंतजार करने की ज़रूरत है जो एक सेलुलर ऑटोमेटन के दीर्घकालिक व्यवहार के लिए उबालता है!
— कैलक्यूलेटरफलाइन
1
मुझे वैधता के बारे में कुछ संदेह है। यदि गॉली केवल अंतिम परिणाम प्रदर्शित करता है, तो यह ठीक होगा, लेकिन यह मध्यवर्ती परिणाम भी दिखाता है (जब तक कि मैं गलत न हो)
— lirtosiast
1
@CatsAreFluffy तुम मेरे upvote तो है।
— lirtosiast
5

पायथन 2, 97 बाइट्स

s=' '*6+input()
exec"s=s[1:]+('1'+s)[sum(s[i]<'1'for i in[-6,-1,1,6])>2or'/'>s];"*980
print s[6:]

इसे ऑनलाइन आज़माएं । इनपुट को उद्धृत पंक्ति के रूप में लिया जाता है, जिसमें प्रत्येक पंक्ति को नए सिरे से सीमांकित किया जाता है। यह 980इष्टतम नहीं है और इसे 35 के निचले हिस्से से बदला जा सकता है। चूंकि इस कार्यक्रम की लंबाई पर इसका कोई प्रभाव नहीं है, इसलिए मैंने पाठक के लिए एक अभ्यास के रूप में सबसे कम सुरक्षित ऊपरी सीमा का निर्धारण छोड़ दिया है।

— xsot
स्रोत
इनपुट के आसपास उद्धरणों की आवश्यकता होती है और \ n बची हुई नई सुर्खियों में आते हैं।
— कैलकुलेटरफाइनल
@CatsAreFluffy मेरा मानना ​​है कि Ideone लिंक पहले से ही स्पष्ट करता है कि इनपुट कैसे लिया जाता है।
— xsot
इनपुट को प्रत्येक पंक्ति के साथ उद्धृत स्ट्रिंग के रूप में लिया गया है जिसे \ n s द्वारा सीमांकित किया गया है।
— कैलक्यूलेटरफिलीन
ठीक है, मैं इसे कम अस्पष्ट बनाने के लिए संपादित करूँगा।
— xsot
3

जावास्क्रिप्ट (ईएस 6), 91 89 87 बाइट्स

एक फ़ंक्शन के रूप में जो इनपुट को संख्या या स्ट्रिंग्स के एक सरणी के रूप में स्वीकार करता है।

नील से -2 बाइट्स ( yस्ट्रिंग रूपांतरण के साथ संयोजन का काम )

-2 बाइट्स (चर को हटाते हुए j)

f=x=>(y=x.map((z,i)=>~(i%5&&x[i-1])+~(i%5<4&x[i+1])+~x[i-5]+~x[i+5]<-5|z))+[]==x?y:f(y)
<!-- Snippet demo with array <-> string conversion for convenience -->
<textarea id="input" cols="10" rows="5">0 0 0 0 1
0 0 0 0 1
0 0 0 1 1
0 0 1 1 1
0 1 1 1 1</textarea>
<button id="submit">Run</button>
<pre id="output"></pre>
<script>
strToArray=x=>x.match(/\d/g)
arrayToStr=x=>([]+x).replace(/(.),(.),(.),(.),(.),*/g, '$1 $2 $3 $4 $5\n')
submit.onclick=_=>output.innerHTML=arrayToStr(f(strToArray(input.value)))
</script>
स्निपेट का विस्तार करें

— nderscore
स्रोत
के (y=...)+''==xबजाय लिखकर 2 बाइट्स सहेजें (y=...),y+''==x।
— नील
2

MATL , 22 बाइट्स

tn:"t5Bt!=~2X53$Y+1>Y|

यह भाषा के वर्तमान संस्करण (15.0.0) में काम करता है ।

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

इनपुट प्रारूप है: 2 डी सरणी अर्धविराम से अलग पंक्तियों के साथ। तो चार परीक्षण मामलों में निम्नलिखित इनपुट हैं:

[0 0 0 0 1; 0 0 0 0 1; 0 0 0 1 1; 0 0 1 1 1; 0 1 1 1 1]

[1 1 0 0 1; 0 0 0 0 0; 0 1 0 0 1; 0 0 0 0 0; 1 0 0 0 1]

[1 0 0 0 0; 0 1 0 0 0; 0 0 1 0 0; 0 0 0 1 0; 0 0 0 0 1]

[1 0 0 1 0; 0 0 1 0 1; 0 0 0 0 0; 1 0 0 0 0; 0 0 1 0 0]

व्याख्या

यह बार-बार निम्नलिखित मास्क के साथ इनपुट सरणी का 2 डी कनवल्शन करता है, जो परिभाषित करता है कि कौन से पड़ोसी दूषित मानते हैं:

0 1 0
1 0 1
0 1 0

परिणाम को मूल सरणी के समान आकार प्राप्त करने के लिए, इसे पहले शून्य के एक फ्रेम के साथ गद्देदार किया जाता है और उसके बाद कनवल्शन का केवल "वैध" भाग रखा जाता है (अर्थात बिना धार प्रभाव के)।

कनवल्शन के आउटपुट के लिए 2 की एक सीमा लागू की जाती है, और परिणाम मूल इनपुट के साथ तत्व-वार ओरेड है।

अंतिम स्थिति तक पहुँचने के लिए इसे पर्याप्त संख्या में किया जाना चाहिए। इसे पूरा करने वाला एक सरल मानदंड है: इनपुट सरणी में प्रविष्टियों की संख्या जितनी अधिक हो उतनी बार पुनरावृति (यानी, 25 बार परीक्षण मामलों में)।

t          % get input 2D array implicitly. Duplicate
n:"        % repeat as many times as elements in the input array
  t        %   duplicate array
  5B       %   number 5 in binary: row vector [1 0 1] 
  t!       %   duplicate and transpose into column
  =~       %   compare for inequality with broadcast. Gives desired mask
  2X53$Y+  %   2D convolution. Output has same size as input 
  1>       %   true for elements equal or greater than 2
  Y|       %   element-wise OR with previous copy of the array
           % end loop. Implicitly display
— लुइस मेंडो
स्रोत
1

टीआई-बेसिक, 151 बाइट्स

Prompt [A]
[A]→[B]
Lbl 0
[B]→[A]
For(Y,1,5
For(X,1,5
DelVar ADelVar BDelVar CDelVar D
If Y>1:[A](Y-1,X→A
If Y<5:[A](Y+1,X→B
If X>1:[A](Y,X-1→C
If X<5:[A](Y,X+1→D
max(A+B+C+D≥2,[A](Y,X→[B](Y,X
End
End
If [A]≠[B]:Goto 0
[B]

इनपुट के रूप में [[1,0,0,1,1][1,0,0,0,0]...]।

— कोनोर ओ ब्रायन
स्रोत
1
मुझे लगता है कि आप इसे लगभग 100 बाइट्स में ले सकते हैं। पहला टिप: एक Repeatलूप का उपयोग करें ।
— lirtosiast
1

लुआ, 236 बाइट्स

s=arg[1]u=s.sub while p~=s do p=s s=s:gsub("(%d)()",function(d,p)t=0 t=t+((p-2)%6>0 and u(s,p-2,p-2)or 0)t=t+(p-7>0 and u(s,p-7,p-7)or 0)t=t+(p+5<30 and u(s,p+5,p+5)or 0)t=t+(p%6>0 and u(s,p,p)or 0)return t>1 and 1 or d end)end print(s)

कमांड लाइन पर इनपुट स्वीकार करता है, और उत्तर पाने के लिए लुआ के स्ट्रिंग हेरफेर का उपयोग करता है।

Ungolfed:

s=arg[1]
u=s.sub
while p~=s do
    p=s
    s=s:gsub("(%d)()", function(d, p)
                 t=0
                 t=t+((p-2)%6>0 and u(s,p-2,p-2)or 0)
                 t=t+(p-7>0 and u(s,p-7,p-7)or 0)
                 t=t+(p+5<30 and u(s,p+5,p+5)or 0)
                 t=t+(p%6>0 and u(s,p,p)or 0)
                 return t>1 and 1 or d
    end)
end
print(s)
— Trebuchette
स्रोत
1

एपीएल, 76 72 70 बाइट्स

{⍵∨1<¯1 ¯1↓1 1↓↑+/(1 0)(¯1 0)(0 ¯1)(0 1){⍺[1]⊖⍺[2]⌽⍵}¨⊂¯1⊖¯1⌽7 7↑⍵}⍣≡

यह क्या करता है: मैट्रिक्स को 7x7 एक तक विस्तारित करें, फिर हमारे तर्क (ओमेगा) को केंद्र में रखें। इस मैट्रिक्स से, 4 "बच्चे" मैट्रीस उत्पन्न करते हैं, प्रत्येक को एक अलग दिशा (ऊपर / नीचे / बाएं / दाएं) में स्थानांतरित किया जाता है, उन्हें एक साथ जोड़ते हैं (इसलिए हमें पड़ोसियों की संख्या मिलती है), फ्रेम को ड्रॉप करें (वापस जाने के लिए) 5x5 मैट्रिक्स)। या "पुराने" एक के साथ यह नया मैट्रिक्स, यह सुनिश्चित करने के लिए कि हम प्रक्रिया में किसी भी सेल को नहीं गिराए (यानी किनारे पर)। फिर, ⍣≡निश्चित-मान के लिए संयोजन का उपयोग करें ।

{⍵∨1<¯1 ¯1↓1 1↓↑+/(1 0)(¯1 0)(0 ¯1)(0 1){⍺[1]⊖⍺[2]⌽⍵}¨⊂¯1⊖¯1⌽7 7↑⍵}⍣≡
                                                             7 7↑⍵    ⍝ Expand the matrix
                                                       ¯1⊖¯1⌽         ⍝ Center the original matrix
                  (1 0)(¯1 0)(0 ¯1)(0 1){⍺[1]⊖⍺[2]⌽⍵}¨⊂               ⍝ Construct 4 child matrices, each offset from the original one by the values on the left of {}
                +/                                                    ⍝ Sum each matrix into one giant matrix
               ↑                                                      ⍝ Mix
     ¯1 ¯1↓1 1↓                                                       ⍝ Transform the 7x7 matrix back to a 5x5 matrix
   1<                                                                 ⍝ Check which elements are smaller than 1
 ⍵∨                                                                   ⍝ "Or" this matrix and the generated matrix
{                                                                 }⍣≡ ⍝ Find the fixpoint

उदाहरण (कार्य को देखते हुए contaminate) को सौंपा गया था :

          stage ⍝ the base matrix
0 0 0 0 1
0 0 0 0 1
0 0 0 1 1
0 0 1 1 1
0 1 1 1 1
      contaminate stage ⍝ apply the function
0 1 1 1 1
0 1 1 1 1
0 1 1 1 1
0 1 1 1 1
0 1 1 1 1
— Ven
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.