एक गो बोर्ड पर कदम रखें

आपको एक गो गेम और खेलने के लिए एक चाल के लिए एक बोर्ड की स्थिति दी जाती है । आपको यह आउटपुट करने की आवश्यकता है कि क्या यह कदम कानूनी है या नहीं, और यदि यह कानूनी है तो नए बोर्ड की स्थिति।

गो मूव्स का संक्षिप्त विवरण: खेल में एक वर्ग बोर्ड पर खाली जगहों पर वैकल्पिक रूप से काले और सफेद टुकड़े ("पत्थर") रखे होते हैं। एक ही रंग के टुकड़ों के समूह जो एक दूसरे (4-वे) से जुड़े होते हैं, समूह कहलाते हैं। बोर्ड पर खाली स्थान जो एक समूह से सटे हुए हैं (4-वे भी) को उस समूह की "स्वतंत्रता" माना जाता है। 0 स्वतंत्रता वाले समूह को पकड़ लिया जाता है (बोर्ड से हटा दिया जाता है)। एक ऐसा कदम जिसके कारण अपने स्वयं के समूह पर कब्जा कर लिया जाएगा ("आत्महत्या") अवैध है, जब तक कि यह एक या एक से अधिक प्रतिद्वंद्वी समूहों को पकड़ नहीं रहा है (प्रक्रिया में स्वतंत्रता प्राप्त कर रहा है, इसलिए यह वास्तव में कब्जा नहीं किया गया है)।

संबंधित लोगों के लिए, आपको को (और सुपरको) से निपटने की आवश्यकता नहीं है, यानी आप मान सकते हैं कि कोई कैप्चर कानूनी है। अगर आपको नहीं पता कि इसका क्या मतलब है, तो ऊपर दिए गए नियमों का पालन करें और यह ठीक रहेगा।

इनपुट: बोर्ड संख्या का प्रतिनिधित्व करने वाले 2 और 19 (समावेशी) के बीच एक संख्या n, जिसके बाद 0 और 2 के बीच n संख्याओं की n रेखाएँ (समावेशी) बोर्ड की स्थिति का प्रतिनिधित्व करती हैं, इसके बाद अंतरिक्ष द्वारा अलग किए गए 3 नंबर, बनाने की चाल का प्रतिनिधित्व करते हैं। बोर्ड की स्थिति में, 0 का अर्थ है खाली जगह, 1 का अर्थ है काला पत्थर और 2 का अर्थ है सफेद पत्थर। इस कदम से स्तंभ, पंक्ति और पत्थर के रंग (1 या 2) को जगह मिलती है। स्तंभ और पंक्ति 0-आधारित, 0 से n-1 (समावेशी) तक हैं और बोर्ड इनपुट के समान क्रम में गिने जाते हैं।

आप मान सकते हैं कि दिए गए बोर्ड की स्थिति कानूनी है (सभी समूहों में कम से कम एक स्वतंत्रता है)।

आउटपुट: एक पंक्ति जिसमें 1 या 0 (या यदि आप चाहें तो सच / गलत हैं) यदि यह कदम कानूनी है या नहीं, तो (केवल एक कानूनी कदम के मामले में) इनपुट के समान प्रारूप में नए बोर्ड की स्थिति से।

स्कोर: पूर्ण स्रोत कोड के बाइट्स की संख्या, छोटी बेहतर है। यदि गैर-अस्की पात्रों का उपयोग करने के लिए 20% अतिरिक्त जुर्माना, और 20% अतिरिक्त जुर्माना यदि आपका कोड लिनक्स में स्वतंत्र रूप से उपलब्ध सॉफ़्टवेयर का उपयोग करके परीक्षण नहीं किया जा सकता है।

नियम: कोई नेटवर्क कनेक्शन और कोई 3 पार्टी लाइब्रेरी नहीं। आपके प्रोग्राम को मानक इनपुट और आउटपुट स्ट्रीम, या आपकी प्रोग्रामिंग भाषा के लिए मानक समकक्ष का उपयोग करना चाहिए।

उदाहरण:

— aditsu छोड़ दिया क्योंकि SE EVIL है
स्रोत

जवाबों:

अजगर 3 (557 504 488)

import sys
s=sys.stdin
M=int(next(s))+1
j=Z=M*M-M
S=s.read(Z)
P=0
b=[0]*3
while j>0:j-=1+(j%M<1);b[int(S[j])]|=1<<j;P|=1<<j
N=lambda x:(x<<1|x>>1|x<<M|x>>M)&P&~x
def h(a,b):t=a|N(a)&b;return h(t,b)if t!=a else a
c,r,m=map(int,next(s).split())
o=m%2+1
p=1<<M*r+c
b[m]|=p
for n in(p<<1,p>>1,p<<M,p>>M):
 e=h(n&P,b[o])
 if~b[m]&N(e)<1<=n&b[o]:b[o]&=~e
_,B,W=b
g=~b[o]&N(h(p,b[m]))>=1>~_&p
print(+g)
q=''
while j<Z:
 r=1<<j
 if g*j%M>M-2:print(q);q=''
 else:q+='012E'[(r&B>0)+(r&W>0)*2]
 j+=1

