पृष्ठभूमि

^{"टास्क" पर जाएं यदि आप टिक-टैक-टो से परिचित हैं (मुझे लगता है कि अधिकांश हैं!)}

टिक-टैक-टो एक प्रसिद्ध दो-खिलाड़ी खेल है। इसमें एक 3x3 बोर्ड होता है जो दो खिलाड़ियों द्वारा धीरे-धीरे भरा जाता है (नीचे स्पष्टीकरण); पहला खिलाड़ी चरित्र का उपयोग करता है Xऔर दूसरा उपयोग करता है O। विजेता को लगातार 3 और समान अक्षर ( Xया O) मिलते हैं , जो क्षैतिज, लंबवत या तिरछे होते हैं। यदि बोर्ड भरा हुआ है और कोई भी खिलाड़ी लगातार तीन अक्षर प्राप्त करने में कामयाब नहीं है, तो खेल समाप्त हो जाता है। ध्यान दें कि खेल के अंत में खाली स्थान हो सकते हैं, यदि खिलाड़ियों में से कोई भी कुल 9 चालों से कम में जीतता है (यह टाई के मामले में नहीं हो सकता है)।

कार्य

एक खेल के अंत में टिक-टीएसी-टो बोर्ड को देखते हुए (एक स्ट्रिंग के रूप में, एक मैट्रिक्स, 9 ऑर्डर किए गए मूल्यों की एक फ्लैट सूची, किसी भी अन्य सभ्य प्रारूप), यह निर्धारित करें कि कौन गेम जीतता है।

• इनपुट में विशिष्ट और सुसंगत मूल्य शामिल होंगे, एक के लिए X, एक के लिए Oऔर दूसरा वह जो खाली स्थान का प्रतिनिधित्व करता है।

• आपका प्रोग्राम 3 अलग, सुसंगत और गैर-रिक्त मानों को आउटपुट करने में सक्षम होना चाहिए: एक मामले में Xजीतता है, एक अन्य मामले में Oजीतता है या एक और अगर खिलाड़ी बंधे हैं।

  कृपया अपने उत्तर में इन मूल्यों को निर्दिष्ट करें। आप मान सकते हैं कि इनपुट एक मान्य टिक-टैक-टो बोर्ड होगा।

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

X, O, _यहाँ इनपुट मानों कर रहे हैं; X wins, O winsऔर Tieआउटपुट के लिए हैं।

X O X
O X _
O _ X

आउटपुट: X wins।

X _ O
X O _
X O X

आउटपुट: X wins।

X O X
_ O X
_ O _

आउटपुट: O wins।

X O X
O O X
X X O

आउटपुट: Tie।

हमेशा की तरह, हमारे सभी मानक नियम लागू होते हैं। यह कोड-गोल्फ है , हर भाषा में बाइट्स में सबसे छोटा कोड जीतता है!

जेली ,  16 15  14 बाइट्स

U,Z;ŒD$€ẎḄỊÐḟḢ

मूल्यों के साथ सूचियों की एक सूची (पंक्तियों - या स्तंभों) को स्वीकार करने वाला एक विचित्र लिंक:

X = 0.155; O = -0.155; _ = 0

लौटने के परिणाम:

X wins = 1.085; O wins = -1.085; Tie = 0

नोट: के लिए शून्य के मान का उपयोग करना _, और बराबर और विपरीत मूल्यों के लिए Xऔर O, यह मान (यहां 0.155) सीमा में हो सकता है (1/6, 1/7)(दोनों सिरों पर अनन्य) - मैंने केवल उस श्रेणी में एक मान चुना है जो एक सटीक प्रतिनिधित्व योग्य फ्लोटिंग पॉइंट परिणाम देता है जीत के मामलों के लिए।

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

कैसे?

