फोर वालिडेटर कनेक्ट करें

Question

परिचय

कनेक्ट फोर एक ऐसा खेल है जहाँ आप चार को एक पंक्ति में लाने का प्रयास करते हैं: क्षैतिज रूप से, लंबवत या तिरछे। इस कोड गोल्फ में, हम यह पता लगाने की कोशिश करेंगे कि कौन जीता, एक गेम बोर्ड दिया गया। हमेशा एक विजेता होगा, और केवल एक विजेता होगा।

---

कार्य

कनेक्ट फोर बोर्ड को देखते हुए यह पता लगाएं कि विजेता कौन है: Xया Y। हमेशा एक विजेता होगा, और केवल एक विजेता होगा। बोर्ड का आकार हमेशा 6 बाई 7 होगा जैसे गेम बोर्ड चित्र में कैसा है।

एक बोर्ड को देखते हुए, निम्नलिखित बोर्ड में, Xलाल है और Yनीला है:

आपका इनपुट होगा:

OOOOOOO
OOOOOOO
OOOOOOO
OOOOXOO
OOOXXOO
OOXYYYY

आप गेम की पंक्तियों को नईलाइन वर्ण (जैसे ऊपर) से अलग कर सकते हैं, कोई विभाजन वर्ण नहीं, पंक्तियों को एक सरणी या सूची में विभाजित कर सकते हैं, या आप वर्णों का एक मैट्रिक्स इनपुट कर सकते हैं।

इस उदाहरण के लिए सही आउटपुट:

Y

Y की एक पंक्ति में चार हैं; हां, Y विजेता है। इसलिए, हम Y का उत्पादन करते हैं।

---

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

इनपुट:

OOOOOOO
OOOOOOO
OOOOOOO
OOOOOOO
OOYYOOO
OYXXXXO

आउटपुट:

X

---

इनपुट:

OOOOOOO
OOOOOOO
OOOOOOO
XXXXOOO
YXYYOOO
YXYYXYX

आउटपुट:

X

---

इनपुट:

YXYYXOO
XYXXYOO
XXXYYOO
YYYXXOO
XXYYYYO
XXYYXXO

आउटपुट:

Y

---

इनपुट:

OOOOOOO
OOOOOOO
OYOOOOO
OOYOOOO
OOOYOOO
OOOOYOO

आउटपुट:

Y

---

इनपुट:

OOOOOOO
OOOOOOO
OYOOOOX
OOYOOOX
OOOXOOX
OXOXYOX

आउटपुट:

X

स्कोरिंग

बाइट्स जीत की कम से कम संख्या!

Comments

यह PMA / घोंघे codegolf.stackexchange.com/questions/47311/… के

— जैरी यिर्मयाह

क्या हम मान सकते हैं कि विजेता के पास हमेशा हारने वाले की तुलना में एक अधिक टोकन होगा?

— गणित नशेड़ी

@ मैथजंकी मैं गलत था, आप ऐसा नहीं मान सकते।

— नील

@nfnneil आउटपुट को X या Y होना चाहिए या क्या हम विजेता को इंगित करने के लिए दो अन्य संगत आउटपुट चुन सकते हैं?

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

क्या हम अन्य वर्णों को इनपुट के रूप में उपयोग कर सकते हैं? या एक संख्यात्मक मैट्रिक्स इनपुट करने के लिए?

— लुइस मेंडू

Answer 1

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

UŒD;ŒD;Z;ṡ€4;/ṢEÞṪṪ

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

इस उत्तर के मूल को मेरे उत्तर से इसी समान प्रश्न पर कॉपी किया जाता है ।

व्याख्या

UŒD;ŒD;Z;ṡ€4;/ṢEÞṪṪ
   ;  ; ;             Append {the input} and the following three values:
UŒD                     the antidiagonals of {the input};
    ŒD                  the diagonals of {the input};
       Z                the transposed {input}.
         ṡ 4          Find all length-4 substrings
          €             of each subarray within that.
            ;/        Flatten one level.
                Þ     Sort, with the following sort order:
               E        If all elements are the same, sort later.
              Ṣ         Tiebreak via lexicographical order.
                 ṪṪ   Take the last element of the last element.

काफी सरल: हम सभी पंक्तियों, स्तंभों, विकर्णों और एंटीडिओगोनल्स (बस के रूप में n- क्वीन्स वैलिनेटर में) को लेते हैं, फिर उन सभी की लंबाई-4 सबस्ट्रिंग लेते हैं, फिर उन्हें इस तरह से क्रमबद्ध करते हैं कि जीतने वाली पंक्ति 4 तरह की हो समाप्त। (हम टाईब्रेक मामले में वहाँ एक है की जरूरत OOOOके अलावा XXXXया YYYY।) पिछले तत्व के अंतिम तत्व ले लो, और कहा कि हो जाएगा Xया Yके रूप में की आवश्यकता है।

Answer 2

रेटिना, 51 48 बाइट्स

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

