टिक टीएसी को पैर की अंगुली शब्दकोश

Question

एक TicTacToeखेल को एक स्ट्रिंग द्वारा दर्शाया जा सकता है जो कि पदों के अनुक्रम को दर्शाता है क्योंकि खिलाड़ी अपना कदम रखते हैं।

0 1 2
३ ४ ५
६ 8 8

मान लें कि Xहमेशा पहले खेलता है।

तो "012345678" का एक स्ट्रिंग खेल को दर्शाता है

XOX
OXO
XOX

ध्यान दें, खेल पहले से ही जीता जाता है जब खिलाड़ी Xअंक प्राप्त करता है 6, उस बिंदु पर खेल समाप्त होता है, जिससे जीत मिलती है X। (यानी, एक खिलाड़ी के जीतने के बाद शेष चालों को अनदेखा करें)

आपकी चुनौती (कोड) सभी खेलों (क्रमबद्ध क्रम) और उसके परिणामों को प्रिंट करना है।

प्रारूप

<movesequence>:<result>\n

उदाहरण के लिए:

012345678:X
012345687:X
012345768:X
...

निरूपित X1 खिलाड़ी विजेता, के लिए Oदूसरे खिलाड़ी के लिए, और Dके लिए बनाता है।

वहाँ हो जाएगा 9!(362,880) खेल।

आपके परिणामों को सत्यापित करने के लिए यहां कुछ डेटा दिए गए हैं।

'X' Wins: 212256 
'O' Wins: 104544 
Draws : 46080 

यह एक कोडगॉल्फ है, और रनटाइम एक मिनट के भीतर होना चाहिए। मज़े करो!

संपादित करें: अतिरिक्त विवरण हटा दिए गए हैं, और बस इसे प्रिंट करें stdout। कोई फ़ाइल बनाने की आवश्यकता नहीं है।

Comments

मुझे यहां अलग-अलग नंबर मिल रहे हैं: X के लिए 212256 जीत, O के लिए 104544 जीत और 46080 ड्रॉ (और विकिपीडिया मेरे लिए सहमत होने लगता है )।

— वेंचरो

@ वेंटरो, मैं पुन: जाँच करूँगा, लेकिन मुझे पृष्ठ पर उन संख्याओं का कोई संदर्भ नहीं दिखता।

— st0le

@ वेंटरो, आप सही कह रहे हैं, मैं उस हिस्से को संपादित करूंगा। जल्द ही md5sum पोस्ट करेंगे।

— st0le

रूबी का उत्तर सबसे छोटा नहीं है, इसलिए यह आपके स्कोरिंग मानदंड (कोड-गोल्फ) के अनुसार स्वीकृत उत्तर नहीं होना चाहिए।

— mbomb007

Answer 1

रूबी 1.9, 201 अक्षर

r=*[*l=0..8,0,3,6,1,4,7,2,5,8,0,4,8,2,4,6].each_slice(3)
w=->a{r.any?{|b|b&a==b}}
[*l].permutation(9){|a|u=[[],[]];i=-1
u[i%2]<<a[i+=1]while !((x=w[u[1]])||o=w[u[0]])&&i<8
puts a*""+":#{x ??X:o ??O:?D}"}

थोड़ा अब तक गोल्फ। यहां पूरा होने में लगभग 45 सेकंड लगते हैं।

• संपादित करें: (268 -> 249) फ़ाइल के बजाय stdout लिखें
• संपादित करें: (249 -> 222) प्रत्येक खिलाड़ी की चाल के साथ सरणी को पहले से न भरें।
• संपादित करें: (222 -> 208) एक खिलाड़ी ने जीता तो यह पता लगाने के लिए छोटा रास्ता
• संपादित करें: (208 -> 213) 213 पर वापस जाएं, पिछला समाधान बहुत धीमा था।
• संपादित करें: (213 -> 201) कुछ पुनर्व्यवस्था, हटाए गए व्हाट्सएप

Comments

मैंने प्रश्न को थोड़ा संपादित किया, आपको अब एक फ़ाइल बनाने की आवश्यकता नहीं है, बस इसे प्रिंट करें।

