क्या यह टिक-टैक-टो बोर्ड मान्य है?

48

चुनौती

किसी भी प्रारूप में टिक-टैक-टो बोर्ड को देखते हुए, यह निर्धारित करें कि यह वैध है या नहीं। यदि कोई बोर्ड टिक-टैक-टो गेम का परिणाम हो सकता है, तो यह मान्य है। उदाहरण के लिए, यह बोर्ड मान्य है:

XOX
OXO
XOX
इसके विपरीत, यह बोर्ड अमान्य है:

XXX
XXO
OOO

इनपुट

  • एक पूर्ण (9/9) टिक टीएसी को पैर की अंगुली बोर्ड (परिणाम, खेल नहीं)।

नियम

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

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

मान्य:

XOX
OXO
XOX

XOX
XOX
OXO

Xóõ
OOX
OXX

OXO
XOX
OXO

अमान्य:

XXX
XXX
XXX

OOO
OOO
OOO

XXX
OOO
XXX

OOO
OOX
XXX

XXO
OXO
OOX

एक छोटा सा सहयोग?

एक बोर्ड को वैध माना जाता है (इस चुनौती के लिए) यदि और केवल तभी यदि निम्नलिखित दो स्थितियाँ हैं:

  • 5 एक्स और 4 ओ, या 4 एक्स और 5 ओ हैं। उदाहरण के लिए, 
    XXX
OXO
XXX
    को अमान्य माना जाता है, क्योंकि 7 Xs और 2 Os हैं।
  • केवल 5 अंकों वाले खिलाड़ी ही जीते हैं, या उनमें से कोई भी नहीं जीता है। उदाहरण के लिए, 
    XXX
OOO
OOX
    को अमान्य माना जाता है, क्योंकि या तो Os की पंक्ति या s की पंक्ति Xपहले बनाई जाएगी। दोनों खिलाड़ी एक साथ अपनी बारी नहीं कर सकते।

वर्तमान विजेता है ...

... ais523 के जेली जवाब , एक आश्चर्यजनक 26 बाइट्स पर!

code-golf  decision-problem  tic-tac-toe 
— आउटगोल्फर को एरिक करें
स्रोत
2
हो सकता है कि एक टेस्ट-केस को भी जोड़ दें O O O X O X X O X, यह दिखाने के लिए कि एक ही खिलाड़ी में क्षैतिज और ऊर्ध्वाधर दोनों पंक्ति हो सकती हैं।
— smls
2
आपको बोर्ड के अंकों को व्यक्तिगत रूप से बताना होगा। मैं उस हिस्से को समझने के लिए निश्चित नहीं हूं। क्या आप एक प्रतिरूप प्रदान कर सकते हैं?
— Arnauld
3
@ टिम एक्स के 4 अंक हैं।
— मार्टिन एंडर
2
@Sparr "केवल 5 अंकों के साथ खिलाड़ी जीता है, या उनमें से कोई भी जीता है।"
— मार्टिन एंडर
2
@ केविन (पहली टिप्पणी का उत्तर दें) क्योंकि कोई भी 9/9 बोर्ड कभी पूरा नहीं होगा यदि दूसरा खिलाड़ी (4 अंक वाला खिलाड़ी) जीतता है।
— एरिक आउटोलॉफ़र

जवाबों:

11

जेली , 26 बाइट्स

ṢŒrṪ4=$$Ðfx3ðœ-µẆm€6R¤;/µL

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

इनपुट प्रारूप थोड़ा असामान्य है; यह बोर्ड का प्रतिनिधित्व करने वाला एक स्ट्रिंग है, लेकिन विंडोज के साथ नई सुर्खियों में (गाड़ी की वापसी के बाद न्यूलाइन)। उदाहरण के लिए, XXO\r\nOXO\r\nOOX। (वास्तव में, लाइनों के बीच कोई भी दो-चरित्र पैडिंग स्ट्रिंग काम करती है, लेकिन विंडोज के नए समाचार अन्य विकल्पों की तुलना में बहुत अधिक रक्षात्मक हैं।)