U,Z;ŒD$€ẎḄỊÐḟḢ - Link: list of lists (as described above)
U              - upend (reverse each row)
  Z            - transpose (get the columns)
 ,             - pair the two
      $€       - last two links as a monad for each of them:
    ŒD         -   diagonals (leading diagonals - notes: 1. only one is of length 3;
               -              2. the upend means we get the anti-diagonals too)
        Ẏ      - tighten (make a single list of all the rows, columns and diagonals)
         Ḅ     - from binary (vectorises) (note that [0.155, 0.155, 0.155]
               -                           converts to 4*0.155+2*0.155+1*0.155 = 1.085
               -                           and [-0.155, -0.155, -0.155]
               -                           converts to 4*-0.155+2*-0.155+1*-0.155 = -1.085
               -                           while shorter lists or those of length three
               -                           with any other mixtures of 0.155, -0.155 and 0
               -                           yield results between -1 and 1
               -                           e.g. [.155,.155,0] -> 0.93)
           Ðḟ  - filter discard if:
          Ị    -   insignificant (if abs(z) <= 1) (discards all non-winning results)
             Ḣ - head (yields the first value from the list or zero if it's empty)

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

a=>"012+345+678+036+147+258+048+246T".replace(/\d/g,n=>a[n]||!1).match(/(\d)\1\1|T/)[0]

इनपुट

• एक्स के रूप में प्रतिनिधित्व किया है 1
• हे के रूप में प्रतिनिधित्व किया है 2
• _ के रूप में प्रतिनिधित्व किया है 0

उत्पादन

• एक्स जीत के रूप में प्रतिनिधित्व किया है "111"
• ओ जीत के रूप में प्रतिनिधित्व किया है "000"
• टाई के रूप में प्रतिनिधित्व किया है "T"

व्याख्या

a=>
    "012+345+678+036+147+258+048+246" // List of indexes for each row
    .replace(/\d/g,n=>a[n]||!1)       // Replace all digits with the value of the cell
    .match(/(\d)\1\1|$/)[0]           // Find the first row filled with the same value

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

f=
a=>"012+345+678+036+147+258+048+246T".replace(/\d/g,n=>a[n]||!1).match(/(\d)\1\1|T/)[0]
console.log(f([1,2,1,2,1,0,2,0,1]))
console.log(f([1,0,2,1,2,0,1,2,1]))
console.log(f([1,2,1,0,2,1,0,2,0]))
console.log(f([1,2,1,2,2,1,1,1,2]))

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

UŒD;;Z;ŒDµSA⁼3µÐfḢ

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

X= 1, O= -1, _= 0
X जीतता है = [1, 1, 1], O जीतता है = [-1, -1, -1], टाई = 0
इनपुट (1, -1, 0)प्रत्येक में 3 तत्वों की 3 सूचियों की सूची के रूप में ।

पायथन 3 , 73 बाइट्स

lambda b:{'XXX','OOO'}&{*b.split(),b[::4],b[1::4],b[2::4],b[::5],b[2::3]}

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

पायथन 2 , 100 95 92 87 82 77 बाइट्स

lambda b:{'XXX','OOO'}&set(b.split()+[b[::4],b[1::4],b[2::4],b[::5],b[2::3]])

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

इनपुट को एक नई लाइन के रूप में अलग स्ट्रिंग में ले जाता है XO_

आउटपुट:

• {'XXX'}के लिए X,
• {'OOO'} के लिये O
• {} एक टाई के लिए

स्ट्रिंग को पंक्तियों के स्तंभों और विकर्णों में काटकर कार्य करता है:

The board:
    1 2 3
    4 5 6
    7 8 9
which is '123\n456\n789' is sliced into:

['123', '456', '789', '147', '258', '369', '159', '357']
rows: b.split() -> ['123', '456', '789']
cols: [b[::4],b[1::4],b[2::4]] -> ['147', '258', '369']
diag: [b[::5],b[2::3]] -> ['159', '357']

तब 'XXX'और 'OOO'स्लाइस के खिलाफ जाँच की जाती है।

इनपुट को एक नई लाइन के रूप में अलग स्ट्रिंग में ले जाता है XO_

आउटपुट:

• {'XXX'}के लिए X,
• {'OOO'} के लिये O
• {} एक टाई के लिए

स्ट्रिंग को पंक्तियों के स्तंभों और विकर्णों में काटकर कार्य करता है:

The board:
    1 2 3
    4 5 6
    7 8 9
which is '123\n456\n789' is sliced into:

['123', '456', '789', '147', '258', '369', '159', '357']
rows: b.split() -> ['123', '456', '789']
cols: [b[::4],b[1::4],b[2::4]] -> ['147', '258', '369']
diag: [b[::5],b[2::3]] -> ['159', '357']

तब 'XXX'और 'OOO'स्लाइस के खिलाफ जाँच की जाती है।

आर, 118 116 115 बाइट्स

@ User2390246 को दो अतिरिक्त बाइट्स के लिए धन्यवाद ।

function(M,b=table,u=unlist(c(apply(M,1,b),apply(M,2,b),b(diag(M)),b(M[2*1:3+1]))))`if`(any(u>2),names(u[u>2]),"T")

थोड़ा अपराजित:

function(M){
    u=unlist(c(apply(M,1,table), #Contingency table of the rows
             apply(M,2,table), #of the columns
             table(diag(M)), #of the diagonal
             table(M[2*1:3+1]))) #of the opposite diagonal
    `if`(any(u>2),names(u[u>2]),"T") #Give name of element that occurs more than twice in any setting
 }

रिटर्न Xअगर एक्स जीत, Oहे जीत अगर और Tएक टाई के मामले में।

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

पर्ल 5 , 58 बाइट्स

56 बाइट्स कोड + 2 एफपीआर -p0।

$_=eval sprintf'/(.)(.{%s}\1){2}/s||'x4 .'0?$1:T',0,2..4

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

आउटपुट Xऔर Oजीत के लिए, या Tएक टाई के लिए। एक ही बार में सभी का परीक्षण करने के लिए हैडर / पाद कोड का एक गुच्छा शामिल है।

वैकल्पिक, 58 बाइट्स

$}.="/(.)(.{$_}\\1){2}/s||"for 0,2..4;$_=eval$}.'0?$1:T'

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