— st0le

Answer 2

जे, 124 वर्ण

((],~':',~1":[){&'DOX'@(</+2*>/)@:(<./"1)@:(((2{m/.@|.),(2{m/.),m"1,>./)"2)@(<:@(>:%2|]),:(%(2|>:)))@(3 3$]))"1((i.!9)A.i.9)

एक्स जीत, ओ जीत और ड्रा काउंट चेक आउट।

हालांकि डिबग करने के लिए थोड़ा दर्दनाक था। :)

Answer 3

हास्केल, 224 222 वर्ण

import Data.List
p=sort.permutations
a(e:_:z)=e:a z;a z=z
[c,d]%(e:z)|any((`elem`words"012 345 678 036 147 258 048 246").take 3).p.a.reverse$e=c|1<3=[d,c]%z;_%[]='D'
main=putStr$p['0'..'8']>>=(\s->s++':':"OX"%inits s:"\n")

काश, permutationsफ़ंक्शन से Data.Listलेक्सोग्राफ़िक क्रम में क्रमपरिवर्तन नहीं होते। इसलिए मुझे 6 तरह के किरदार निभाने पड़े।

Answer 4

एपीएल (139)

यह संभवतः अधिक छोटा किया जा सकता है, लेकिन यह काफी कठिन था जैसा कि यह है। मानो या न मानो, यह मेरे कंप्यूटर पर लगभग 45 सेकंड में चलता है (स्क्रीन को आउटपुट करते समय सब कुछ आउटपुट करने में लगने वाले समय को छोड़कर)।

↑{⊃,/(,/⍕¨⍵-1),':',{1∊T←↑{∨/↑{⍵∘{⍵≡⍵∧⍺}¨↓⍉(9⍴2)⊤⎕UCS'㗀㐇㔤㑉㔑㑔'}¨↓(M∘.≥M)∧[2]M∊⍵}¨↓⍉5 2⍴0,⍨⍵:'XO'[1+</+/T]⋄'D'}⍵}¨↓{1≥⍴⍵:↑,↓⍵⋄↑⍪/⍵,∘∇¨⍵∘~¨⍵}M←⍳9

स्पष्टीकरण:

• M←⍳9: 1 से 9 तक एम संख्या में स्टोर करें। आंतरिक रूप से, यह प्रोग्राम 0..8 के बजाय 1..9 का उपयोग करता है।
• {... }: सभी क्रमपरिवर्तन प्राप्त करने के लिए एक समारोह:
  • 1≥⍴⍵:↑,↓⍵: यदि लंबाई छोटी या 1 के बराबर है, तो तर्क को मैट्रिक्स के रूप में वापस करें।
  • ⋄↑⍪/⍵,∘∇¨⍵∘~¨⍵: अन्यथा, प्रत्येक वर्ण को अंदर ⍵से निकालें ⍵, उस की क्रमबद्धता प्राप्त करें, और चरित्र को वापस जोड़ें।
