19

चलो कुछ कोड गोल्फ खेलते हैं!

एक टिक टीएसी को पैर की अंगुली राज्य की स्थिति (उदाहरण :)

|x|x|o|
|x|o|x|
|o|o|x|

निर्धारित करें कि क्या खेल winएक loseया एक है cat। आपका कोड किसी भी राज्य को दिए गए इन विकल्पों में से कोई भी आउटपुट देना चाहिए। उपरोक्त गेम का आउटपुट होना चाहिएlose

बस स्पष्ट होने के लिए: एक जीत को किसी भी 3 xs के रूप में परिभाषित किया जाता है (विकर्ण, क्षैतिज, ऊर्ध्वाधर)। हार oएक पंक्ति में 3 s है, जबकि एक पंक्ति catमें कोई भी खेल नहीं है।

चीजों को दिलचस्प बनाने के लिए, आपको राज्य के लिए अपनी इनपुट संरचना निर्धारित करनी होगी- जिसे आपको तब समझाना होगा। उदाहरण के लिए xxoxoxooxएक वैध स्थिति है जैसा कि ऊपर देखा गया है, जहां प्रत्येक पात्र को बाएं से दाएं, ऊपर से नीचे तक पढ़ा जाता है। [['x','x','o'],['x','o','x'],['o','o','x']]बहुआयामी सरणी में खेल एक समान तरीके से पढ़ा जाता है। जबकि 0x1a9जो हेक्स के लिए 110101001एक उपयुक्त संपीड़न के रूप में काम 1कर सकता है, जहां xएस के लिए हेरफेर किया 0जा सकता है और इसके लिए हेरफेर किया जा सकता है o।

लेकिन वे सिर्फ कुछ विचार हैं, मुझे यकीन है कि आप अपने खुद के कई हो सकते हैं।

मैदान के नियम:

आपका कार्यक्रम किसी भी व्यवहार्य स्थिति को स्वीकार करने में सक्षम होना चाहिए।
इनपुट का रूप किसी भी राज्य का प्रतिनिधित्व करने में सक्षम होना चाहिए।
"जीत राज्य बोर्ड से निर्धारित किया जाना चाहिए"
एक पूर्ण बोर्ड मान लें
Winइससे पहले कि loseमामला 'xxxoooxxx' में उदाहरण के लिए

सबसे कम वर्ण गणना जीत जाती है

code-golf game

— डायलन मेडिसेट्टी
स्रोत

1

मुझे यह इनपुट संरचना पसंद है: (win|lose|cat) [xo]{9}जहां पहला शब्द बताता है कि क्या खिलाड़ी x के लिए गेम जीत, हार या बिल्ली (?) है। किसी भी राज्य का प्रतिनिधित्व करने में सक्षम।

— रनर १११

2

क्या मैं एक नियम सुझा सकता हूं जैसे "जीत राज्य बोर्ड से निर्धारित किया जाना चाहिए" या "इनपुट में बोर्ड राज्य को छोड़कर कोई जानकारी नहीं होनी चाहिए"?

— अंडरग्राउंडोरेल

3

क्या हम केवल कानूनी खेल खेले हैं? यदि ऐसा है, तो कुछ राज्य असंभव होंगे, यानी XXX OOO XXX लेकिन अन्यथा कुछ पूर्ण-बोर्ड राज्यों में इसे चौथे असंभव परिणाम के रूप में शामिल किया जाता है, जहां एक्स जीतता है, लेकिन ओ भी जीतता है।

— दंगा

10

ब्याज से बाहर "बिल्ली" क्यों?

— क्रिस

7

@DylanMadisetti: पहले इसे कभी नहीं सुना और "जीत हार बिल्ली" के लिए गुग्लिन कुछ भी नहीं आया। मैं व्यक्तिगत रूप से टाई या ड्रा के साथ गया था। या इस खेल के मामले में शायद "अनिवार्यता"। ;-) मैं उतना दिमाग नहीं लगाता, जितना प्रतियोगिता में जाता है। एक स्ट्रिंग एक स्ट्रिंग है। ;-)

— क्रिस

11

रूबी 2.0, 85 अक्षर

यहाँ रूबी में एक सरल बिटमास्क-आधारित समाधान है:

d=gets.hex
$><<[292,146,73,448,56,7,273,84].map{|m|d&m<1?:lose:d&m<m ?:cat: :win}.max

बोर्ड को एक हेक्स संख्या के रूप में दर्शाया गया है, जो नौ वर्गों के अनुरूप नौ बिट्स से बना है। 1 एक है X, 0 एक है O। यह 0x1a9सवाल में उदाहरण की तरह है , हालांकि 0xवैकल्पिक है!

वहाँ शायद एक बेहतर तरीका है bitmasks तो बस एक बड़ी सूची हार्डकोडिंग। मैं खुशी से सुझाव लूंगा।

इसे इदेओन पर यहां देखें ।

— पॉल प्रेस्टिज
स्रोत

1

आपकी सूची में 273दो बार शामिल हैं । और मुझे वास्तव में यह maxविचार पसंद है!

— वेंतोरो

1

ओह @Ventero, हमेशा अस्पष्ट अनुकूलन (धन्यवाद) के साथ

— पॉल प्रेस्टिज

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

— स्टीफन ओस्टरमिलर

2

@StephenOstermiller नियम 4: एक पूर्ण बोर्ड मान लें। आप सही हैं कि यह नियम शायद नियम 1 और 2 द्वारा विरोधाभास है, हालांकि यदि आप इस प्रश्न पर सभी टिप्पणियों को पढ़ते हैं, तो मुझे लगता है कि यह प्रश्न की भावना के भीतर है (अपूर्ण बोर्ड कवर नहीं किए गए हैं, जबकि पूर्ण लेकिन अवैध बोर्ड हैं।) हालाँकि मुझे लगता है कि ओक्साल हेक्स की तुलना में अधिक उपयोगकर्ता के अनुकूल इनपुट प्रारूप होगा।

— लेवल रिवर सेंट

1

समझ गया, मुझे लगा कि पूरा का मतलब कुछ अलग है।

— स्टीफन ओस्टरमिलर

10

गणितज्ञ, 84 वर्ण