पायथन 2 , 124 118 117 115 बाइट्स

• छः बाइट्स को बचाना धन्यवाद एग्री द आउटगॉल्फ ; अल्पविराम से बचने के लिए एक स्ट्रिंग का उपयोग करना।
• श्री एक्सकोडर को एक बाइट धन्यवाद दिया ; गोल्फ [j*3:j*3+3]के लिए [j*3:][:3]।
• स्ट्रिंग को संपीड़ित करने के लिए एक जादुई संख्या का उपयोग करके दो बाइट्स सहेजे गए।

def T(B):
 for j in range(8):
	a,b,c=map(int,`0x197bf3c88b2586f4bef6`[j*3:][:3])
	if B[a]==B[b]==B[c]>0:return B[a]

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

इनपुट / आउटपुट मान

• X के रूप में प्रतिनिधित्व किया है 1
• O के रूप में प्रतिनिधित्व किया है 2
• _ के रूप में प्रतिनिधित्व किया है None

पायथन 3 , 173 बाइट्स

lambda x:h(x,1)*2or+h(x,0)
h=lambda x,y:g(x,y)or g(zip(*x),y)or x[0][0]==x[1][1]==x[2][2]==y or x[0][2]==x[1][1]==x[2][0]==y
g=lambda x,y:any(all(e==y for e in r)for r in x)

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

• के मैट्रिक्स के रूप में इनपुट 1 == X, 0 == O, -1 == _

• एकल मान के रूप में आउटपुट: 2 == X, 1 == O, 0 == TIE

-8 बाइट्स एग्री टू द आउटग्राफर

PHP, 70 बाइट्स

for($c=95024101938;${${$i++&7}.=$argn[$c%9]}=1<$c/=3;);echo$XXX-$OOO;

मान लेता है -n(दुभाषिया चूक)। इसके अतिरिक्त -R( <code>इनपुट की प्रत्येक पंक्ति के लिए निष्पादित) की आवश्यकता होती है , जिसे एक के रूप में गिना जाता है।

इनपुट को एक ही लाइन पर लिया जाता है (बिल्कुल समस्या वर्णन में, सभी व्हाट्सएप को छोड़कर)।

आउटपुट निम्नलिखित है: 1→ X जीत, -1→ O जीत, 0→ टाई।

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

रेटिना , 49 बाइट्स

;
;;
.*(\w)(.)*\1(?<-2>.)*(?(2)(?!))\1.*
$1
..+
T

इसे ऑनलाइन आज़माएं! इनपुट को 9 Xएस के 11-वर्ण स्ट्रिंग के रूप में लेता है , Oएस या -एस तीन के तीन समूहों में ;एस द्वारा अलग किया जाता है , हालांकि लिंक में एक हेडर शामिल है जो इस प्रारूप में दिए गए परीक्षण मामलों का अनुवाद करता है। एक संतुलित समूह का उपयोग करके एक विजयी रेखा से मेल खाते हुए काम करता है ताकि यह सुनिश्चित हो सके कि तीन मिलान वाले अक्षर समान हैं। (उपयुक्त दूरी 0 (क्षैतिज रेखा), 4 (रिवर्स विकर्ण), 5 (लंबवत रेखा), या 6 (विकर्ण) हैं; अन्य दूरियाँ ;स्ट्रिंग के बाहर एक हिट या विस्तार करेंगी ।)

जावा 8, 112 108 106 104 90 102 93 बाइट्स

b->b.replaceAll(".*(X|O)(\\1|...\\1...|.{4}\\1.{4}|..\\1..)\\1.*","$1").replaceAll("..+","T")

+12 बाइट्स (90 → 102) दोनों के बजाय केवल एक विकर्ण की जाँच के बग-फिक्स के कारण ..
-9 बाइट्स (102 → 93) के replaceAllबजाय का उपयोग करके matches।

प्रारूप XOX OX_ O_X, आउटपुट X, Oया में इनपुट T।

स्पष्टीकरण:

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