मूल विचार यह है कि हम उन वर्णों की तलाश करते हैं जो इनपुट में 4 बार दिखाई देते हैं, लेकिन मूल स्ट्रिंग में तीन समान रूप से होने वाली घटनाएं नहीं होती हैं। 3 × 3 ग्रिड की रेखाओं के बीच दो या दो से अधिक अक्षरों के साथ, सभी क्षैतिज, ऊर्ध्वाधर और विकर्ण रेखा समान रूप से दूरी पर हैं, लेकिन कोई अन्य समान रूप से गोलाकार रेखा में तीन तत्व नहीं हो सकते हैं।

स्पष्टीकरण:

ðऔर µरों हैं श्रृंखला विभाजक , जो कई भागों है कि प्रत्येक स्वतंत्र हैं में कार्यक्रम अलग हो गए। चीजों को थोड़ा स्पष्ट करने के लिए मैंने उन्हें नीचे रिक्त स्थान से बदल दिया है।

ṢŒrṪ4=$$Ðfx3 œ- Ẇm€6R¤;/ L
Ṣ                           sorted version of the input
 Œr                         run-length-encode it
        Ðf                  keep only elements where
   Ṫ                        delete the last element, and it was
    4=                      equal to 4
      $$                    parse Ṫ4= as a group
          x3                repeat each element three times

                Ẇ           all sublists of the input
                 m€         take every nth element of each (€) sublist
                   6R       for each n in 1..6
                     ¤      parse 6R as a group
                      ;/    flatten one level (m€ creates a nested structure)

             œ-             multiset difference
                         L  length of that difference

दूसरे शब्दों में, हम उन वर्णों की सूची पाते हैं जो इनपुट में चार बार दिखाई देते हैं, और उनमें से प्रत्येक की तीन प्रतियों से मिलकर एक सूची बनाते हैं; हम उन सभी क्रमों की सूची पाते हैं जो मूल स्ट्रिंग में समान रूप से स्थित हैं; और अगर हम दूसरे को पहले से घटाते हैं, तो हम चाहते हैं कि परिणाम की लंबाई 1 हो (यानी एक खिलाड़ी ने चार बार खेला लेकिन जीत नहीं पाया)। ध्यान दें कि जैसा कि हम 3 × 3 ग्रिड पर हैं और हर वर्ग भरा हुआ है, दोनों खिलाड़ियों के लिए चार बार खेलना असंभव है। जेली में, 1 सत्य है, 0 गलत है, इसलिए हमें परिणामी सूची को बूलियन में बदलने के लिए कुछ विशेष करने की आवश्यकता नहीं है। (दॅ µLकी आवश्यकता है, हालांकि, क्योंकि अन्यथा दोनों “XXX”और “OOO”संभव truthy उत्पादन मूल्यों, और सवाल होगा की आवश्यकता है कि सभी वैध बोर्डों एक ही आउटपुट देते हैं।)

— ग्रेग मार्टिन
स्रोत
3
यह पूरी तरह से पठनीय है।
— पैरामैब
21

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

s=>(a=[...s]).sort()[5]-a[3]&[7,56,73,84,146,273,292,448].every(j=>j&i,i=`0b`+s^~-a[4])

9 के एक स्ट्रिंग के रूप में इनपुट लेता है 0और 1वर्ण और रिटर्न 1मान्य के लिए, 0अवैध के लिए। हम वर्णों को क्रम में क्रमबद्ध करते हैं। यदि मध्य तीन वर्ण अब समान हैं तो बोर्ड अमान्य है क्योंकि बहुत सारे एक टुकड़े हैं। अन्यथा, हम मूल बोर्ड को बाइनरी में परिवर्तित करते हैं, बिट्स को फ्लिप करते हैं अगर 0एस से अधिक एस होते हैं 1। इस बिंदु पर बोर्ड मान्य है अगर 0तीन की एक पंक्ति नहीं है, इसलिए हम बस सभी आठ लाइनों का परीक्षण बिटमास्क की एक सरणी के माध्यम से करते हैं। संपादित करें: @ बाइट्स के लिए 1 बाइट का धन्यवाद सहेजा गया।

— नील
स्रोत
@ETHproductions आह, बेशक, परिणाम केवल 0 या 1 होने जा रहा है।
— नील
14

पायथन 3, 131 127 125 100 96 बाइट्स

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

def z(b):return int('agqozfx67wwye6rxr508ch2i8qicekpreqkap0725pk',36)<<24&1<<b+(b>255)*(511-b-b)

परीक्षण मूल्य:

X X X
O X O
X X X