a=Input[];Which[Max@#>2,win,Min@#<1,lose,1>0,cat]&@{Tr@a,Tr@Reverse@a,Tr/@a,Total@a}

इनपुट प्रारूप: {{1, 1, 0}, {1, 0, 1}, {0, 0, 1}}

— alephalpha
स्रोत

यहाँ क्या हो रहा है?

— देखिए

3

@ सही से शुरू करो। Tr@aक्षेत्र (विकर्ण से अधिक राशि) का पता लगाने है, Tr@Reverse@aफ़्लिप क्षेत्र का पता लगाने है (कुछ विरोधी विकर्ण से अधिक), Tr/@aहै Trप्रत्येक पंक्ति, जो आप, प्रत्येक पंक्ति से अधिक राशि देता है के लिए लागू Total@aआप प्रत्येक स्तंभ के ऊपर राशि देता है। तो मूल रूप से, आपको सभी 8 लाइनें मिलनी चाहिए जिनकी आपको जांच करनी है। फिर उस Whichचीज़ पर लागू किया जाता है (मूल रूप से एक if/elseif/elseबयान), जहां #8 मूल्यों की उस सूची का प्रतिनिधित्व करता है। ifवहाँ एक 3आप जीतते हैं, else ifवहाँ एक है 0आप खो देते हैं, else if 1>0(सही) cat।

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

6

बैश: 283 262 258

अपेक्षाकृत अनुकूल इंटरफेस की विशेषता है।

t(){ sed 's/X/true/g;s/O/false/g'<<<$@;}
y(){ t $(sed 's/X/Q/g;s/O/X/g;s/Q/O/g'<<<$@);}
f(){($1&&$2&&$3)||($1&&$5&&$9)||($1&&$4&&$7)||($2&&$5&&$8)||($3&&$5&&$7)||($3&&$6&&$9)||($4&&$5&&$6)||($7&&$8&&$9)}
f $(t $@)&&echo win||(f $(y $@)&&echo lose)||echo cat

निष्पादन हेतु bash tictactoe.sh O X O X O X X O X

नोट: 9 पदों की सूची एक मानक मैट्रिक्स प्रतिनिधित्व है। इससे कोई फर्क नहीं पड़ता कि बोर्ड को कॉलम मेजर या रो मेजर के रूप में दर्शाया गया है, बाएं से दाएं या ऊपर से नीचे तक पढ़ा जाए - नॉट्स और क्रॉस (या अगर आप जोर देते हैं तो टिक टीएसी का खेल) सममित हैं, इसलिए इनपुट ऑर्डर अप्रासंगिक होना चाहिए हर सही क्रियान्वयन में परिणाम, जब तक इनपुट रैखिक है।

संपादित करें: छोटे फ़ंक्शन सिंटैक्स सुझाव के लिए hjk का धन्यवाद।

— दंगा
स्रोत

के t() { ... }बजाय पर विचार करें function t? वहां कुछ पात्रों को बचा सकता है। :)

— hjk

मैं पूरी तरह से वैकल्पिक फ़ंक्शन सिंटैक्स के बारे में भूल गया था - धन्यवाद!

— दंगा

<<<अन्य चार वर्णों को सहेजने के लिए रिक्त स्थान की आवश्यकता नहीं है ।

— माइकल माइर

4

बेफुज 93 - 375

इनपुट के रूप में एक बाइनरी स्ट्रिंग लेता है।

99>~\1-:!!|>v  
>0v>v>v   >^$>v
^+ + +    0<:p:
>#+#+#+    ^246
^+ + +    0<265
>#+#+#+    ^pp6
^+ + +    0<2++
 #+#+#+     55p
   0 0      552
  >^>^>0v   +46
v+ + +  <   ppp
>0 + + + v  444
   v!!-3:<< 246
  v_"ni"v   ppp
  0v" w"<   :+:
  \>,,,,@   266
  ->,,,@    555
  !^"cat"_^ 645
  !>:9-! ^  +:+
  >|        p:p
   >"eso"v  6p6
 @,,,,"l"<  246
            p2p
            >^ 
  v       <^  <

स्ट्रिंग पढ़ता है। ब्रूटफोर्स इसे (दायीं ओर सबसे खड़ी पट्टी) लिखते हैं और बीच में एक मैट्रिक्स के रूप में

^+ + + 
>#+#+#+
^+ + + 
>#+#+#+
^+ + + 
 #+#+#+

जाली (आईडीके) जोड़ना। स्तंभों, पंक्तियों और दो निदानों का योग निर्धारित करता है। उन मानों को 3 ("जीत") या 0 ("खोना") की तुलना करें, अन्यथा यदि सभी मान 1 या 2 के बराबर हैं तो ड्रा ("कैट") करें।

— AndoDaan
स्रोत

4

GolfScript, 27 वर्ण

70&.{~"win""lose"if}"cat"if

इनपुट प्रारूप एक स्ट्रिंग है जिसमें आठ अष्टक अंक होते हैं, प्रत्येक (अतिरेक से) तीन लगातार बोर्ड वर्गों को एन्कोड करते हैं:

पहले तीन अंक प्रत्येक बोर्ड की एक पंक्ति को ऊपर से नीचे और बाएं से दाएं तक एनकोड करते हैं।
निम्नलिखित तीन अंक प्रत्येक बोर्ड के एक कॉलम को बाएं से दाएं और ऊपर से नीचे की ओर घेरते हैं।
अंतिम दो अंक प्रत्येक विकर्णों में से एक को कूटबद्ध करते हैं (पहले ऊपर से नीचे दाएं से बाएं, फिर नीचे से बाएं से ऊपर दाईं ओर)।

तीन वर्गों के एक अनुक्रम (पंक्ति / स्तंभ / विकर्ण) को एक अष्टाधारी अंक के रूप में एनकोड करने के लिए, प्रत्येक xको अनुक्रम में 1 और हर o0 के साथ बदलें , और परिणामी अनुक्रम की व्याख्या करें और शून्य और 0 और 7 के बीच एक द्विआधारी संख्या के रूप में शून्य करें। समावेशी।

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

इनपुट, वैकल्पिक रूप से, अंकों के बीच रिक्त स्थान या अन्य सीमांकक शामिल कर सकते हैं। वास्तव में, सभी कार्यक्रम वास्तव में परवाह करते हैं कि इनपुट स्ट्रिंग में अंक हैं 7या नहीं 0।

उदाहरण के लिए, उदाहरण बोर्ड:

|x|x|o|
|x|o|x|
|o|o|x|

इनपुट द्वारा दर्शाया जा सकता है:

651 643 50

सुविधा के लिए, यहाँ एक ASCII आर्ट बोर्ड लेआउट बदलने के लिए एक गोल्फस्क्रिप्ट प्रोग्राम है, जैसा कि ऊपर दी गई चुनौती में दिखाया गया है, इस प्रोग्राम के लिए उपयुक्त इनपुट स्ट्रिंग में:

."XOxo"--[{1&!}/]:a[3/.zip"048642"{15&a=}%3/]{{2base""+}%}%" "*

इस कनवर्टर किसी भी के अलावा अन्य पात्रों पर ध्यान नहीं देता xऔर oअपने इनपुट में, या तो मामले में। यह एकल अंक स्ट्रिंग (ऊपर दिखाए गए स्थान के साथ पूरा के रूप में ऊपर दिखाया गया है) जीत-निर्धारण कार्यक्रम में खिलाने के लिए उपयुक्त पैदा करता है, इसलिए इन दोनों कार्यक्रमों के संयोजन का उपयोग ASCII कला बोर्ड से सीधे विजेता को निर्धारित करने के लिए किया जा सकता है।