बोर्ड का प्रतिनिधित्व करने के लिए 3 बिटफिल्ड का उपयोग करता है - एक, काले, सफेद और खाली स्थानों के लिए। खोज पड़ोसियों को बनाता है Nऔर श्रृंखला hसंचालन को बहुत संक्षिप्त करता है।

बहुत सारी टिप्पणियों के साथ एक अनगुल्ड संस्करण: https://gist.github.com/airfrog/8429006

— airfrog
स्रोत

आपके पास प्रत्येक पंक्ति के अंत में बहुत सी जगहें हैं, आपके द्वारा पोस्ट की गई फ़ाइल में 2732 बाइट्स हैं।

— एडिट्स ने छोड़ दिया क्योंकि SE

@aditsu अब तय होनी चाहिए

— airfrog

आकार अभी भी गलत है, 555 अब होना चाहिए :) इसके अलावा मुझे आश्चर्य है कि अगर आप अभी भी अधिक अर्धविराम का उपयोग करके कुछ बाइट्स बचा सकते हैं।

— एडित्सू ने छोड़ दिया क्योंकि एसई ईवीआईएल

बग? इनपुट: 6 000000 011221 121121 122221 011110 000000 4 0 1आउटपुट: 0. अब उदाहरण के रूप में जोड़ा गया 4.

— aditsu छोड़ दिया क्योंकि एसई EVIL

यह बग तय हो गया है, मैंने इसे ढूंढते हुए एक और बग भी तय किया है जिसे आप एक उदाहरण के रूप में जोड़ना चाह सकते हैं। इनपुट: 5 22100 20211 12211 12120 01120 1 1 2आउटपुट 0. होना चाहिए

— एयरफ्रॉग

अजगर ( 912 1004)

def o():
 n=int(raw_input(''))
 i=[raw_input('') for r in range(n+1)]
 b=[map(int,list(r)) for r in i[:n]]
 u,v,w=map(int,i[n].split(' '))
 if b[v][u]!=0:return 0
 b[v][u]=w
 if w==1:q=2
 elif w==2:q=1
 else:return 0
 f=[[],[],[]]
 h=[[],[],[]]
 g=[range(z*n,(z+1)*n) for z in range(n)]
 d=[(1,0),(-1,0),(0,1),(0,-1)]
 m=lambda z:max(0,min(n-1,z))
 t=[0,1,2,0,1]
 for j,s in enumerate(t):
  for r in range(n):
   for c in range(n):
    for y,x in map(lambda p:(m(r+p[0]),m(c+p[1])),d):
     if s==0:
      if b[y][x]==b[r][c]:
       if g[y][x]!=min(g[y][x],g[r][c]):
        t.insert(j+1,0)
       g[y][x]=g[r][c]=min(g[y][x],g[r][c])
     elif s==1:
      if g[r][c] not in h[b[r][c]]:
       h[b[r][c]].append(g[r][c])
      if b[y][x]==0 and g[r][c] not in f[b[r][c]]:
       f[b[r][c]].append(g[r][c])
    if s==2:
     if b[r][c]==q and g[r][c] not in f[b[r][c]]:
      b[r][c]=0
 h[w].sort()
 f[w].sort()
 if h[w]!=f[w]:return 0
 return "1\n"+'\n'.join([''.join(map(str,r)) for r in b])
print o()

के माध्यम से चलो: पार्स इनपुट, जाँच करें कि क्या चाल एक खाली जगह पर है, चाल करें, इनिट "समूह" ग्रिड, आसन्न पत्थरों के रंग की जाँच करके समूह ग्रिड को सरल / छोटा करें (s = 0) और जब तक यह पूरी तरह से छोटा न हो जाए , तब तक दोहराते रहें समूह की स्वतंत्रता के लिए (s = 1), बिना किसी स्वतंत्रता वाले समूहों के लिए प्रतिद्वंद्वी पत्थरों को हटा दें (s = 2), दोहराएँ s = 0 और s = 1, जांचें कि सभी खिलाड़ी समूहों में स्वतंत्रताएं हैं, परिणाम लौटाएं।

यह संभवतः काफी छोटा किया जा सकता है ...

~~इंटरएक्टिव~~ उदाहरण चलाता है:

— Jur
स्रोत

आपका कार्यक्रम कुछ भी नहीं करता है, यह केवल एक फ़ंक्शन को परिभाषित करता है।

— एडित्सो ने छोड़ दिया क्योंकि एसई ईवीआईएल

इसे अंतःक्रियात्मक रूप से चलाएं और प्रिंट ओ () के साथ कॉल करें जैसा कि उदाहरण में दिखाया गया है ...

— jur

नहीं। यह एक स्टैंडअलोन प्रोग्राम माना जाता है जिसे आप कमांड लाइन से चलाते हैं। इसके अलावा, यह भी कम कर देगा।

— एडिट्स ने छोड़ दिया क्योंकि SE 8:13 पर EVIL

अंतिम पंक्ति पर प्रिंट ओ () जोड़कर इसे फिक्स्ड करें

— jur

केवल फ़ंक्शन बॉडी (बहिष्कृत) का उपयोग क्यों नहीं किया जाता है? और मुझे लगता है कि आप नए जोड़े गए उदाहरण 4 को भी विफल कर देते हैं

— एडित्सू ने छोड़ दिया क्योंकि एसई ईवीआईएल