बाइनरी मान के रूप में दर्शाया गया है 0b111010111, और यदि बोर्ड मान्य है, तो फ़ंक्शन गैर-शून्य मान देता है।

— केन वाई एन
स्रोत
4 कम बाइट्स के लिए इंटरमीडिएट चर को हटा दिया गया
— केन वाईएन
दो कम बाइट्स के रूप में a&(1<<b)कोष्ठक की जरूरत नहीं है।
— केन वाईएन
समरूपता का उपयोग करके 25 बाइट्स को बंद करके और 24 सबसे कम शून्य बिट्स को संक्षिप्त करके एक - एक गोल्फर को करना होगा if b>255:b=511-b!
— केन YN
करने के लिए एक गोल्फ रास्ता मिला if।
— केन वाईएन
11

बैच, 140 बाइट्स

@set/aXXX=OOO=O=0
@for %%l in (%* %1%2%3 %1%4%7 %1%5%9 %2%5%8 %3%5%7 %3%6%9 %4%5%6 %7%8%9)do @set/a%%l+=1
@cmd/cset/a!XXX*!(O-=5)+!OOO*!~O

अमान्य 1और 0अमान्य के लिए नौ अलग-अलग कमांड-लाइन तर्क और आउटपुट के रूप में इनपुट लेता है । समय की संख्या पर नज़र रखने से काम करता है यह एक देखता है Oऔर की एक ओर्थोगोनल लाइन OOOया XXX। आसानी से बैच हमें परोक्ष रूप से पूर्णांक अंकगणितीय प्रदर्शन करने की अनुमति देता है, इसलिए हम वेतन वृद्धि नहीं कर रहे हैं, %%lलेकिन इसके बजाय कुछ चर (हालांकि हम केवल तीन चर उल्लिखित में रुचि रखते हैं)। फिर हमें यह परखना होगा कि या तो Xजीता नहीं है और पाँच Oएस हैं या जो Oनहीं जीते हैं और चार Oएस हैं।

— नील
स्रोत
10

मैथेमेटिका, 82 75 बाइट्स

7 बाइट बचाने के लिए मार्टिन एंडर को धन्यवाद!