इसके अलावा, यहां एक रिवर्स कनवर्टर है, बस यह प्रदर्शित करने के लिए कि इनपुट वास्तव में स्पष्ट रूप से बोर्ड का प्रतिनिधित्व करता है:

.56,48>-- 3<{2base-3>{"ox"=}%n}%"|".@@*+);

Ps। इस समाधान का ऑनलाइन डेमो यहां दिया गया है।

— इल्मरी करोनें
स्रोत

2

इनपुट प्रारूप ऐसा लगता है जैसे इनपुट के उत्पादन में बहुत अधिक धोखा होता है।

— आर्कु

@ अर्कु: ठीक है, हाँ, यह है, लेकिन यह प्रश्न स्पष्ट रूप से कहता है कि "आपको राज्य के लिए अपनी इनपुट संरचना निर्धारित करनी होगी - जिसे आपको तब समझाना होगा।" यह भी एक वैध इनपुट प्रारूप के एक उदाहरण के रूप में एक बिट-पैक हेक्स स्ट्रिंग दिखाता है; मेरे और मेरे इनपुट प्रारूप के बीच एकमात्र अंतर यह है कि मैं कुछ बिट्स को फिर से बनाता और डुप्लिकेट करता हूं।

— इल्मरी करोनें

6

यह बिल्कुल दोहराव है जो एक धोखा की तरह लगता है। (उदाहरण के लिए, यह इनपुट में 7 या 0 की उपस्थिति के रूप में विजेता को सीधे सांकेतिक शब्दों में बदलना करता है )

— अर्कु

फिर भी यह एक चतुर एन्कोडिंग है, यह बेमानी है, लेकिन यह समाधान को किसी भी गैर-बेमानी एन्कोडिंग की तुलना में अधिक कुशल बनाता है!

— एआरआरजी

3

पायथन 2 - 214 बाइट्स

b=eval(raw_input())
s=map(sum,b)
w,l='win','lose'
e="if min(s)<1:print l;a\nif max(s)>2:print w;a"
exec e+'\ns=map(sum,zip(*b))\n'+e
m=b[1][1]
for i in 0,2:
 if m==b[0][i]==b[2][abs(i-2)]:print[l,w][m];a
print'cat'

मुझे यकीन है कि सुधार किए जाने हैं।

चलाने के लिए:

python2 tictactoe.py <<< '[[1,1,1],[1,0,1],[0,1,0]]'

जो इस बोर्ड का प्रतिनिधित्व करता है:

X|X|X
-----
X|O|X
-----
0|X|0

NameErrorसिवाय हर मामले में एक अपवाद के साथ बाहर निकलता है cat।

— undergroundmonorail
स्रोत

वाह, मैं कभी नहीं जानता था <<<! इसके लिए सिर्फ +1।

— ग्रेग हेविगिल

@GregHewgill यह बहुत सुविधाजनक है। ./whatever <<< 'blah blah blah'के रूप में एक ही है, echo -n 'blah blah blah' | ./whateverलेकिन के लिए एक पूरी अलग प्रक्रिया के बिना है echo।

— भूमिगत

@undergroundmonorail echoमें bashवास्तव में अंतर्निहित है, इसलिए एक नई प्रक्रिया बांट नहीं करता है

— बॉब

@GregHewgill इसे एक हेस्टिंग्रिंग कहा जाता है

3

हास्केल, 146 वर्ण

चीजों को दिलचस्प बनाने के लिए, आपको राज्य के लिए अपनी इनपुट संरचना निर्धारित करनी होगी- जिसे आपको तब समझाना होगा।

ठीक :)। एक बोर्ड का मेरा प्रतिनिधित्व उन 126 पात्रों में से एक है

ĻŃŇŉŊœŗřŚşšŢťŦŨųŷŹźsƁƂƅƆƈƏƑƒƕƖƘƝƞƠƤƳƷƹƺƿǁǂǅǆǈǏǑǒǕǖǘǝǞǠǤǯǱǲǵǶǸǽǾȀȄȍȎȐȔȜȳȷȹȺȿɁɂɅɆɈɏɑɒɕɖɘɝɞɠɤɯɱɲɵɶɸɽɾʀʄʍʎʐʔʜʯʱʲʵʶʸ''ˀˎː˔~˭ˮ˰˴˼̌

यहाँ 146 वर्णों में समाधान है:

main=interact$(\x->case(head x)of h|elem h "ĻŃœťŦŨųŷŹƁƂƅƈƕƠƤƳƿǂǆǞǤǵǾȀȳȿɁɅɑɒɘɝɠɤɵɽʀʐʽʾː˭ˮ˰˴˼̌"->"lose";h|elem h "ƏƝƞƹǁǈǑǝȍȺɆɈɶɾʎʸ"->"cat";h->"win")

और यहाँ एक हैस्केल स्क्रिप्ट के रूप में यह कैसे काम करता है:

import Data.List (subsequences, (\\))
import Data.Char (chr)

-- A set of indexes [0-8] describing where on the board pieces of a single color have been played
-- For example the board "OxO;Oxx;xxO" is indexes [0,2,3,8]
type Play = [Int]

-- There are 126 filled tic tac toe boards when X plays first.
--      (This is a combination of 4 OHs among 9 places : binomial(9 4) = 126)
-- perms returns a list of all such possible boards (represented by the index of their OHs).
perms = filter (\x -> 4 == length x) $ subsequences [0..8]

-- We now create an encoding for plays that brings them down to a single char.
-- The index list can be seen as an 9 bit binary word [0,2,3,8] -> '100001101'
-- This, in turn is the integer 269. The possible boards give integers between 15 and 480.
-- Let's call those PlayInts
type PlayInt = Int

permToInt [] = 0
permToInt (x:xs) = (2 ^ x) + permToInt xs 

-- Since the characters in the range 15-480 are not all printable. We offset the chars by 300, this gives the range 
-- ĻŃŇŉŊœŗřŚşšŢťŦŨųŷŹźſƁƂƅƆƈƏƑƒƕƖƘƝƞƠƤƳƷƹƺƿǁǂǅǆǈǏǑǒǕǖǘǝǞǠǤǯǱǲǵǶǸǽǾȀȄȍȎȐȔȜȳȷȹȺȿɁɂɅɆɈɏɑɒɕɖɘɝɞɠɤɯɱɲɵɶɸɽɾʀʄʍʎʐʔʜʯʱʲʵʶʸʽʾˀ˄ˍˎː˔˜˭ˮ˰˴˼̌
-- Of all distinct, printable characters
uOffset = 300

