12

चूंकि कल 4 मई है, कल आने वाले सभी बुरे चुटकुलों के लिए आपको मानसिक रूप से तैयार करने के लिए यहां थोड़ा स्टार वार्स पोस्ट किया गया है।

पृष्ठभूमि की कहानी

गैलेक्टिक सीनेट के एक सत्र के दौरान सभी सीनेटर एक n*nग्रिड में बैठे हैं । जारजार फ्लू का अचानक प्रकोप (जो हमेशा के लिए रहता है और संक्रमित को जारजार बिंक्स की तरह बोलने का कारण बनता है) कुछ सीनेटरों को संक्रमित कर देता है।

यहां एक 6*6ग्रिड के साथ एक उदाहरण दिया गया है जहां Xसंक्रमित सीनेटर हैं, इसी सूची है [[0,5],[1,4],[2,3],[2,1],[3,3],[3,0],[4,5],[0,5]]:

उसके बाद संक्रमण कदम दर कदम फैलने लगता है। दो सीनेटर सटे हुए हैं यदि वे ग्रिड पर एक पूरे किनारे को साझा करते हैं (यानी, ऊपर, नीचे, दाएं, बाएं), जिसका अर्थ है कि हम विकर्णों को बाहर करते हैं।

हम निष्कर्ष निकाल सकते हैं कि एक सीनेटर 2,3 या 4 अन्य सीनेटरों के निकट हो सकता है और संक्रमण के लिए निम्नलिखित नियमों का दावा कर सकता है:

संक्रमित होने वाला सीनेटर हमेशा संक्रमित रहता है
यदि वह पिछले चरण में 2 या अधिक संक्रमित सीनेटर के निकट था, तो एक सीनेटर एक कदम पर संक्रमित होता है

यहां पिछली ग्रिड के साथ एक उदाहरण दिया गया है जो संक्रमण के 2 पहले चरणों को दर्शाता है:

नेक्सट कदम के बाद सभी सीनेट संक्रमित हो जाएंगे

आपका कार्य

आपके कोड को ऐसी सूचियों की तुलना में अमान्य इनपुट को संभालने की आवश्यकता नहीं है, जो n*nनिर्देशांक से अलग हैं या अलग-अलग नहीं हैं।

nउदाहरण के लिए आपका कोड पूर्णांक (या एक बाइनरी ग्रिड या आपकी भाषा के अनुकूल कोई अन्य प्रारूप) के जोड़ों की सूची के रूप में ले जाएगा और एक पूर्णांक (जो किसी सूची के अलावा किसी अन्य प्रारूप का उपयोग करने पर अनावश्यक हो सकता है), उदाहरण के लिए:

8 [[1,2],[1,1],[7,4],[2,7],[4,3]]

n ग्रिड के किनारे होने का मतलब है कि ग्रिड एक * n ग्रिड होगा, और पूर्णांकों के जोड़ों की सूची, जो संक्रमित संक्रमित सीनेटरों की कोशिकाओं के निर्देशांक हैं।

ग्रिड के नीचे बाईं ओर [0,0] है और ऊपर दाईं ओर [n-1, n-1] है। शीर्ष बाईं ओर [0, n-1] है।

आपका कोड एक पूर्णांक आउटपुट करना चाहिए:

-1 या एक गलत मान या एक त्रुटि यदि पूरी ग्रिड पूरी तरह से संक्रमित नहीं होगी या पूरे ग्रिड को संक्रमित करने के लिए आवश्यक चरणों की न्यूनतम संख्या

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

6 [[0,5],[1,4],[2,3],[2,1],[3,3],[3,0],[4,5],[5,0]] => 7

4 [[1,1][0,3][1,0][3,0][3,3]] => 9

याद रखें कि यह कोड-गोल्फ है , इस प्रकार बाइट्स जीत में सबसे छोटा जवाब है!

code-golf grid

1

Mathematica.SE पर संबंधित पोस्ट।

— मार्टिन एंडर

MATL, 29 28 बाइट्स

tn:"tlY6Z+1>Z|t?@.]]Nl=?l_]&

इनपुट 1 डी और 0 के 2 डी मैट्रिक्स के रूप में है

इसे MATL ऑनलाइन पर आज़माएं

व्याख्या

        % Implicitly grab user input as a 2D matrix
t       % Duplicate the inputs
n:      % Count the number of elements in the input (N) and create the array [1...N]
"       % Loop this many times (maximum number of steps we analyze)
  t     % Duplicate the top element
  lY6   % Push the 2D array => [0 1 0; 1 0 1; 0 1 0]
  Z+    % Perform 2D convolution (and maintain the size)
  l>    % Find all values that are >= 2
  Z|    % Perform an element-wise OR with the previous state
  t?    % If all elements are 1's
    @.  % Push the current index and break out of the loop
  ]     % End of if 
]       % End of for loop
Nl=?    % If there is only one element on the stack
  l_    % Push a negative one
]       % End of if statement
&       % Display the top stack element

— Suever
स्रोत

@LuisMendo दुर्भाग्य से मुझे ऐसा नहीं लगता क्योंकि कन्वेन्शन के आउटपुट में कुछ 0 हैं जो -1 हो जाएगा और इसलिए "सत्य" होगा

— स्वेअर