b->{                   // Method with String as both parameter and return-type
  b.replaceAll(".*(X|O)(\\1|...\\1...|.{4}\\1.{4}|..\\1..)\\1.*",
                       //  If we found a line of X or O:
     "$1")             //   Replace it with either X or O
   .replaceAll("..+",  //  If there are now more than 2 characters left:
     "T")              //   Replace it with T
                       // End of method (implicit / single-line return-statement)

स्पष्टीकरण रेगेक्स:

.*(X|O)(\1|...\1...|.{4}\1.{4}|..\1..)\1.*
.*                                      .*# 0 or more trailing & leading chars
  (X|O)                               \1  # X or O next to those leading/trailing chars
       (\1                                # A single X or O in between (row found)
          |...\1...                       # 3 chars, X or O, 3 chars (column found)
                   |.{4}\1.{4}            # 4 chars, X or O, 4 chars (diagonal TL→BR found)
                              |..\1..)    # 2 chars, X or O, 2 chars (diagonal TR→BL found)

रेटिना , 127 बाइट्स

.*(X|O)\1\1.*
$1
(X|O).. \1.. \1..
$1
.(X|O). .\1. .\1.
$1
..(X|O) ..\1 ..\1
$1
(X|O).. .\1. ..\1
$1
..(X|O) .\1. \1..
$1
..+
_

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

... मुझे लगता है कि आप इस क्रूर बल को बुला सकते हैं ... सोचा कि इसके लिए कुछ योग्यता हो सकती है ...

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

.*(X|O)(\1|...\1...|.{4}\1.{4}|..\1..)\1.*
$1
..+
T

मेरे जावा 8 उत्तर का पोर्ट । प्रारूप XOX OX_ O_X, आउटपुट X, Oया में इनपुट T।

स्पष्टीकरण:

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

.*(X|O)(\1|...\1...|.{4}\1.{4}|..\1..)\1.*
.*                                      .*# 0 or more trailing & leading chars
  (X|O)                               \1  # X or O next to those leading/trailing chars
       (\1                                # A single X or O in between (row found)
          |...\1...                       # 3 chars, X or O, 3 chars (column found)
                   |.{4}\1.{4}            # 4 chars, X or O, 4 chars (diagonal TL→BR found)
                              |..\1..)    # 2 chars, X or O, 2 chars (diagonal TR→BL found)

$1                                        #  Replace match of above with either X or O

..+                                       # If there are now 2 or more characters left:
T                                         #  Replace everything with T

जे, 34 बाइट्स

[:>./[:+./"1(2 1 0},:0 1 2}),(,|:)

Ungolfed:

[: >./ [: +./"1 (2 1 0} ,: 0 1 2}) , (, |:)

व्याख्या

एन्कोडिंग:

X = 2
O = 3
_ = 1

हमारी उच्च-स्तरीय रणनीति पहले एक मैट्रिक्स बनाना है जिसकी पंक्तियों में से प्रत्येक एक संभावित जीत है। पंक्ति एक विकर्ण / है, पंक्ति 2 विकर्ण \ है, अगली तीन पंक्तियाँ पंक्तियाँ हैं, और अंतिम तीन पंक्तियाँ स्तंभ हैं। इस भाग को वाक्यांश (आइटम संशोधन का उपयोग करके }) पूरा किया जाता है :

(2 1 0},:0 1 2}),(,|:)

अंत में हम प्रत्येक पंक्ति का GCD लेते हैं:

+./"1

हमारे एन्कोडिंग के लिए धन्यवाद, रिक्त के साथ किसी भी पंक्ति में 1 का जीसीडी होगा, क्योंकि किसी भी पंक्ति में एक्स और ओएस का कोई भी मिश्रण होता है, क्योंकि 2 और 3 कोप्रेम हैं। तो हम सभी को अगले करने की जरूरत है अधिकतम तत्व मिल रहा है:>./

यदि खेल एक टाई है, तो यह होगा 1. यदि कोई खिलाड़ी जीतता है, तो यह उस खिलाड़ी की संख्या होगी।

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

जावास्क्रिप्ट, 66 बाइट्स

([a,b,c,d,e,f,g,h,i])=>e&(a&i|c&g|b&h|d&f)|a&(b&c|d&g)|i&(c&f|g&h)

इसे सरल रखना।

• इनपुट: एक स्ट्रिंग, या संख्याओं या तारों 0का एक रिक्त स्थान, 1एक एक्स, और 2एक ओ के अनुरूप ।
• आउटपुट: 0एक टाई के लिए, 1एक्स जीत के लिए, 2ओ जीत के लिए।

विस्तृत, हल्की टिप्पणी:

( [a,b,c,d,e,f,g,h,i] ) => // Break apart the input into nine variables w/ destructuring
  // Run through all possible win conditions. 1&1&1 -> 1, 2&2&2 -> 2
  e & (             // All victories involving the middle square
    a & i | c & g | // Diagonal lines
    b & h | d & f   // Vertical/horizontal through the middle
  ) | 
  a & ( b & c | d & g ) | // Victories with the top-left square
  i & ( c & f | g & h )   // Victories with the bottom-right square