-- Transform a PlayInt to its Char representation
pIntToUnicode i = chr $ i + uOffset

-- Helper function to convert a board in a more user friendly representation to its Char
-- This accepts a representation in the form "xooxxxoxo"
convertBoard s = let play = map snd $ filter (\(c, i) -> c == 'o') $ (zip s [0..]) :: Play 
    in pIntToUnicode $ permToInt play

--
-- Now let's cook some data for our final result
--  

-- All boards as chars
allUnicode = let allInts = map permToInt perms 
    in map pIntToUnicode allInts

-- Now let's determine which boards give which outcome.

-- These are all lines, columns, and diags that give a win when filled
wins = [
        [0,1,2],[3,4,5],[6,7,8], -- lines
        [0,3,6],[1,4,7],[2,5,8], -- columns
        [0,4,8],[2,4,6] -- diagonals
    ]

isWin :: Play -> Bool   
isWin ps = let triplets = filter (\x -> 3 == length x) $ subsequences ps -- extract all triplets in the 4 or 5 moves played
    in any (\t -> t `elem` wins) triplets -- And check if any is a win line

-- These are OH wins
oWins = filter isWin perms
-- EX wins when the complement board wins
xWins = filter (isWin . complement) perms
    where complement ps = [0..9] \\ ps
-- And it's stalemate otherwise
cWins = (perms \\ oWins) \\ xWins

-- Write the cooked data to files
cookData = let toString = map (pIntToUnicode . permToInt) in do
  writeFile "all.txt" allUnicode
  writeFile "cWins.txt" $ toString cWins
  writeFile "oWins.txt" $ toString oWins
  writeFile "xWins.txt" $ toString xWins

-- Now we know that there are 48 OH-wins, 16 stalemates, and 62 EX wins (they have more because they play 5 times instead of 4).
-- Finding the solution is just checking to which set an input board belongs to (ungolfed :)
main = interact $ \x -> case (head x) of -- Only consider the first input char
    h | elem h "ĻŃœťŦŨųŷŹƁƂƅƈƕƠƤƳƿǂǆǞǤǵǾȀȳȿɁɅɑɒɘɝɠɤɵɽʀʐʽʾː˭ˮ˰˴˼̌" -> "lose" -- This string is == oWins
    h | elem h "ƏƝƞƹǁǈǑǝȍȺɆɈɶɾʎʸ" -> "cat" -- And this one == cWins
    h -> "win"

— ARRG
स्रोत

3

जावास्क्रिप्ट, 420 वर्ण

if((s&0x3F000)==0x3F000||(s&0x00FC0)==0x00FC0||(s&0x0003F)==0x0003F||(s&0x030C3)==0x030C3||(s&0x0C30C)==0x0C30C||(s&0x30C30)==0x30C30||(s&0x03330)==0x03330||(s&0x30303)==0x30303)return 'win'
if((s&0x3F000)==0x2A000||(s&0x00FC0)==0x00A80||(s&0x0003F)==0x0002A||(s&0x030C3)==0x02082||(s&0x0C30C)==0x08208||(s&0x30C30)==0x20820||(s&0x03330)==0x02220||(s&0x30303)==0x20202)return 'lose'
if((s&0x2AAAA)==0x2AAAA)return 'cat'

इस संस्करण में, sएक पूर्णांक शामिल है जो गेम बोर्ड की स्थिति का प्रतिनिधित्व करता है। यह मूल्य का एक छोटा सा सरणी है जहां दो बिट्स बोर्ड पर प्रत्येक वर्ग का प्रतिनिधित्व करते हैं:

10 - एक्स
11 - ओ
00 - खाली वर्ग

यह समाधान प्रत्येक आठ संभव "तीन को एक पंक्ति" कॉन्फ़िगरेशन में परीक्षण करने के लिए बिट हेरफेर का उपयोग करता है (यह उन्हें प्रत्येक दो बार परीक्षण करता है, एक बार एक्स के लिए और एक बार ओ के लिए)।

मैं इसे अपनी टिक-टैक-टो वेबसाइट से लघु प्रस्तुति के साथ प्रस्तुत करता हूं जहां यह detectWinफ़ंक्शन वास्तविक टिक-टीएसी-टो गेम के भाग के रूप में उपयोग होता है।

— स्टीफन ओस्टरमिलर
स्रोत

6

खैर, इसे क्रूरता कहा जा सकता है।

— देखिए

2

रूबी, 84 वर्ण

$><<(gets.tr("01","10")[r=/0..(0|.0.)..0|000(...)*$|^..0.0.0/]?:win:~r ?:lose: :cat)

सरल, RegExp आधारित समाधान। इनपुट प्रारूप एक 9-अंकीय बाइनरी स्ट्रिंग है, उदाहरण के 110101001लिए प्रश्न में दिए गए उदाहरण बोर्ड।

रूबी, 78 वर्ण

$><<(gets.tr("ox","xo")[r=/o...(o|.o.)...o|ooo|o_.o._o/]?:win:~r ?:lose: :cat)

इनपुट प्रारूप: xxo_xox_oox

— Ventero
स्रोत

1

हास्केल, 169

main=interact$(\x->last$"cat":[b|(a,b)<-[("ooo","lose"),("xxx","win")],any(==a)x]).(\x->x++(foldr(zipWith(:))(repeat[])x)++map(zipWith(!!)x)[[0..],[2,1,0]]).take 3.lines

इनपुट प्रारूप: "X" केवल x"O" द्वारा दर्शाया गया है o। प्रत्येक पंक्ति के भीतर, वर्ण रिक्त स्थान के बिना एक साथ होते हैं, आदि पंक्तियों को नई रेखाओं द्वारा अलग किया जाता है।

सभी संभावित पंक्तियों / स्तंभों / विकर्णों को उत्पन्न करता है, फिर [("ooo","lose"),("xxx","win")]बोर्ड पर उनके अस्तित्व द्वारा फ़िल्टर करता है, फिर टपल में दूसरे शब्द का चयन करता है, इसलिए हम जानते हैं कि कौन से खिलाड़ी जीते। हम पूर्वनिर्धारित करते हैं "cat"ताकि हम सूची के अंतिम तत्व को अपने विजेता के रूप में ले सकें। यदि दोनों खिलाड़ी जीते हैं, "win"तो अंतिम होगा (सूची की समझ बनाए रखने के आदेश)। चूंकि "cat"हमेशा पहले होता है, यदि कोई विजेता मौजूद होता है, तो उसे चुना जाएगा, लेकिन अन्यथा एक अंतिम तत्व अभी भी मौजूद है क्योंकि यह "cat"गैर- रिक्तता की गारंटी देता है।

संपादित करें: पिछली सूची की समझ को बदलकर 3 वर्णों को शेव किया गया map।

— YawarRaza7349
स्रोत

1

सी, 150 लगभग

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