कैसे के बारे में tn:"tlY6Z+1>Z|t?x@D.]]N?xl_? (मैंने बहुत परीक्षण नहीं किया है)। यदि सभी तत्व किसी बिंदु पर 1 हैं, तो तुरंत लूप इंडेक्स प्रदर्शित करें और स्टैक को हटा दें। लूप के अंत में, यदि स्टैक नॉन-खाली डिलीट और पुश है-1

— लुइस मेंडू

3

APL (Dyalog 16.0), 54 अक्षर या 60 बाइट्स

तर्क के रूप में संलग्न मैट्रिक्स लेता है, चरण संख्या देता है जो संक्रमण को पूरा करता है, अर्थात 1 = पहले से ही पूरी तरह से संक्रमित है। 0 = पूरी तरह से फैलता नहीं है, जो सिर्फ 1 + ओपी की संख्या है।

54 अक्षर (यूनिकोड):

(≢×0=0∊⊃){(⊢≡f←⊢∨2≤{+/,⍵×3 3⍴0 1}⌺3 3)⊃⍵:⍵⋄(⊂f⊃⍵),⍵}⍣≡

60 बाइट्स (क्लासिक):

(≢×0=0∊⊃){(⊢≡f←⊢∨2≤{+/,⍵×3 3⍴0 1}⎕U233A 3 3)⊃⍵:⍵⋄(⊂f⊃⍵),⍵}⍣≡

⌺ के बराबर है ⎕U233A

उदाहरण 'रन:

      g←(≢×0=0∊⊃){(⊢≡f←⊢∨2≤{+/,⍵×3 3⍴0 1}⌺3 3)⊃⍵:⍵ ⋄ (⊂f⊃⍵),⍵}⍣≡
      ⎕IO←0
      b←⊂⊖⍉~@(⎕JSON'[[0,5],[1,4],[2,3],[2,1],[3,3],[3,0],[4,5],[5,0]]')⊢0⍴⍨2⍴6
      g b
8
      b←⊂⊖⍉~@(⎕JSON'[[1,1],[0,3],[1,0],[3,0],[3,3]]')⊢0⍴⍨2⍴4
      g b
10

चरण इस प्रकार हैं:

┌─────────────┬─────────────┬─────────────┬─────── ──────┬─────────────┬─────────────┬─────────────┬─ ────────────┐
│ XX │ XXX X XXXX │ XXXXX │ XXXXX │ XXXXX XX XXXXX │ XXXXXX │
│ X │ XXX X XXXX │ XXXXX │ XXXXX │ XXXXX XX XXXXXX │ XXXXXX │
│ XX │ XXX X XXXX │ XXXX │ XXXXX X XXXXXX XX XXXXXX │ XXXXXX │
│ │ X │ XXX XX XXXXX X XXXXXX X XXXXXX XX XXXXXX │ XXXXXX │
│ X │ XX │ XXX │ XXXXX X XXXXXX X XXXXXX XX XXXXXX │ XXXXXX │
│ XX │ XXXX X XXXX │ XXXX │ XXXXX X XXXXXX XX XXXXXX │ XXXXXX │
└─────────────┴─────────────┴─────────────┴─────── ──────┴─────────────┴─────────────┴─────────────┴─ ────────────┘
┌─────────┬─────────┬─────────┬─────────┬───────── ┬─────────┬─────────┬─────────┬─────────┬───────── ┐
│ XX │ XX │ XX │ XX │ XX │ XX │ XXX X XXXX │ XXXX │ XXXX │
│ │ │ │ │ X │ XX │ XXX │ XXXX X XXXX │ XXXX │
│ X │ X │ XX │ XXX │ XXX │ XXX │ XXX │ XXX │ XXX X XXXX │ XXX │ XXX │
│ XX │ XXX │ XXX │ XXX │ XXX │ XXX │ XXX │ XXX │ XXX │ XXX │ XXXX │
└─────────┴─────────┴─────────┴─────────┴───────── ┴─────────┴─────────┴─────────┴─────────┴───────── ┘

— एडम
स्रोत

2

पायथ , 49 बाइट्स

J^UE2*lK.uS{+NeMf>hT1r8S@Jsmm+VdkNs_MB_MBU2Q)qJeK

टेस्ट सूट ।

आउटपुट के लिए 1-इंडेक्सिंग का उपयोग करता है।

— लीक नन
स्रोत

2

पायथन, 231 बाइट्स

g=input()
q=lambda r,c:g[r][c]if(0<=r<m)*(0<=c<m)else 0
m=len(g);p=t=0;n=range(m)
while not all([r for k in g for r in k]):h=[[g[r][c]or sum([q(r+1,c),q(r-1,c),q(r,c+1),q(r,c-1)])>1 for c in n] for r in n];t+=1;0/(g!=h);g=h
print t

यदि यह संभव नहीं है तो यह एक त्रुटि उठाता है।

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

— नील
स्रोत

0/0से दो बाइट्स बचाता है raise। शायद 1/(g!=h)काम करेगा? (तब पूरे whileको भी इनलेट किया जा सकता था)।

— जोनाथन एलन

@JonathanAllan I ने इसे अपडेट किया, इनपुट के लिए धन्यवाद।

— नील

q=lambda r,c:g[r][c]if(0<=r<m)*(0<=c<m)else 0की बचत होती है 12. आप के बीच (क) अंतरिक्ष को हटा सकते हैं 1और forऔर (ख) ]और forभी।

— जोनाथन एलन

@JonathanAllan फिर से अपडेट किया गया। धन्यवाद