t=Total;3<(b=#~t~2)<6&&{t[c=If[b>4,1-#,#]],t/@c,Tr@c,Tr@Reverse@c}~FreeQ~3&

इनपुट और आउटपुट Trueया के रूप में 1s और 0s की 3x3 नेस्टेड सूची लेने का कार्य करें False।

Totalफ़ंक्शन के कुछ आसान लचीलेपन का उपयोग करता है (यहां गोल्फ के लिए t): एक उदाहरण सरणी को देखते हुए e = { {1,2,3} , {4,5,6} , {7,8,9} }, कमांड t[e]तीन वैक्टर (यहां उपज {12,15,18}) देता है; कमांड t/@eप्रत्येक सबलिस्ट को व्यक्तिगत रूप से (यहां उपज {6,15,24}) देता है; और कमांड e~t~2सभी नौ तत्वों (यहां उपज 45) को बोता है ।

तो पहले हम परीक्षण करते हैं 3<(b=#~t~2)<6, कि क्या 1s की कुल संख्या 4 या 5 है; यदि हम बाहर नहीं निकलते हैं False। यदि हां, तो हम c=If[b>4,1-#,#]बलपूर्वक चार 1 s का प्रयोग करते हैं, पाँच का नहीं। फिर हम कॉलम रकम t[c], पंक्ति रकम t/@c, मुख्य विकर्ण Tr@cका योग और विपरीत विकर्ण का योग की गणना करते हैं , और यह जांचने के लिए Tr@Reverse~cउपयोग ~FreeQ~3करते हैं कि 3उन संगणित रकम में किसी भी स्तर पर प्रकट होने में विफल रहता है।

मनोरंजक पक्ष नोट: इस साइट पर अधिकांश दिखावे के विपरीत, यहाँ Trएक आयामी सूची का योग करने के लिए उपयोग नहीं किया जाता है , लेकिन वास्तव में इसका उपयोग दो-आयामी मैट्रिक्स के ट्रेस की गणना करने के लिए किया जाता है!

— ग्रेग मार्टिन
स्रोत
6

पायथ - 36 बाइट्स

मैं डायगास को शामिल करता हूं और इसके बजाय दो टर्नरी का उपयोग करता हूं।

JsM+sCBQm@VdU3_BQ?q5KssQ*FJ?qK4!}3JZ

परीक्षण सूट

— Maltysen
स्रोत
5

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

एक 9-बिट बाइनरी मास्क के रूप में इनपुट लेता है, जहां X = 1और O = 0(MSB = शीर्ष बाएं सेल, LSB = निचला दायां सेल)।

n=>[7,56,73,84,146,273,292,448,o=x=0].map((m,i)=>(c-=n>>i&1,m&n^m?m&n||o++:m&&x++),c=4)&&!(c|x&&~c|o)

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

कोड स्निपेट दिखाएं

— Arnauld
स्रोत
मैं जानता था कि वहाँ एक (कुछ) सरल बिटवाइज़ समाधान होना था। अच्छा काम
— ETHproductions
5

अजगर 2, 158 132 109 92 91 123 बाइट्स

def v(b):f=sum(b,());w={x[0]for x in b+zip(*b)+[f[::4],f[-3:1:-2]]if len(set(x))==1};return sum(map(`b`.count,w))==len(w)*5

इनपुट पंक्तियों की एक सूची / टपल है, प्रत्येक तीन-स्ट्रीप ऑफ़ स्ट्रिंग्स, उदा:
[('X', 'O', 'X'), ('O', 'X', 'O'), ('X', 'O', 'X')]

@ माल्टीसेन के उत्तर के अनुसार विकर्णों की अनदेखी करके कुछ बाइट्स को बचाया, जिसने निम्नलिखित अभिव्यक्ति को भी छोटा कर दिया।

बचत के लिए धन्यवाद @vaultah 17 18 बाइट्स।

विकर्णों की जाँच करना आवश्यक हो जाता है, जिससे ऊपर की बहुत बचत हुई।

इसे यहाँ आज़माएँ।

व्याख्या

def v(b):
  f=sum(b,())
  w={x[0]for x in b+zip(*b)+[f[::4],f[-3:1:-2]]if len(set(x))==1}
  return sum(map(`b`.count,w))==len(w)*5

fटुकड़ा करने की क्रिया के लिए चपटा इनपुट है।
wविजयी दृश्यों के साथ वर्ण शामिल हैं।
प्रत्येक विजेता चरित्र की घटनाओं को गिनें, जो या तो 0 होगा, यदि wखाली है या 5 है, तो len(w)1. 10 राशि है जब दोनों में एक विजयी क्रम असंभव है। 5 जीतने वाले का अर्थ है कि हारने वाले के पास 4. आपके पास जीतने का क्रम नहीं है।

— जेक कोब
स्रोत
lambda b:len({x[0]for x in b+zip(*b)if len(set(x))==1})<2and set(map(b .count,'XO'))=={4,5}कुछ बाइट्स बचाता है।
— तिजोरी
और मैंने अभी देखा कि ...and{4,5}==set(map(b .count,'XO'))एक और बाइट बचाता है।
— तिजोरी
मुझे लगता है कि यह गलत तरीके से पिछले "अमान्य" उदाहरण को प्रश्न से वैध मानता है, क्योंकि यह सुनिश्चित नहीं करता है कि विजेता 5 अंकों के साथ खिलाड़ी है।
— SMLS
@smls आप सही कह रहे हैं। उस स्थिति की जाँच में बहुत सारे बाइट्स खर्च होते हैं, हो सकता है कि इसे और आगे बढ़ाया जा सके।
— जेक कॉब
5

आर, 88 82 बाइट्स

x=scan();`if`(sum(x)%in%4:5,all(apply(combn(which(x==(sum(x)<5)),3),2,sum)!=15),F)

1 से 9 तक के तीन पूर्णांक जो 15 तक योग करते हैं, वे नीचे दिखाए गए वर्ग की पंक्तियों / कॉलम / विकर्ण हैं।

2 7 6
9 5 1
4 3 8

यह फ़ंक्शन बूलियन्स के वेक्टर के रूप में इनपुट लेता है, "X" के लिए T, "O" के लिए F, जो बोर्ड का चपटा प्रतिनिधित्व है। लेकिन, इन्हें फिर से व्यवस्थित किया गया है ताकि इनका सूचकांक क्रम में (क्रमांक 2,7,6,9,5,1,4,3,8) संख्या के समान हो। उस आदेश को सामान्य तरीके से बोर्ड को समतल करके प्राप्त किया जा सकता है, और फिर सी (6,1,8,7,5,3,2,2,4,4) द्वारा स्लाइस किया जा सकता है। तो यह

X O X
O X O
X O X

के रूप में प्रतिनिधित्व किया है:

c(T, F, T, F, T, F, T, F, T)[c(6,1,8,7,5,3,2,9,4)]

जो है:

c(F, T, F, T, T, T, F, T, F)

फ़ंक्शन पहले निर्धारित करता है कि क्या कोई खिलाड़ी ठीक चार अंकों के साथ है। यदि ऐसा है, तो फ़ंक्शन इस बात का निर्धारण करने के लिए तथ्य-की-चीजों-ऐड-अप-टू -15 का उपयोग करता है कि क्या उस खिलाड़ी के पास एक तीन-इन-पंक्ति है (बोर्ड अमान्य iff है कि खिलाड़ी करता है)।

यदि आप एक पारंपरिक रूप से चपटा बोर्ड इनपुट के रूप में लेना चाहते हैं, तो कोड इस तरह दिखाई देगा:

f=function(x)ifelse(sum(x)%in%4:5,all(apply(combn(c(2,7,6,9,5,1,4,3,8)[which(x==(sum(x)<5))],3),2,sum)!=15),F)

मैं इस पर नया हूँ, सलाह की सराहना की जाएगी।

— ixodesbeta
स्रोत
1
यदि आप if()इसके बजाय उपयोग करते हैं तो 2 बाइट्स सहेजें : f=function(x)यदि (sum(x)%in%4:5,all(apply(combn(which(x==(sum(x)<5)),3),2,sum)!=15),F)। बड़े पैमाने पर परीक्षण नहीं किया गया है। Backticks खंडहर कोड, लेकिन यह है backtick if backtick(।
— जोनाथन कैरोल
1
और भी बेहतर; x=scan();अगर (sum(x)%in%4:5,all(apply(combn(which(x==(sum(x)<5)),3),2,sum)!=15),F)और इनपुट के रूप में 1और 0। 82 बाइट्स।
— जोनाथन कैरोल
3

जावास्क्रिप्ट (ईएस 6), 145 139 131 127 बाइट्स

s=>!(q="XO"[s.split`O`.length-5])|![...s].some((c,i)=>c==q&!/(.)(\1|..(\1|.(\1|.\1.).)..)\1/.test(s.slice(0,i)+0+s.slice(i+1)))

इनपुट एक अलग-अलग स्ट्रिंग के रूप में, जैसे "XOX OXO XOX"। 1अमान्य बोर्ड के लिए आउटपुट , 0वैध के लिए। यह स्पष्ट रूप से सबसे अच्छी तकनीक नहीं है, कम से कम जावास्क्रिप्ट के साथ नहीं ...

यह मूल रूप से जाँच करता है कि दोनों निम्नलिखित पकड़:

  • वहाँ बिल्कुल 4 या 5 Os हैं, और
  • कम से कम 5-इंस्टेंस के टुकड़े में से एक है जो हटाए जाने पर एक अनिर्दिष्ट गेम बनाता है।

रेगेक्स यह जांचना है कि क्या कोई गेम तय किया गया है। यह एक बोर्ड से मेल खाता है यदि 0 (पंक्ति), 2 (डाउन-राइट विकर्ण), 3 (स्तंभ), या 4 (नीचे-बाएँ विकर्ण) वर्णों के साथ एक जोड़ी की लंबाई के किसी भी तीन रन होते हैं, तो प्रत्येक जोड़ी को अलग करता है।

टेस्ट स्निपेट

कोड स्निपेट दिखाएं

— ETHproductions
स्रोत
2

रूबी, 104 99 91 बाइट्स

->x{[7,56,448,292,146,73,84,273].none?{|y|b=x.to_i 2;((a=x.count'1')==4?b:a==5?~b:7)&y==y}}

इनपुट प्रारूप: 9 प्रतीकों (0s और 1s) के बाइनरी स्ट्रिंग बोर्ड का प्रतिनिधित्व करते हैं, उदाहरण के लिए पहला परीक्षण मामला है 101010101। पहले इसे एक बाइनरी नंबर में कनवर्ट करें, जांचें कि क्या पॉपकाउंट 4 या 5 है, यदि यह संख्या 5 उल्टा है, तो हमारे पास हमेशा 4 है। अगर उनमें से तीन गठबंधन किए गए हैं (तो क्षैतिज, ऊर्ध्वाधर, विकर्ण मास्किंग) की जांच करें।

TL; DR : 4 अंक के साथ खिलाड़ी जीता हुआ झूठा लौटें, अन्यथा सही।

टिप्पणी के लिए धन्यवाद जॉर्डन,

मैं UTF-8 स्ट्रिंग को पुन: उत्पन्न नहीं कर सकता जो एक अन्य बाइट को बचाएगा।

— जीबी
स्रोत
आप बदल सकते हैं .select{...}[0]के साथ .find{...}।
— जॉर्डन
और आप संख्या के सरणी को बदलकर एक और बाइट बचा सकते हैं "8ǀĤITđ".unpack("U*")(यदि अनुवाद में कुछ खो जाता है, तो स्ट्रिंग pack("U*")मूल सरणी पर कॉल करने का परिणाम है ; यह 12 बाइट्स है)।
— जॉर्डन
क्या आप any?इसके बजाय उपयोग कर सकते हैं none?, आउटपुट को फ़्लिप कर सकते हैं और पूरे बाइट को बचा सकते हैं?
— एलेक्सिस एंडरसन
मैंने एक के साथ कोशिश की? इसके बजाय कोई नहीं? लेकिन फिर मुझे एक चाहिए! उत्पादन फ्लिप करने के लिए।
— जीबी
1

पर्ल 6 , 103 99 बाइट्स

{my \c=%(.flat.Bag.invert)<5>;?all c,|(.[0]===c if [eq] $_ for |.flat[<0 4 8>,<2 4 6>],|$_,|.&zip)}

एक लंबोदर जो सूचियों की सूची को स्वीकार करता है (('X','O','X'), ('O','X','O'), ('X','O','X')), और एक बूल लौटाता है।

यह इस तरह काम करता है:

  1. चेक करें कि कौन सा चिह्न 5 बार दिखाई देता है, और इसे स्टोर करें c। (यदि कोई चिह्न ठीक 5 बार नहीं दिखाई देता है, तो इसमें एक गलत मान होगा)
  2. सभी विकर्णों, पंक्तियों और स्तंभों पर इरेट करें और "जीतने वाले" (अर्थात जहां तीनों अक्षर समान हों) को फ़िल्टर करें ।
  3. जांचें कि cक्या सत्य है, और प्रत्येक जीतने वाली रेखा प्रकार की है c।
— SMLS
स्रोत
1

PHP, 125 बाइट्स

for($p=$n=$argv[1];$p;$p/=2)$i+=$p&1;foreach([7,56,448,73,146,292,273,84]as$m)$n&$m^$m?$n&$m||$o++:$x++;echo!$x|!$o&&2>$i^=4;

मैं के रूप में ही विचार था Arnauld : बोर्ड मान्य है अगर वहाँ या तो 4 या 5 बिट्स सेट कर रहे हैं और या तो Xया Oया कोई भी एक लकीर है (लेकिन दोनों नहीं)।

फ़ील्ड के Xसाथ इनपुट को उत्पन्न करने के लिए 1और Oसाथ में 0, लाइनों को मिलाएं और बाइनरी को दशमलव में परिवर्तित करें, कमांड लाइन तर्क के रूप में प्रदान करें।

1मान्य के लिए प्रिंट ; अमान्य के लिए खाली आउटपुट। के साथ भागो -r।

टूट - फूट

// count set bits
for($p=$n=$argv[1];$p;$p/=2)$i+=$p&1;
    /* ($p/=2 takes longer than $p>>=1, but eventually
       $p will come close enough to 0 for the loop to finish */
// count streaks for X and O
foreach([7,56,448,73,146,292,273,84]as$m)
    $n&$m^$m            // ($n masked with streak)!=streak <=> no streak for X
        ?$n&$m||$o++    // true: O has a streak if ($n masked with streak) is empty
        :$x++;          // false: X has a streak
echo!$x|!$o&&2>$i^=4;   // valid if not both have a streak
                        // AND $i is 4 or 5 (toggle 4 -> result 0 or 1)
— टाइटस
स्रोत
1

स्विफ्ट, 178 बाइट्स

func t(i:String)->Bool{let r=i.characters.filter({$0=="X"}).count;let g=i.characters.split(separator:"\n").map(String.init).contains;return(r==5||r==4)&&(!g("XXX") && !g("OOO"))}
— कालेब क्लेवेटर
स्रोत
0

ES6 (Javacript), 130, 138, 117 बाइट्स

संपादन:

  • @ नील से उत्कृष्ट सलाह के लिए 21 बाइट्स धन्यवाद!
  • प्रारंभिक संस्करण बग के लिए प्रवण था, जिसे अब +8 बाइट्स की कीमत पर तय किया जाना चाहिए। (साभार @ETHproductions इसे इंगित करने के लिए)

एक एक्स्टेलीली straighforward दृष्टिकोण। शायद थोड़ा और आगे बढ़ा जा सकता है।

इनपुट को 9 अलग-अलग तर्कों, 1es और 0es के रूप में स्वीकार करता है

  • 1 के लिए है एक्स
  • 0 के लिए है हे

तर्क: 1-3 - पहली पंक्ति, 4-6 - दूसरी पंक्ति, 7-9 - तीसरी पंक्ति।

golfed

(a,b,c,d,e,f,g,h,j)=>![a+b+c,d+e+f,g+h+j,a+d+g,b+e+h,c+f+j,a+e+j,g+e+c,7].some(x=>x=="7777307777"[a+b+c+d+e+f+g+h+j])

इंटरएक्टिव "टेस्ट बेड"

var a=b=c=d=e=f=g=h=j=0;

T=(a,b,c,d,e,f,g,h,j)=>![a+b+c,d+e+f,g+h+j,a+d+g,b+e+h,c+f+j,a+e+j,g+e+c,7].some(x=>x=="7777307777"[a+b+c+d+e+f+g+h+j]);

function test() {
  if(T(a,b,c,d,e,f,g,h,j)) {
     grid.style.backgroundColor='green';
     msg.innerHTML="GOOD"
  } else {
     grid.style.backgroundColor='red';
     msg.innerHTML="BAD"
  }
}
<table id=grid style="background: red">
<thead>
  <tr>
     <td id=msg align="center" colspan="3">BAD</td>
    </tr>
  </thead>
  <tr>
      <td><input type="checkbox" onchange="a=this.checked*1;test();" id="ca"/></td>
      <td><input type="checkbox" onchange="b=this.checked*1;test();" id="cb"/></td>
      <td><input type="checkbox" onchange="c=this.checked*1;test();" id="cc"/></td>
    </tr>
    <tr>
      <td><input type="checkbox" onchange="d=this.checked*1;test();" id="cd"/></td>
      <td><input type="checkbox" onchange="e=this.checked*1;test();" id="ce"/></td>
      <td><input type="checkbox" onchange="f=this.checked*1;test();" id="cf"/></td>
    </tr>
    <tr>
      <td><input type="checkbox" onchange="g=this.checked*1;test();" id="cg"/></td>
      <td><input type="checkbox" onchange="h=this.checked*1;test();" id="ch"/></td>
      <td><input type="checkbox" onchange="j=this.checked*1;test();" id="cj"/></td>
    </tr>
 </table>
स्निपेट का विस्तार करें

— टसेपेल्लिन
स्रोत
मैं गलत हो सकता हूं, लेकिन ऐसा लगता है कि यह केवल जांच करता है कि क्या कोई विजेता है। एक वैध बोर्ड का कोई विजेता नहीं हो सकता; उदाहरण के लिए, [1,0,1,1,0,1,0,1,0]( XOX XOX OXO)।
— ETHproductions
हां, मैंने इसे गॉल्फ़ करते हुए नकार को खो दिया है। यह जाँचना चाहिए कि विपरीत पक्ष विजेता नहीं है। अब तय होना चाहिए। धन्यवाद !
— ज़ेपेलिन
(मैंने नवीनतम संपादन से पहले टिप्पणी करना शुरू कर दिया है) क्या आप ए) a+b+c+d+e+f+g+H+iइसके बजाय लिख सकते हैं F.reduce((r,c)=>r+=c*1)(जिस बिंदु पर आपको ज़रूरत नहीं है F) बी) लिखना .includes(C)(और इनलाइन Cमान पर जाएं)?
— नील
@ नील, यह शायद काम करेगा, मैं इसे कल एक कोशिश करूँगा। धन्यवाद !
— ज़ेपेलिन
है OOO XXX OXOएक असफल?
— इस्माइल मिगुएल
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.