M`X((.{6}X){3}|(.{8}X){3}|(.{7}X){3}|XXX)
T`d`YX

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

इनपुट को पंक्तियों की अल्पविराम से अलग सूची के रूप में लेता है

Comments

आप एक मैच मंच का उपयोग करने और कम करके कुछ बाइट्स बचा सकते हैं (.{7}X){3}|XXXकरने के लिए (.{7}X|X)\4\4: tio.run/nexus/retina#fc4xCsMwDAXQPfcI2GC6NDS5QaeipcP/...

— मार्टिन Ender

@MartinEnder मैं यह नहीं देखता कि आप कैसे उपयोग कर सकते हैं \4- आप .{7}मिलान स्ट्रिंग का प्रभाव दोहराना चाहते हैं । (और समूह को संतुलित करना शायद बहुत लंबा होगा।)

— नील

@ ओह ओह, कोई बात नहीं, किसी तरह मैंने यह नहीं माना कि ग्रिड में मैच की तुलना में अन्य ओएक्सवाई कोशिकाएं हैं। मैच चरण का उपयोग करना तब भी 3 बाइट्स बचाता है।

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

Answer 3

जावास्क्रिप्ट (ईएस 6), 54 55

संपादित करें 1 बाइट बचाया धन्यवाद @Arnauld

मैं सिर्फ जाँच करता हूं कि क्या X विजेता है, क्योंकि हमेशा एक विजेता होगा, और केवल एक विजेता होगा

इनपुट किसी भी विभाजक के साथ एक स्ट्रिंग है, जैसे @ अरनुल्ड के उत्तर में

F=    
b=>'YX'[+[0,6,7,8].some(x=>b.match(`X(.{${x}}X){3}`))]

;['OOOOOOO OOOOOOO OOXOOOO OOXOOOO OOXOOOO OOXOYYY'
 ,'OOOOOOO OOOOOOO OOXOOOO OOYXOOO OOYOXOO OOYYOXY'
 ,'OOOOOOO,OOOOOOO,OOOOOOO,OOOOOOO,OOYYOOO,OYXXXXO'
 ,'OOOOOOO,OOOOOOO,OOOOOOO,XXXXOOO,YXYYOOO,YXYYXYX'
 ,'YXYYXOO,XYXXYOO,XXXYYOO,YYYXXOO,XXYYYYO,XXYYXXO']
.forEach(s => console.log(s,F(s)))

Comments

@ अरनल्ड राइट, धन्यवाद

— edc65

Answer 4

जेली , 25 22 बाइट्स

ŒgL⁼¥Ðf
;UŒD€;Z;$ç€4FṀ

एक (या अक्षरों की सूची की सूची) तार की सूची के गठन ले जाता है X, Yऔर O(भी प्रतिस्थापन के साथ काम करेगा अंतरिक्ष दोनों काउंटरों की तुलना में कम क्रमसूचक है ऐसा है कि)।

इसे ऑनलाइन आज़माएं! या एक संवर्धित संस्करण चलाएं जोएक बहुस्तरीय स्ट्रिंग लेता है।

कैसे?

ŒgL⁼¥Ðf - Link 1, runs of given length: list A, length B  e.g. "XYYYXXO", 4
Œg      - group runs of equal elements of A                     ["X","YYY","XX","O"]
     Ðf - filter keep:
    ¥   -     last two links as a dyad:
  L     -         length                                         1   3     2    1
   ⁼    -         equal to B?         (none kept in this case->) 0   0     0    0

;UŒD€;Z;$ç€4FṀ - Main link: list of list of chars (or list of stings) I
 U             - reverse each row of I
;              - I concatenated with that
  ŒD€          - positive diagonals of €ach (positive and negative diagonals)
        $      - last two links as a monad:
      Z        -     transpose of I (i.e. the columns)
       ;       -     concatenated with I (columns + rows)
     ;         - concatenate (all the required directional slices)
         ç€4   - call the last link (1) as a dyad for €ach with right argument = 4
            F  - flatten the result
             Ṁ - take the maximum ('Y'>'X'>'O') - this has the bonus effect of returning:
                               'Y' or 'X' for a winning board; and
                               'O' or '' for a (valid) game in progress.

Answer 5

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

नील को धन्यवाद देकर 7 बाइट्स बचाए

इनपुट को कुछ- ग्रहणित स्ट्रिंग के रूप में लेता है , जहां कुछ मूल रूप से कोई भी वर्ण होता है।

b=>[...'XXXXYYYY'].find((c,i)=>b.match(`(${c}.{${(i%4+6)%9}}){3}`+c))

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

let f =

b=>[...'XXXXYYYY'].find((c,i)=>b.match(`(${c}.{${(i%4+6)%9}}){3}`+c))

console.log(f("OOOOOOO,OOOOOOO,OOOOOOO,OOOOOOO,OOYYOOO,OYXXXXO"))
console.log(f("OOOOOOO,OOOOOOO,OOOOOOO,XXXXOOO,YXYYOOO,YXYYXYX"))
console.log(f("YXYYXOO,XYXXYOO,XXXYYOO,YYYXXOO,XXYYYYO,XXYYXXO"))

Comments

उपयोग क्यों नहीं b.match()? RegExpकॉल पर बचाना चाहिए ।

— नील

@ नील मैं पूरी तरह से भूल गया कि match()एक अंतर्निहित रूपांतरण कर रहा था RegExp। धन्यवाद!

— अरनुलद

Answer 6

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

m=input()
u=[r[::-1]for r in m]
print"YX"[any(any('X'*4in''.join(t[i][j-i]for i in range(j+1))for j in range(6))for t in(m[::-1],m,u,u[::-1]))]

तार की सूची या वर्णों की सूची की सूची लेता है। विनिर्देश की गारंटी के रूप में 7 कॉलम द्वारा 6 पंक्तियों के लिए हार्ड-कोडित ।

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

Answer 7

PHP, 71 बाइट्स

echo preg_match('#X(XXX|(.{8}X){3}|(.{7}X){3}|(.{9}X){3})#',$argn)?X:Y;

ऑनलाइन संस्करण

Answer 8

पायथन 2 , 201 143 129 128 107 बाइट्स

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

lambda m:"YX"[any("X"*4in"".join(a)for a in zip(*m)+m+zip(*["0"*(7-i)+m[i]+"00"*i+m[i]for i in range(6)]))]

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

क्रेडिट

• केवल ASCII द्वारा 129 से 107 बाइट्स तक ।

Comments

यह पूरी तरह से स्व-उत्तर के लिए स्वीकार्य है।

— जोनाथन एलन

बहुत ज्यादा इसे देख के बिना, वहाँ पर बेकार व्हाइटस्पेस हो रहा है: i:] for, i, r, r] forऔर 1 for।

— यति

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

— नील

भी *(len(m)-1)हो सकता है *~-len(m)। यह काम किस प्रकार करता है।

— यति

] forऔर 1 forअभी भी कर रहे हैं।

— यति

Answer 9

के (ngn / k) , ५ 58 ५५ बाइट्स

{"XY"@|/&/'88<x ./:/:,/{x+/:/:+3+[4#1-+!3 3]\&4}'+!6 7}

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

{ } तर्क के साथ कार्य करें x

+!6 7 0..5 और 0..6 के सभी संभावित जोड़े

{ }' उनमें से प्रत्येक के लिए करते हैं

4#1-+!3 3 8 ऑर्थो-विकर्ण दिशाओं में से 4 हैं: (1 1;1 0;1 -1;0 1)

3+[ ]\&4चार शून्य ( &4) की सूची के साथ शुरू करें और प्रत्येक दिशा में 3 चरण बनाएं

x+/:/: प्रत्येक संभावित स्थिति से शुरू करें और प्रत्येक संभव दिशा में कदम उठाएं

,/CONCATENATE। इस बिंदु पर हमारे पास तालमेल जोड़े की 4-सूचियों का एक मैट्रिक्स है, उनमें से कुछ बोर्ड से परे फैली हुई हैं

x ./:/: से इसी कोशिकाओं को देखो x

88<उनमें से कौन हैं "Y"-s? (88 का आस्की कोड "X")

&/'कौन सी 4-सूचियों में केवल "Y"-s शामिल हैं? (और कम करने-प्रत्येक)

|/कम से कम ऐसा है? (या-कम)

"XY"@अगर झूठी वापसी "X", अगर सच्ची वापसी"Y"

Answer 10

Zsh , 207 ... 159 बाइट्स

संस्करण इतिहास: पहले सप्ताह के लिए ~ 25 बाइट्स के लिए 4 पुनरावृत्तियों; फिर 6 महीने बाद ~ 25 बाइट्स के लिए 3 और पुनरावृत्तियों।

t(){a=($^a-$^@_);for s l (${w:^^argv})s+=$l&&for ((i=0;i++<$#s;))a[i]+=$s[i];}
w=(+)
t $@
for s;w[++j]=${(l:j:)}_
t $@
t ${(Oa)@}
[[ $a = *XXXX* ]]&&<<<X||<<<Y

( पहला ) ( दूसरा ) ( तीसरा ) ( चौथा ) ( पाँचवाँ ) ( छठा ) इसे ऑनलाइन आज़माएँ!

पाद लेख में, मैं इनपुट बोर्ड और उस सरणी को बनाता हूं, जिसे हम stderr पर प्रिंट करते हैं। उन्हें देखने के लिए डीबग करने के लिए नीचे स्क्रॉल करें। हमारे द्वारा बनाई गई सरणी अब बहुत लंबी है, क्योंकि tइनपुट बोर्ड के साथ कार्टेशियन उत्पाद है प्रत्येक कॉल । (अरे, यह कुछ बाइट्स द्वारा कोड छोटा कर दिया।)

यहाँ कवर करने के लिए बहुत कुछ है, इसलिए मैंने एक एनोटेट गिस्ट की टिप्पणियों (छठे संस्करण) को स्थानांतरित किया ।

(tl; dr: मूल सरणी का समसामयिक परिवर्तन, लेकिन उन्हें अलग रखना सुनिश्चित करें)