उपयोगकर्ता इनपुट दो अष्टाधारी संख्याएं (मैं बाइनरी का उपयोग करना चाहता था लेकिन जहां तक मुझे पता है कि सी केवल अष्टक का समर्थन करता है):

a केंद्र वर्ग का प्रतिनिधित्व करता है, X के लिए 1, O के लिए 0

b परिधि वर्गों का प्रतिनिधित्व करने वाला एक नौ-अंकीय संख्या है, एक कोने में शुरू होने वाले बोर्ड के चारों ओर चक्कर लगाना और एक ही कोने में (केवल उस कोने के दोहराव के साथ), एक X के लिए 1, O के लिए 0।

जीतने के दो संभावित तरीके हैं:

केंद्र वर्ग X ( a= 1) है और दो विपरीत वर्ग भी X हैं ( b&b*4096गैर-शून्य है)
तीन आसन्न परिधि वर्ग एक्स हैं ( b/8 & b & b*8नॉनज़ेरो हैं।) यह केवल एक वैध जीत है यदि मध्य वर्ग एक किनारे वर्ग है, न कि एक कोने वर्ग, इसलिए mकोने वर्ग के मामलों से बचने के लिए, मुखौटा भी लागू करना आवश्यक है ।

हार का पता चर सी का उपयोग करके लगाया जाता है, जो कि बी का विलोम है।

int a,b,c,m=010101010;
main(){
    scanf("%o%o",a,b);c=b^0111111111;
    printf("%s",(a&&b&b*4096)|(b/8&b&b*8&m)?"win":((!a&&c&c*4096)|(c/8&c&c*8)?"lose":"cat"));
}

— स्तर नदी सेंट
स्रोत

आप m"खो" का पता लगाने में मुखौटा लागू करना भूल गए - c/8&c&c*8। मैंने आपके कोड को (इसके संचालन के परीक्षण के बिना) इस प्रकार से फिर से रखा है:

int a,b;t(v){return a&&v&v<<12||v/8&v&v*8&0x208208;}main(){scanf("%o%o",a,b);printf("%s",t(b)?"win":t(b^0x1249249)?"lose":"cat");}

(130 वर्ण)। दोहराया परीक्षण एक परीक्षण समारोह में निकालने के लिए पर्याप्त था t(); यह cऔर की आवश्यकता को हटा देता है m; स्थिरांक एक चार को बचाने के लिए हेक्स में परिवर्तित हो गए।

— टोबी स्पाइट

बस देखा जाता है कि printfएक प्रारूप स्ट्रिंग की आवश्यकता नहीं है - बस परिणाम स्ट्रिंग को प्रारूप के रूप में आपूर्ति करें - या putsयह, क्योंकि सवाल आउटपुट के बाद एक नई रेखा के लिए नहीं पूछता है! (एक और 7 वर्ण बचाता है)।

— टोबी स्पाइट

1

दे घुमा के, 107 103

एक स्क्रिप्ट बनाता है और चलाता है।

I / O प्रारूप: oxo-oox-xooआउटपुट lose(एक -अलग पंक्तियों का उपयोग करें )। स्टड पर इनपुट। cआदेश के लिए GNU sed की आवश्यकता है ।

मैंने नियम 5 को "अगर जीत और हार संभव है, तो जीत चुनें" के रूप में व्याख्या की है।

मुख्य कोड

यह वास्तविक उत्तर है।

वास्तव में दिलचस्प कुछ भी नहीं। यह परिभाषित करता है $bके रूप में /cwinपात्रों को बचाने के लिए है, तो स्क्रिप्ट की जीत हालत भाग को परिभाषित करता है, तो का उपयोग करता है sed y/x/o/\;s$b/close/परिवर्तित करने के लिए xकरने के लिए oऔर cwinकरने के लिए close(और इस प्रकार खो की स्थिति पैदा करने)। फिर यह दो चीजों को भेजता है और ccat( catयदि कोई जीत / हार की स्थिति से मेल नहीं खाता है तो उत्पादन होगा )।

b=/cwin
v="/xxx$b
/x...x...x$b
/x..-.x.-..x$b
/x-.x.-x$b"
sed "$v
`sed y/x/o/\;s$b/close/<<<"$v"`
ccat"

उत्पन्न कोड

यह बैश स्क्रिप्ट द्वारा निर्मित और चलाई जाने वाली सेड स्क्रिप्ट है।

रेगेक्स में, .किसी भी पात्र से मेल खाता है और उनके बाद cTEXTTEXT प्रिंट करता है और यदि regex का मिलान होता है, तो बाहर निकलता है।

यह स्टैंडअलोन सेड स्क्रिप्ट के रूप में चल सकता है। यह 125 वर्ण लंबा है, आप इसे दूसरे समाधान के रूप में गिन सकते हैं।

/xxx/cwin
/x...x...x/cwin
/x..-.x.-..x/cwin
/x-.x.-x/cwin
/ooo/close
/o...o...o/close
/o..-.o.-..o/close
/o-.o.-o/close
ccat

1

पायथन 3, 45

इनपुट में है i, जो प्रत्येक पंक्ति, कॉलम और गेम बोर्ड के विकर्ण का प्रतिनिधित्व करने वाली संख्याओं की सूची है, जैसे:

X X O
O X O
O O X

द्वारा दर्शाया गया है [6, 2, 1, 4, 6, 1, 7, 4]।

कोड :('cat','lose','win')[2 if 7 in i else 0 in i]

— pseudonym117
स्रोत

1

डार्ट - 119

(देखें dartlang.org )।

RegExp का उपयोग करके मूल संस्करण: 151 वर्ण।

main(b,{w:"cat",i,p,z}){
 for(p in["olose","xwin"])
   for(i in[0,2,3,4])
     if(b[0].contains(new RegExp('${z=p[0]}(${'.'*i}$z){2}')))
       w=p.substring(1);
  print(w);
}

कमांड लाइन पर इनपुट 11 वर्ण है, उदाहरण के लिए, "xxx | ooo | xxx"। किसी भी गैर-Xo चरित्र का उपयोग सीमांकक के रूप में किया जा सकता है।

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

रीससिव बिट-बेस संस्करण: 119 वर्ण। इनपुट एक 9-बिट संख्या होनी चाहिए जिसमें 1s 'x' और 0s 'o' का प्रतिनिधित्व करता है।

main(n){
  n=int.parse(n[0]);
  z(b,r)=>b>0?b&n==b&511?"win":z(b>>9,n&b==0?"lose":r):r;
  print(z(0x9224893c01c01e2254,"cat"));
}

— LRN
स्रोत

1

CJam, 39 38 36 वर्ण

"ᔔꉚ굌궽渒䗠脯뗠㰍㔚귇籾〳㎪䬔⹴쪳儏⃒ꈯ琉"2G#b129b:c~