• ¨↓: प्रत्येक क्रमपरिवर्तन के लिए ...
• {... }: एक फ़ंक्शन जो उस क्रमपरिवर्तन के लिए विजेता देता है:
  • ⊃,/(,/⍕¨⍵-1),':',{... }⍵: एक क्रमांक को स्ट्रिंग के रूप में प्राप्त करें, 1 के साथ सभी संख्याओं में कमी आई (1..9 के बजाय आवश्यक 0..8 आउटपुट प्राप्त करने के लिए), इसके बाद एक कोलन द्वारा पीछा किया जाता है, इसके बाद विजेता को दर्शाते हुए वर्ण:
    • ⍉5 2⍴0,⍨⍵: O द्वारा चालों को X से अलग करें। क्योंकि O में X से कम की चाल है, इसलिए वह स्थान भरा है 0, जो अप्रयुक्त है और इसलिए परिणाम को प्रभावित नहीं करता है।
    • {... }¨↓: X बोर्ड और O बोर्ड दोनों के लिए, निम्नलिखित फंक्शन चलाएं जो यह निर्धारित करता है कि नौ में से एक में जीत है या नहीं:
      • (M∘.≥M)∧[2]M∊⍵: चाल संख्याओं से एक बिटबोर्ड उत्पन्न करें, और andइस बिटबोर्ड को बिटस्ट्रिंग्स के साथ 100000000, 110000000... 111111111समय के प्रत्येक नौ क्षण में बोर्ड की स्थिति प्राप्त करने के लिए।
      • {... }¨↓: इनमें से प्रत्येक के लिए, निम्न फ़ंक्शन चलाएँ:
        • ⍉(9⍴2)⊤⎕UCS'㗀㐇㔤㑉㔑㑔': प्रत्येक संभावित जीतने की स्थिति के लिए बिटबोर्ड प्राप्त करें
        • ⍵∘{⍵≡⍵∧⍺}¨↓: andवर्तमान बिटबोर्ड के साथ प्रत्येक जीतने वाला राज्य और जाँच करें कि क्या जीतने वाला राज्य अभी भी है
      • ∨/↑: orये एक साथ, यह देते हुए कि इस बिटबोर्ड पर जीत है या नहीं
    • 1∊T←↑: एक 9x2 मैट्रिक्स बनाओ, पहली पंक्ति पर 9 एक्स-टाइमस्टेप्स और दूसरी पंक्ति पर 9 ओ-टाइमस्टेप्स के साथ। इसे T में संग्रहीत करें। यदि इस मैट्रिक्स में 1 है, तो कोई जीता है।
    • :'XO'[1+</+/T]: यदि कोई जीता है, तो 'X' या 'O' दें, जो 1पहले था।
    • ⋄'D': यदि कोई नहीं जीता है, तो 'D' दें।
• ↑: इनमें से एक मैट्रिक्स बनाएं ताकि वे प्रत्येक एक अलग पंक्ति में प्रदर्शित हों।

Answer 5

अजगर अनगढ़

from itertools import*
r=range
W=[[0,1,2],[3,4,5],[6,7,8],[0,3,6],[1,4,7],[2,5,8],[0,4,8],[2,4,6]]
def c(B):
    for i in r(8):
                if B[W[i][0]]==B[W[i][1]]==B[W[i][2]]:
                        return 1
        return 0

for i in permutations('012345678',9):
    B=[]
    for j in r(9):
        B.append(-(j+1))
    k=0
    F=1
    for j in r(9):
        k=[1,0][k]
        B[int(i[j])]=k
        if c(B):
            F=0
            break
    print "".join(i),':',[['0','X'][k],'D'][F]

Comments

आपको दूसरे permutations

— पैराम की

कृपया अपने कार्यक्रम को गोल्फ दें।

— mbomb007

Answer 6

C ++ Ungolfed

#include<iostream>
using namespace std;
#include<algorithm>

int check(int B[])
{
        for (int i=0;i<3;i++)
                if ((B[3*i]==B[3*i+1]&&B[3*i]==B[3*i+2]) || (B[i]==B[i+3]&&B[i]==B[i+6]))
                        return 1;
        if ((B[2]==B[4]&&B[2]==B[6]) || (B[0]==B[4]&&B[0]==B[8]))
                return 1;
        return 0;               
}
int main()
{
        char c[11]="012345678";
        int B[9],i,j;
        do{
                for (i=0;i<9;i++)B[i]=-(i+1);
                for (i=0,j=1;i<9;i++,j=j?0:1)
                {
                        B[c[i]-'0']=j;
                        if (check(B))
                                break;
                }
                printf("%s:%c\n",c,i<9?j?'X':'O':'D');
        }while (next_permutation(c,c+9));
}

Comments

कृपया अपने कार्यक्रम को गोल्फ दें।

— mbomb007

Answer 7

पायथन 2.7 (237)

from itertools import*
for z in permutations('012345678'):
 k,F=0,[9]*9
 for h in z:
    F[int(h)]=k=1-k
    if any(sum(a)in(0,3)for a in(F[:3],F[3:6],F[6:],F[::3],F[1::3],F[2::3],F[::4],F[2:8:2])):break
 else:k=2
 print"".join(z)+':','OXD'[k]