यह एक आधार रूपांतरित कोड है

q3/_z__Wf%s4%\s4%]`:Q3'o*#"win"{Q'x3*#"lose""cat"?}?

जो 52 वर्ण लंबा है।

इनपुट केवल बोर्ड के स्ट्रिंग प्रतिनिधित्व है जो बाईं ओर से शुरू होता है, पंक्ति से पंक्ति में जा रहा है। उदाहरण के लिए:

oxooxooox

जिसके परिणामस्वरूप winआउटपुट होता है। या

oxooxoxox

जिसके परिणामस्वरूप catउत्पादन होता है, आदि।

कोड बस निम्नलिखित तीन चीजें करता है:

q3/_ - स्ट्रिंग को 3 के भागों में विभाजित करें, अर्थात प्रति पंक्ति
_z - प्रति पंक्ति सरणी की प्रतिलिपि बनाएँ और कॉलम सरणी में स्थानांतरित करें।
__Wf%s4%- प्रत्येक पंक्ति को उल्टा करें और बाएं से दाएं विकर्ण प्राप्त करें। यह बोर्ड का द्वितीयक विकर्ण है।
\s4% - बोर्ड का मुख्य विकर्ण प्राप्त करें
]` - सरणी में सब कुछ लपेटें और सरणी को कठोर करें।

अब हमारे पास बोर्ड से 3 के सभी संभावित समूह हैं। हम केवल परिणाम का निर्धारण करने के लिए "ooo" और "xxx" के अस्तित्व की जांच करते हैं।

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत

1

जीएनयू सेड, 25 बाइट्स

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

इनपुट प्रारूप: xxx ooo xxx xox xox xox xox xox (ओपी के प्रश्न से लिया गया बोर्ड राज्य)

/xxx/cwin
/ooo/close
ccat

यदि इनपुट प्रारूप गैर-निरर्थक है ( xxx ooo xxx) है, तो ऊपर दिया गया sed कोड केवल तभी काम करता है जब नीचे दी गई रेखा से प्रीपेंड किया जाता है, जिससे प्रोग्राम 96 बाइट्स लंबा हो जाता है (आवश्यक rध्वज गणना के साथ)।

s/(.)(.)(.) (.)(.)(.) (.)(.)(.)/& \1\4\7 \2\5\8 \3\6\9 \1\5\9 \3\5\7/

— seshoumara
स्रोत

1

बैश: 208 चार

y(){ tr '01' '10'<<<$@;}
f(){ x=$[($1&$2&$3)|($1&$5&$9)|($1&$4&$7)|($2&$5&$8)|($3&$5&$7)|($3&$6&$9)|($4&$5&$6)|($7&$8&$9)]; }
f $@;w=$x
f $(y $@)
([ $x -eq 1 ]&&echo lose)||([ $w -eq 1 ]&&echo win)||echo cat

निष्पादन हेतु bash tictactoe.sh 0 1 0 1 0 1 1 0 1

इस उत्तर से प्रेरित ।

— माइकल मिओर
स्रोत

0

VB.net

उदाहरण प्रदान करने के साथ निम्न बिट-पैटर्न के रूप में एन्कोड किया गया है

q  = &B_100101_100110_011010 ' 00 Empty, 01 = O, 10 = X

अब हम निम्नलिखित करके परिणाम (या विजेता) निर्धारित कर सकते हैं।

Dim g = {21, 1344, 86016, 66576, 16644, 4161, 65379, 4368}
Dim w = If(g.Any(Function(p)(q And p)=p),"Lose",If(g.Any(Function(p)(q And p*2)=p*2),"Win","Cat"))

— एडम स्पाइट
स्रोत

0

जे - 97 बाइट्स

ठीक है, सबसे सरल दृष्टिकोण उपलब्ध है। इनपुट के रूप में लिया जाता है 111222333, जहां संख्याएं पंक्तियों का प्रतिनिधित्व करती हैं। बाएं से दाएं पढ़ें। खिलाड़ी है xऔर दुश्मन है o। खाली वर्गों को छोड़कर xया कुछ भी हो सकता है o।

f=:(cat`lose>@{~'ooo'&c)`('win'"_)@.('xxx'&c=:+./@(r,(r|:),((r=:-:"1)(0 4 8&{,:2 4 6&{)@,))3 3&$)

उदाहरण: (NB एक टिप्पणी है)

   f 'xoxxoxxox' NB. Victory from first and last column.
win
   f 'oxxxooxxx' NB. Victory from last row.
win
   f 'ooxxoxxxo' NB. The example case, lost to a diagonal.
lose
   f 'xxooxxxoo' NB. Nobody won.
cat
   f 'xoo xx ox' NB. Victory from diagonal.
win

अनगोल्ड कोड एक स्पष्टीकरण

row   =: -:"1                        Checks if victory can be achieved from any row.
col   =: -:"1 |:                     Checks if victory can be achieved from any column.
diag  =: -:"1 (0 4 8&{ ,: 2 4 6&{)@, Checks if victory can be achieved from diagonals.
check =: +./@(row,col,diag) 3 3&$    Checks all of the above and OR's them.

f     =: (cat`lose >@{~ 'ooo'&check)`('win'"_)@.('xxx'&check)
Check if you have won ........................@.('xxx'&check)
 If yes, return 'win' .............. ('win'"_)
 If not                   (cat`lose >@{~ 'ooo'&check)
  Check if enemy won ................... 'ooo'&check
   If yes, return 'lose'   ---`lose >@{~
   If not, return 'cat'    cat`---- >@{~

— seequ
स्रोत

0

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

b=0b101001110
l=[448,56,7,292,146,73,273,84]
print(['Win'for w in l if w&b==w]+['Lose'for w in l if w&~b==w]+['Cat'])[0]

या पायथन, पाइथन शेल से 115 बाइट्स (2 या 3):

b=0b101001110;l=[448,56,7,292,146,73,273,84];(['Win'for w in l if w&b==w]+['Lose'for w in l if w&~b==w]+['Cat'])[0]

बोर्ड चर प्रश्न में वर्णित बाइनरी प्रारूप पर सेट है: 1एक्स के लिए, 0ओ के लिए, बाएं से दाएं, ऊपर से नीचे। इस मामले में, 101001110प्रतिनिधित्व करता है

XOX
OOX
XXO

जिसके परिणामस्वरूप उत्पादन होता है: Cat

— सेसम टिमरमैन
स्रोत

इनपुट प्रारूप क्या है?

— देखिए

0

पायथन ( 73 62 वर्ण)

इनपुट चार लोअर-केस स्ट्रिंग्स हैं, जो एक ही बोर्ड के चार अलग-अलग विचारों का प्रतिनिधित्व करते हैं, सभी एक ही स्ट्रिंग में समाप्‍त होते हैं: पंक्ति द्वारा, स्तंभ द्वारा, दाएं-तिरछे, बाएं-विकर्ण।

अपडेट करें

एक अच्छे काउंटर-उदाहरण के साथ इस ओर इशारा करने के लिए धन्यवाद! एक बोर्ड के भीतर प्रत्येक खंड (पंक्ति या स्तंभ) के साथ बोर्ड के प्रत्येक दृश्य को एक चरित्र द्वारा अलग किया जाना है जो न तो "x" या "ओ" है, ताकि बोर्ड का ढांचा संघनन के बाद भी संरक्षित हो। बोर्ड के प्रत्येक दृश्य के चारों ओर की सीमाएं चौकोर कोष्ठक ("[" और "]") होंगी, और पंक्तियों / स्तंभों के बीच विभाजक एक पाइप वर्ण होगा "" |

यह एल्गोरिथ्म को सरल बनाता है - बस एक जीत या नुकसान के लिए क्रमशः "xxx" या "चिड़ियाघर" देखें। अन्यथा यह एक टाई (बिल्ली) है।

जैसे बोर्ड (बाएं से दाएं, ऊपर से नीचे) पढ़ना ...

X | X | X X | O | X O | X | O |

... का प्रतिनिधित्व "[xxx | xox | oxo]" (पंक्तियों द्वारा) + "[xxo | xox | xxo]" (स्तंभों द्वारा) + "[xoo]" (दाएँ डायग) + [xoo] "(बाएं) diag) = "[xxx | xox | oxo] [xxo | xox | xxo] [xoo] [xoo]"।

यह अजगर बयान प्रिंट खेल चर दिया परिणाम है इनपुट के रूप में:

print 'win' if 'xxx' in s else 'lose' if 'ooo' in s else 'cat'

— बॉब
स्रोत

क्या यह बोर्ड के लिए काम करता है OXX XOO XOX(यह बिल्ली होना चाहिए)?

— देखिए

नहीं ... नहीं यह नहीं है। अच्छी पकड़! मुझे लगता है कि मेरा समाधान थोड़ा बहुत सरल था ... उफ़!

— बोब

मैं यह नहीं कह सकता कि इस प्रकार के समाधान ने मेरे दिमाग को पार नहीं किया। :)

— seequ

0

हास्केल (69 वर्ण)

i x=take 4$(x>>=(\y->case y of{'7'->"win";'0'->"lose";_->""}))++"cat"

यह इस उत्तर के अनुसार उसी इनपुट को लेता है । प्रत्येक पंक्ति, स्तंभ और विकर्ण के द्विआधारी मान का वर्णन करते हुए, विशेष रूप से, इनपुट 8 अष्टाधारी मूल्य है। कोड 7 "जीत" का हर उदाहरण बनाता है, 0 "हार" का हर उदाहरण, और बाकी सब को हटा देता है। फिर यह अंत में "बिल्ली" जोड़ता है और परिणाम से पहले 4 वर्ण लेता है।

4 संभावित उत्तर होंगे: "हार", "बिल्ली", "जीत" उसके बाद एक 'एल', और "जीत" के बाद एक 'सी', जिसे नियम निषेध नहीं करते हैं :)

उदाहरण का उपयोग:

i "65153806" --outputs "lose"

— TheBrownMotie
स्रोत

0

जे: 83

(;:'lose cat win'){::~>:*(-&(+/@:(*./"1)@;@(;((<0 1)&|:&.>@(;|.)(,<)|:)))-.)3 3$'x'=

उपयोग: बस एक्स और ओ के एक स्ट्रिंग संलग्न करें और जादू का काम देखें। जैसे। 'Xxxoooxxx'।

आंतरिक क्रिया (+/@:(*./"1)@;@(;((<0 1)&|:&.>@(;|.)(,<)|:)))मूल रूप से मूल द्विआधारी मैट्रिक्स के साथ एक साथ बॉक्स करती है, जिसमें 2 विकर्णों के साथ एक साथ प्रेषित बॉक्स होता है। ये परिणाम एक साथ चकित होते हैं; जीत का निर्धारण करने के लिए पंक्ति रकम ली जाती है, और फिर सारांशित किया जाता है। आगे मैं इस क्रिया को कहूंगा Inner।

विजेता को खोजने के लिए, सामान्य और उल्टे बाइनरी मैट्रिस के बीच के अंकों का अंतर हुक द्वारा लिया जाता है (-&Inner -.)।

बाकी कोड केवल आउटपुट बनाता है, और सही का चयन करता है।

— jpjacobs
स्रोत

0

जावास्क्रिप्ट, 133 , 114 वर्ण

r = '/(1){3}|(1.{3}){2}1|(1.{4}){2}1|(1\|.1.\|1)/';alert(i.match(r)?'WIN':i.match(r.replace(/1/g,0))?'LOSS':'CAT')

इनपुट iपंक्तियों के लिए सीमांकक के साथ एक सरल स्ट्रिंग है, अर्थात100|001|100

संपादित करें: नुकसान के मामले की जांच करने के लिए जीरो के साथ रेक्स में 1s को बदलने के लिए मेरी विधि को अपडेट किया।

— thomaux
स्रोत

आप =रेगेक्स शाब्दिक के चारों ओर के रिक्त स्थान और उद्धरण को हटा सकते हैं । इसके अलावा, 1...एक चरित्र से छोटा है 1.{3}।

— nyuszika7h

1

r.test(i)से भी छोटा एक चरित्र है i.match(r)।

— nyuszika7h

0

जे - 56 (26?) चार

इनपुट को नौ अक्षरों का 3x3 मैट्रिक्स दिया गया है, क्योंकि J उस डेटाटाइप, LOL के रूप में समर्थन कर सकता है।

(win`lose`cat{::~xxx`ooo<./@i.<"1,<"1@|:,2 7{</.,</.@|.)

उदाहरण:

   NB. 4 equivalent ways to input the example board
   (3 3 $ 'xxoxoxoox') ; (_3 ]\ 'xxoxoxoox') ; ('xxo','xox',:'oox') ; (];._1 '|xxo|xox|oox')
+---+---+---+---+
|xxo|xxo|xxo|xxo|
|xox|xox|xox|xox|
|oox|oox|oox|oox|
+---+---+---+---+
   (win`lose`cat{::~xxx`ooo<./@i.<"1,<"1@|:,2 7{</.,</.@|.) 3 3 $ 'xxoxoxoox'
lose
   wlc =: (win`lose`cat{::~xxx`ooo<./@i.<"1,<"1@|:,2 7{</.,</.@|.)
   wlc (3 3 $ 'xoxoxooxo')
cat
   wlc (3 3 $ 'xxxoooxxx')
win

यदि हमें प्रत्येक पंक्ति, स्तंभ और विकर्ण की स्थिति का निरूपण करते हुए अष्टाधारी अंकों की गोल्फस्क्रिप्ट एन्कोडिंग की अनुमति है, तो यह सिर्फ 26 वर्ण है:

   win`lose`cat{::~7 0<./@i.] 6 5 1 6 4 3 5 0
lose
   f=:win`lose`cat{::~7 0<./@i.]
   f  7 0 7 5 5 5 5 5
win

— algorithmshark
स्रोत

0

टी-एसक्यूएल (2012), 110

select max(iif(@&m=0,'lose',iif(@&m=m,'win','cat')))from(VALUES(292),(146),(73),(448),(56),(7),(273),(84))z(m)

इनपुट एक हेक्स संख्या है। यह टी-एसक्यूएल में माणिक समाधान का बहुत सुंदर और स्वच्छ अनुवाद है।

— माइकल बी
स्रोत

0

जावास्क्रिप्ट 1.6, 71 वर्ण

मैं इनपुट को एक सरणी के रूप में मान रहा हूं gameजिसमें प्रत्येक पंक्ति, प्रत्येक स्तंभ और प्रत्येक डायग 3 char स्ट्रिंग के रूप में है। बॉब के उत्तर के समान है , लेकिन यह एक सरणी में आता है, न कि एक समतल स्ट्रिंग के रूप में।

alert(game.indexOf("xxx")>=0?"win":game.indexOf("ooo")>=0?"lose":"cat")

EDIT @ nyuszika7h की टिप्पणी (67 वर्ण)

alert(~game.indexOf("xxx")?"win":~game.indexOf("ooo")?"lose":"cat")

— JNF
स्रोत

आप के ~game.indexOf("xxx")बजाय उपयोग कर सकते हैं game.indexOf("xxx")>=0, दूसरे के लिए एक ही है।

— nyuszika7h

0

जावा 7, 260 बाइट्स

String c(int[]s){int a[]=new int[8],x=0,y;for(;x<3;x++){for(y=0;y<3;a[x]+=s[x*3+y++]);for(y=0;y<3;a[x+3]+=s[y++%3]);}for(x=0;x<9;y=s[x],a[6]+=x%4<1?y:0;a[7]+=x%2<1&x>0&x++<8?y:0);x=0;for(int i:a)if(i>2)return"win";for(int i:a)if(i<1)return"loose";return"cat";}

अनगढ़ और परीक्षण के मामले:

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

class M{
  static String c(int[] s){
    int a[] = new int[8],
        x = 0,
        y;
    for(; x < 3; x++){
      for(y = 0; y < 3; a[x] += s[x * 3 + y++]);
      for (y = 0; y < 3; a[x + 3] += s[y++ % 3]);
    }
    for(x = 0; x < 9; y = s[x],
                      a[6] += x % 4 < 1
                               ? y
                               : 0,
                      a[7] += x % 2 < 1 & x > 0 & x++ < 8
                               ? y
                               : 0);
    x = 0;
    for(int i : a){
      if(i > 2){
        return "win";
      }
    }
    for(int i : a){
      if(i < 1){
        return "loose";
      }
    }
    return "cat";
  }

  public static void main(String[] a){
    /*  xxo
        xox
        oox  */
    System.out.println(c(new int[]{ 1, 1, 0, 1, 0, 1, 0, 0, 1 }));
    /*  xxx
        ooo
        xxx  */
    System.out.println(c(new int[]{ 1, 1, 1, 0, 0, 0, 1, 1, 1 }));
    /*  xxo
        oox
        xox  */
    System.out.println(c(new int[]{ 1, 1, 0, 0, 0, 1, 1, 0, 1 }));
  }
}

आउटपुट:

loose
win
cat

— केविन क्रूज़सेन
स्रोत

0

एपीएल (एनएआरएस), 69 चार्ट, 138 बाइट्स

{w←3 3⍴⍵⋄x←(+/1 1⍉⊖w),(+/1 1⍉w),(+⌿w),+/w⋄3∊x:'win'⋄0∊x:'lose'⋄'cat'}

इनपुट एक 3x3 मैट्रिक्स या 9 तत्व का एक रैखिक सरणी होना चाहिए जो केवल 1 (एक्स के लिए) और 0 (ओ के लिए) हो सकता है, परिणाम "बिल्ली" होगा यदि कोई नहीं जीतता है, तो "हार" अगर ओ जीतता है, "जीत" “अगर X जीत गया। एक अमान्य बोर्ड के लिए कोई चेक नहीं है या इनपुट है एक सरणी में 9 से कम तत्व या अधिक है या प्रत्येक तत्व की जांच करें <2।

एक टिप्पणी के रूप में: यह एक 3x3 मैट्रिक्स में इनपुट को परिवर्तित करेगा, और "एक्स" नामक एक सरणी का निर्माण करेगा जहां तत्व प्रत्येक पंक्ति कॉलम और विकर्ण का योग है।

कुछ परीक्षण देखें उदाहरण दूसरों से दिखाया गया है:

  f←{w←3 3⍴⍵⋄x←(+/1 1⍉⊖w),(+/1 1⍉w),(+⌿w),+/w⋄3∊x:'win'⋄0∊x:'lose'⋄'cat'}
  f 1 2 3
win
  f 0 0 0
lose
  f 1 0 1  1 0 1  1 0 1
win
  f 0 1 1  1 0 0  1 1 1
win
  f 0 0 1  1 0 1  1 1 0
lose
  f 1 1 0  0 1 1  1 0 0
cat
  f 1 1 0  0 1 0  0 0 1
win
  f 1 1 0  1 0 1  0 0 1
lose

— RosLuP
स्रोत

Tictactoe में जीत निर्धारित करें

रूबी 2.0, 85 अक्षर

गणितज्ञ, 84 वर्ण

बैश: 283 262 258

बेफुज 93 - 375

GolfScript, 27 वर्ण

पायथन 2 - 214 बाइट्स

हास्केल, 146 वर्ण

जावास्क्रिप्ट, 420 वर्ण

रूबी, 84 वर्ण

रूबी, 78 वर्ण

हास्केल, 169

सी, 150 लगभग

दे घुमा के, 107 103

मुख्य कोड

उत्पन्न कोड

पायथन 3, 45

डार्ट - 119

CJam, 39 38 36 वर्ण

जीएनयू सेड, 25 बाइट्स

बैश: 208 चार

जे - 97 बाइट्स

अनगोल्ड कोड एक स्पष्टीकरण

पायथन ( 73 62 वर्ण)

अपडेट करें

हास्केल (69 वर्ण)

जे: 83

जावास्क्रिप्ट, 133 , 114 वर्ण

जे - 56 (26?) चार

टी-एसक्यूएल (2012), 110

जावास्क्रिप्ट 1.6, 71 वर्ण

जावा 7, 260 बाइट्स

एपीएल (एनएआरएस), 69 चार्ट, 138 बाइट्स