क्या आप तीन पुरुषों की मोरिस में दो और चालों से जीत सकते हैं?

Question

bounties

नंबर 1 ( सम्मानित )

मैं पहले वैध जवाब के लिए 50 प्रतिनिधि में फेंक दूंगा

नंबर 2 ( सम्मानित )

मैं सबसे कम वैध जवाब के लिए एक और 100 प्रतिनिधि में फेंक दूंगा।

नंबर 3 ( प्रस्तुतियाँ के लिए खुला )

मैं एक महत्वपूर्ण छोटे वैध जवाब के साथ पहले एक के लिए 200 प्रतिनिधि में फेंक दूंगा। वर्तमान में सबसे कम उत्तर में 45% ( 564 बाइट्स x 0.45 = अधिकतम 254 बाइट्स ) महत्वपूर्ण है।

---

खेल

आपको क्लासिक खेल " नौ पुरुषों की मॉरिस " या बस " मिल " याद है? थ्री मेन्स मॉरिस नाम की भिन्नता है जो एक उत्परिवर्ती टिक-टैक-टो की तरह थोड़ी है।

नियम

यह खेल का खाली बोर्ड है:

   a   b   c
1 [ ]–[ ]–[ ]
   | \ | / |
2 [ ]–[ ]–[ ]
   | / | \ |
3 [ ]–[ ]–[ ]

[ ]एक क्षेत्र है और |–/\उन क्षेत्रों के बीच मार्गों का प्रतिनिधित्व करता है।

खेल दो खिलाड़ियों द्वारा खेला जाता है 1और 2जो बोर्ड पर प्रत्येक जगह 3 टोकन रखते हैं। यह वास्तव में पहले से ही हुआ है और हम खेल में हैं। यदि एक खिलाड़ी millखिलाड़ी के 3 टोकन की एक ऊर्ध्वाधर या क्षैतिज पंक्ति बना सकता है, तो यह गेम जीता जाता है।

टोकन को इस नियम के अनुसार, कनेक्टिंग लाइनों के साथ बोर्ड पर ले जाया जा सकता है:

किसी भी आसन्न खाली स्थिति के लिए (यानी एक किनारे की स्थिति से केंद्र के लिए, या केंद्र से एक किनारे की स्थिति के लिए, या एक किनारे की स्थिति से एक आसन्न किनारे की स्थिति के लिए)

एक खिलाड़ी को एक चाल चलनी चाहिए जब तक कि कोई आसन्न खाली स्थिति न हो, जिस स्थिति में यह कदम छोड़ दिया जाता है।

चुनौती

आप खिलाड़ी हैं 1और आपकी चाल अगली है। एक कार्यक्रम या एक समारोह लिखें, जो निर्धारित करता है:

• आप 2 या उससे कम चालों ( निश्चित जीत ) के साथ एक जीत को मजबूर कर सकते हैं
• यदि आपका प्रतिद्वंद्वी गलती करता है ( संभावित जीत ) , तो आप 2 या उससे कम चालों से जीत सकते हैं
• आप 2 या उससे कम चालों से नहीं जीत सकते, क्योंकि आपको अधिक चालों की आवश्यकता होगी या क्योंकि मजबूर चालों से आपके प्रतिद्वंद्वी को जीत हासिल होगी ( जीतने के लिए असंभव )

आवश्यकताएँ

• भले ही आप निश्चित रूप से जीत जाते हैं जब आप अपने प्रतिद्वंद्वी को मौत के घाट उतार देते हैं, तो आपका कार्यक्रम निश्चित समय पर समाप्त होना चाहिए।
• आप एक कार्यक्रम या एक समारोह लिख सकते हैं।

इनपुट

खिलाड़ियों द्वारा प्रतिनिधित्व किया जाता है 1और 2। 0एक मुक्त क्षेत्र को परिभाषित करता है। आप एक मैट्रिक्स या एक सरणी के रूप में इनपुट ले सकते हैं।

निश्चित

A         B         C         D
2 1 0  |  2 1 0  |  1 0 1  |  1 2 2
2 1 2  |  0 1 0  |  1 0 2  |  2 1 O
0 0 1  |  2 2 1  |  0 2 2  |  O O 1

A: [2,1,0,2,1,2,0,0,1]
B: [2,1,0,0,1,0,2,2,1]
C: [1,0,1,1,0,2,0,2,2]
D: [1,2,2,2,1,0,0,0,1]

मुमकिन

A         B         C
1 0 1  |  1 0 1  |  1 2 2
1 2 2  |  1 2 0  |  0 0 1
2 0 0  |  2 0 2  |  2 1 0

A: [1,0,1,1,2,2,2,0,0]
B: [1,0,1,1,2,0,2,0,2]
C: [1,2,2,0,0,1,2,1,0]

असंभव

A         B    
1 0 0  |  1 2 0
1 2 2  |  2 1 0
2 0 1  |  1 2 0

A: [1,0,0,1,2,2,2,0,1]
B: [1,2,0,2,1,0,1,2,0]

उत्पादन

आपके प्रोग्राम को एक स्माइली आउटपुट / वापस करना चाहिए:

• निश्चित जीत: :)
• संभावित जीत: :|
• जीतने के लिए असंभव: :(

उदाहरण

दो चालों में निश्चित जीत:

[2][1][ ] 1. [2][1][ ]
[2][1][2] -> [2][1][2]
[ ][ ][1]    [ ][1][ ]

[2][1][ ] 1. [2][1][ ]    [ ][1][ ] 2. [ ][ ][1]
[ ][1][ ] -> [ ][ ][1] -> [2][ ][1] -> [2][ ][1]
[2][2][1]    [2][2][1]    [2][2][1]    [2][2][1]

[1][ ][1] 1. [ ][1][1]    [ ][1][1] 2. [1][1][1]
[1][ ][2] -> [1][ ][2] -> [1][ ][2] -> [ ][ ][2]
[ ][2][2]    [ ][2][2]    [2][ ][2]    [2][ ][2]

दो चालों में संभावित जीत:

[1][ ][1] 1. [ ][1][1]    [ ][1][1] 2. [1][1][1]
[1][2][ ] -> [1][2][ ] -> [1][2][2] -> [ ][2][2]
[2][ ][2]    [2][ ][2]    [2][ ][ ]    [2][ ][ ]

[1][ ][1] 1. [ ][1][1]    [ ][1][1] 2. [1][1][1]
[1][2][ ] -> [1][2][ ] -> [1][2][2] -> [ ][2][2]
[2][ ][2]    [2][ ][2]    [2][ ][ ]    [2][ ][ ]

[1][2][2] 1. [ ][2][2]    [2][ ][2] 2. [1][2][2]
[ ][ ][1] -> [1][ ][1] -> [1][ ][1] -> [1][1][1]
[2][1][ ]    [2][1][ ]    [2][1][ ]    [2][ ][ ]

दो चालों में जीतना असंभव:

[1][ ][ ]
[1][2][2]
[2][ ][1]

बक्शीश

यदि एक निश्चित जीत संभव है और आपका कार्यक्रम सफलता के लिए एक तरह से a1:a2(1 चाल) या a1:a2,a3:b2(2 चाल) की चाल को आउटपुट करता है , तो आप अपनी बाइट की गिनती का 30% निकाल सकते हैं ।

---

यह कोड गोल्फ है - बाइट्स जीत में इतना कम जवाब। मानक खामियों को अस्वीकार कर दिया जाता है।

---

_{पीटर टेलर का धन्यवाद जिन्होंने सैंडबॉक्स में कुछ खामियों और सुधार को बेहतर बनाया ।}

Comments

संबंधित ।

— १०:३० पर निवसुर्नमेर्इ

मैं उन

— असि

यदि कोई खिलाड़ी स्थानांतरित करने में असमर्थ है तो क्या होगा? जैसे [1,0,0,2,1,0,2,2,1], खिलाड़ी 2 नहीं चल सकता - क्या यह खिलाड़ी 1 के लिए जीत है?

— विजुअलमेल

@LeifWillerts मैं गलत समझ सकता हूं कि आपका क्या मतलब है, लेकिन उस स्थिति में, कोई भी खिलाड़ी जीतने की स्थिति में नहीं है - वे केवल एक क्षैतिज या ऊर्ध्वाधर रेखा (विकर्ण नहीं) होने से जीतते हैं।

— विजुअलमेल

खैर, केवल 1680 वैध बोर्ड स्थान हैं, इसलिए हार्डकोडिंग 210 बाइट्स से थोड़ा अधिक दे सकता है। (कम अगर समरूपता माना जाता है)

— lirtosiast

Answer 1

हास्केल, 580 564 441 बाइट्स

यह कितनी दूर है मैं इसे अभी के लिए गोल्फ कर सकता हूं। यकीन नहीं होता कि दूसरी भाषाएं इसे हरा सकती हैं।

mजैसे सूचियों की सूची पर कॉल करें [[2,1,0],[2,1,2],[0,0,1]](निश्चित ए)।

import Data.Array
r=[0..2]
p?f=[(x,y)|x<-r,y<-r,f!y!x==p]
p%f=all(==x)xs||all(==y)ys where(x:xs,y:ys)=unzip$p?f
s p x y f=f//[(y,f!y//[(x,p)])]
p#f=[s 0 x y$s p u v f|a@(x,y)<-p?f,b@(u,v)<-0?f,((x-u)*(y-v)==0&&abs(x+y-u-v)==1)||elem(1,1)[a,b]]
p&f|p#f>[]=p#f|0<1=[f]
e=any
i a p f=e(a$e(p%))(map(map(p&))(map((3-p)&)$p&f))||e(p%)(p&f)
l=listArray(0,2)
f(True,_)=":)"
f(False,True)=":|"
f _=":("
m=putStrLn.f.(\f->(i all 1 f,i e 1 f)).l.map l

टेस्ट कोड:

da = [[2,1,0],[2,1,2],[0,0,1]]
db = [[2,1,0],[0,1,0],[2,2,1]]
dc = [[1,0,1],[1,0,2],[0,2,2]]
dd = [[1,2,2],[2,1,0],[0,0,1]]
pa = [[1,0,1],[1,2,2],[2,0,0]]
pb = [[1,0,1],[1,2,0],[2,0,2]]
pc = [[1,2,2],[0,0,1],[2,1,0]]
ia = [[1,0,0],[1,2,2],[2,0,1]]
ib = [[1,2,0],[2,1,0],[1,2,0]]
al = [da,db,dc,dd,pa,pb,pc,ia,ib]

mapM_ m al रिटर्न:

:)
:)
:)
:)
:|
:|
:|
:(
:(

Comments

सही है, मुझे लगता है। शाम को

— डबलचेक

Answer 2

सी # - 739 663 बाइट्स

पूरा कार्यक्रम, argv से इनपुट पढ़ता है, और काम करने के लिए प्रकट होता है। इसे वैसे ही चलाएं

ThreeMill 1 2 1 1 2 0 0 0 2

यदि इनपुट का यह तरीका अस्वीकार्य है, तो मुझे इसे बदलने में खुशी होगी (argv का उपयोग करना पसंद नहीं है)।

using System;using System.Linq;class P{static void Main(string[]A){var I=new[]{0,3,6,1,4,7,2,5,8};Func<string[],string>J=S=>S[0]+S[1]+S[2]+" "+S[3]+S[4]+S[5]+" "+S[6]+S[7]+S[8]+" ";Func<string[],string,int>W=(B,p)=>(J(B)+J(I.Select(i=>B[i]).ToArray())).Contains(p+p+p)?1:0;Func<string[],string,string[][]>V=(B,p)=>I.SelectMany(a=>I.Where(b=>a!=b&B[a]==p&B[b]=="0"&(a==4|b==4|a-b==3|b-a==3|((a-b==1|b-a==1)&a/3==b/3))).Select(b=>{var N=(string[])B.Clone();N[b]=p;N[a]="0";return N;})).DefaultIfEmpty(B).ToArray();int h,G;Console.WriteLine(":"+"(|))"[V(A,"1").Max(z=>((h=0)<(G=V(z,"2").Sum(j=>V(j,"1").Max(q=>W(q,"1")-W(q,"2"))+h++*0))?1:0)+(h>G?W(z,"1")*2:2))]);}}

मुझे कल यह पोस्ट करने के लिए विघटित कर दिया गया था, क्योंकि मैं इसे बहुत नीचे नहीं कर पाया हूं (यह सब बहुत समय नहीं था, और मैं अभ्यास से बाहर हो सकता हूं), लेकिन चूंकि अभी तक कोई प्रतिक्रिया नहीं हुई है, इसलिए मैं ' मैं इसे वैसे भी पोस्ट करूँगा, मैं निश्चित रूप से इनाम की उम्मीद नहीं करता, मैं यह किसी ऐसे व्यक्ति के पास गया जिसने पोस्ट करने से पहले उनके प्रयासों में थोड़ा और प्रयास किया है!

संपादित करें: सभी बूलों को ints के साथ बदल दिया, जिसका मतलब था कि मैं Linq का बेहतर उपयोग कर सकता हूं, और बड़ी बचत देते हुए, दोनों फॉरेक्स लूप्स को गिराने में कामयाब रहा। मैं थोड़ा चकित हूं कि hकाउंटर काम करता है ... ++ ऐसी एक सूक्ष्म उपयोगिता है।

कार्यक्रम बहुत सरल है, यह बस हर संभव कदम की खोज करता है (एक स्ट्रिंग [] में बोर्ड राज्य को संग्रहीत करता है)। यह हमारी सभी संभावित चालों (इसके बाद आने वाले बोर्ड) पर पुनरावृत्ति करता है, और हमारे प्रतिद्वंद्वी द्वारा प्रतिक्रियाओं की संख्या को गिनाता है कि हम सफल ( G) जीत सकते हैं (यानी जो हम जीतते हैं, और वह नहीं करता है)। यह भी संभावित प्रतिक्रियाओं की संख्या मायने रखता है (h)। यदि हम कोई भी जीत सकते हैं, तो यह संभव है, और हम योग में 1 जोड़ते हैं, अगर हम उन सभी को जीत सकते हैं, तो यह निश्चित है, और हम योग में 2 जोड़ते हैं। अधिकतम कुछ इसलिए हमारा सबसे अच्छा संभव परिणाम है, और हम उपयुक्त चेहरे को वापस करने के लिए "(|)) स्ट्रिंग में अनुक्रमित करते हैं।" ध्यान दें कि हमें अतिरिक्त ") की आवश्यकता है" क्योंकि योग 2 या 3 हो सकता है यदि यह एक निश्चित है (यह संभव है कि हम पहले से ही जीते गए किसी भी प्रतिक्रिया को हरा पाने में सक्षम नहीं दिखते हैं, इसलिए संभव जांच है एक बालक भ्रामक)।

कार्यक्रम बोर्ड से एक स्ट्रिंग का उत्पादन करके एक जीत की जाँच करता है, जो कि अंतरिक्ष से अलग की गई पंक्तियाँ और कॉलम हैं, और इस स्ट्रिंग में खिलाड़ी के चरित्र के 3 में से एक स्ट्रिंग के लिए लगता है (उदाहरण के लिए "201 201 201 021 220 002 111" एक है) हमारे लिए जीत)

using System;
using System.Linq; // all important

class P
{
    static void Main(string[]A) // transform to int?
    {
        var I=new[]{0,3,6,1,4,7,2,5,8}; // vertical indexes
        Func<string[],string>J=S=>S[0]+S[1]+S[2]+" "+S[3]+S[4]+S[5]+" "+S[6]+S[7]+S[8]+" "; // joins the strings up, so that there is a space separating each group of three (including at end)
        Func<string[],string,int>W=(B,p)=>(J(B)+J(I.Select(i=>B[i]).ToArray())).Contains(p+p+p)?1:0; // checks if a particular player wins
        Func<string[],string,string[][]>V=(B,p)=>I.SelectMany(a=>I // for each imagineable move
            .Where(b=>a!=b&B[a]==p&B[b]=="0"&(a==4|b==4|a-b==3|b-a==3|((a-b==1|b-a==1)&a/3==b/3))) // where it's legal
            .Select(b=>{var N=(string[])B.Clone();N[b]=p;N[a]="0";return N;}) // select the resulting board
        ).DefaultIfEmpty(B) // allow not-moving
        .ToArray();

        int h, // h stores the number of responses the opponent has to each move
        G; // G stores the number of responses by the opponent we can beat

        Console.WriteLine(":"+"(|))"[ // we index into this to decide which smiley
            V(A,"1").Max(z=>
                    ((h=0)<(G=V(z,"2").Sum(j=>V(j,"1").Max(q=>W(q,"1")-W(q,"2"))+h++*0))?1:0) // if there is atleast 1 reponse by the opponent we can beat, we can possibly win
                    +(h>G?W(z,"1")*2:2) // if there are moves which we can't win, then if we have already won (one-move), else, we can definitely win
                   ) // sum is therefore 0 if impossible, 1 if possible, >2 (no more than 3) if definite 
            ]);

    }
}

यहाँ मेरा परीक्षण स्क्रिप्ट है:

ThreeMill 2 1 0 2 1 2 0 0 1
ThreeMill 2 1 0 0 1 0 2 2 1
ThreeMill 1 0 1 1 0 2 0 2 2
ThreeMill 1 2 2 2 1 0 0 0 1

ThreeMill 1 0 1 1 2 2 2 0 0
ThreeMill 1 0 1 1 2 0 2 0 2
ThreeMill 1 2 2 0 0 1 2 1 0

ThreeMill 1 0 0 1 2 2 2 0 1
ThreeMill 1 2 1 1 2 0 0 0 2
ThreeMill 1 0 1 2 0 2 1 0 2

जो आउटपुट देता है

:)
:)
:)
:)
:|
:|
:|
:(
:|
:)

Comments

अच्छा लगा। पहला होने के लिए धन्यवाद। :) अगर यह ठीक है, तो मैं सप्ताहांत के बाद इनाम को पुरस्कार दूंगा, इसे विशेष रुप से टैब में कुछ और दिन रखने के लिए।

— सम्मिलित

@insertusernamehere मेरे द्वारा ठीक है, अगर मुझे किसी भी वास्तविक काम को करने के लिए परेशान नहीं किया जा सकता है, तो मैं कल इस पर कुछ और काम कर सकता हूं।

— विजुअलमेल नॉन

यह मुझे इस टिप्पणी की याद दिलाता है: " मैं एक मिनट के लिए एक प्रश्न का उत्तर देने में सक्षम नहीं हूं। यह महत्वपूर्ण है! बस डेटाबेस विवरण भेजें और मैं एसक्यूएल अपने उत्तर डालूंगा। मेरे पास बचने के लिए बहुत काम है और कोई कारण नहीं है। इससे बचने के लिए !! " स्टैक ओवरफ्लो काम क्यों नहीं कर रहा है?" । :)

— insertusernamehere

Answer 3

पॉवरशेल 576 550 बाइट्स

मैं इतनी आसानी से हतोत्साहित नहीं होऊंगा - अगर मुझे 631 बाइट्स के नीचे # नहीं मिल सकता है, तो मुझे इसके बजाय एक अलग भाषा का उपयोग करना होगा! मैं उम्मीद कर रहा हूं कि लीफ विलर्ट्स अपने जवाब से 5 बाइट्स मारेंगे, क्योंकि मैंने फैसला किया है कि मैं पावरशेल का ज्यादा शौकीन नहीं हूं, हो सकता है कि मैं इसे बाइट काउंट्स के लिहाज से निष्पक्ष रूप से देखूं ...

यह एक स्क्रिप्ट है, आप इसे चलाते हैं . .\mill.ps1 "201102021"। यह बहुत अच्छी तरह से मेरे C # उत्तर की एक प्रति है, केवल उस भाषा में जिसके साथ मुझे बहुत कम अनुभव है। मैंने इसे गोल्फ के लिए बहुत अधिक प्रयास नहीं किया है, क्योंकि पहली बार काम करने में इतना लंबा समय लग गया है, और पहले से ही काफी कॉम्पैक्ट है।

संपादित करें: बस उन [Math]::Floorकॉल को वहां नहीं छोड़ सकता

param($U);$I=0,3,6,1,4,7,2,5,8;function J($S){($S[0..2]+" "+$S[3..5]+" "+$S[6..8]-join"").Contains($p*3)}function W($D,$p){(J $D)-or(J $D[$I])}function V($Q,$C){$I|%{$a=$_;$I|?{$a-ne$_-and$Q[$a]-eq$c-and$Q[$_]-eq"0"-and($a-eq4-or$_-eq4-or$a-$_-eq3-or$_-$a-eq3-or(($a-$_-eq1-or$_-$a-eq1)-and$a/3-$a%3/3-eq$_/3-$_%3/3))}|%{$b=$Q[0..8];$b[$_]=$c;$b[$a]=0;$b-join''}}|%{$n=1}{$n=0;$_}{if($n){$Q}}}$e=$f=0;V $U "1"|%{$h=0;$x=$_;V $x "2"|%{$k=0;(V $_ "1"|%{if((W $_ "1")-and!(W $_ "2")){$k=$e=1}});$h+=1-$k};if($h-eq0-or(W $x "1")){$f=2}};":"+"(|))"[$e+$f]

यदि आप इसका वर्णन करते हैं कि यह कैसे काम करता है ... C # उत्तर आपके लिए है, लेकिन उम्मीद है कि टिप्पणियां पर्याप्त रूप से स्पष्ट करती हैं। अर्धविराम एकल-पंक्ति कमांड के साथ पूरी तरह से मेल नहीं खा सकते हैं, मुझे अभी तक यकीन नहीं है कि वे कहाँ हैं और आवश्यक नहीं हैं, और जब मैंने पूरी चीज को एक पंक्ति में रखा तो उन्हें वापस कॉपी नहीं किया।

param($U); # take input as argument

$I=0,3,6,1,4,7,2,5,8; # cols

function J($S){ # checks if this is a winning string
($S[0..2]+" "+$S[3..5]+" "+$S[6..8]-join"").Contains($p*3)}

function W($D,$p){ # checks if this is a winning board
(J $D)-or(J $D[$I])} # $D[$I] reorganises into columns

function V($Q,$C){ # yields all valid moves from position $Q for player $C
$I|%{$a=$_;$I| # for each possible move
?{$a-ne$_-and$Q[$a]-eq$c-and$Q[$_]-eq"0"-and($a-eq4-or$_-eq4-or$a-$_-eq3-or$_-$a-eq3-or(($a-$_-eq1-or$_-$a-eq1)-and$a/3-$a%3/3-eq$_/3-$_%3/3))}| # where legal
%{$b=$Q[0..8];$b[$_]=$c;$b[$a]=0;$b-join''}}| # make the move (copy $Q to an array, modify, join into a string)
%{$n=1}{$n=0;$_}{if($n){$Q}}} # if empty, return $Q - I am confident this can be achieved with commas, and [0], and maybe a +, but I don't want to think about it

$e=$f=0; # possible, definite

V $U "1"|%{ # for all our possible moves
$h=0;$x=$_; # $k is whether we win all of these
  V $x "2"| # for all opponent's responses
  %{$k=0;(V $_ "1"| # for all our responses
  %{if((W $_ "1")-and!(W $_ "2")){$k=$e=1}});$h+=1-$k}; # if we can win and he can't, then things are looking good, set $e to 1 (possible win)

  if($h-eq0-or(W $x "1")){$f=2} # if we win every move, or we have already won, it's a definite
};

":"+"(|))"[$e+$f] # smile, it's all over

टेस्ट स्क्रिप्ट (पॉवरशेल):

. .\mill.ps1 "210212001"
. .\mill.ps1 "210010221"
. .\mill.ps1 "101102022"
. .\mill.ps1 "122210001"

. .\mill.ps1 "101122200"
. .\mill.ps1 "101120202"
. .\mill.ps1 "122001210"

. .\mill.ps1 "100122201"
. .\mill.ps1 "121120002"
. .\mill.ps1 "101202102"

. .\mill.ps1 "100122201"
. .\mill.ps1 "120210120"

इसका आउटपुट:

:)
:)
:)
:)
:|
:|
:|
:(
:|
:)
:(
:(

Answer 4

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

मुझे यह देखना होगा कि क्या मैं इसे और नीचे ले जा सकता हूं, या अगर मुझे 30% बोनस मिल सकता है, लेकिन बहुत शिथिलता के बाद, यहाँ मेरा जवाब है।

def t(g,x=1,r=0,z=0):
 m=[[1,3,4],[0,2,4],[2,4,5],[0,4,6],[0,1,2,3,5,6,7,8],[2,4,8],[3,4,7],[4,6,8],[4,5,7]];a=[[0,1,2],[3,4,5],[6,7,8],[0,3,6],[1,4,7],[2,5,8],[0,4,8],[2,4,6]];z=z or[[],[],[],[]];s=0
 if r>3:return z
 for i in a:
  if g[i[0]]==g[i[1]]==g[i[2]]>0:s=g[i[0]];break
 z[r]+=s,
 for q in range(9):
  i=g[q]
  if i==x:
   for p in m[q]:
    if g[p]<1:n=g[:];n[q],n[p]=n[p],n[q];z=t(n,3-x,r+1,z)
 if r:return z
 else:
  w=l=0
  for j in range(4):w=w or 1in z[j];l=l or 2in z[j]
  if l<1and w:return":)"
  elif w<1and l:return":("
  else:return":|"

Ungolfed:

def three_mens_morris(grid, player=1, rec=0, w_l=0, p=0):
    moves = [[1,3,4],[0,2,4],[2,4,5],[0,4,6],[0,1,2,3,5,6,7,8],[2,4,8],[3,4,7],[4,6,8],[4,5,7]]
    w_l = w_l or [[],[],[],[]]
    if rec == 4: return w_l
    result = check_grid(grid)
    w_l[rec].append(result)
    for sq_1 in range(len(grid)):
        piece = grid[sq_1]
        if piece == player:
            for sq_2 in moves[sq_1]:
                if grid[sq_2] == 0:
                    new_grid = grid.copy()
                    new_grid[sq_1],new_grid[sq_2]=new_grid[sq_2],new_grid[sq_1]
                    w_l = three_mens_morris(new_grid,3-player,rec+1,w_l)
    if p: print(w_l)
    if rec:
        return w_l
    else:
        win = loss = 0
        for i in range(4):
            if 1 in w_l[i]:
                win = 1
            elif 2 in w_l[i]:
                loss = 1
        if p:print(win,loss)
        if loss==0 and win:
            return ":)"
        elif loss and win==0:
            return ":("
        else:
            return ":|"

def check_grid(grid):
    rows = [[0,1,2],[3,4,5],[6,7,8],[0,3,6],[1,4,7],[2,5,8],[0,4,8],[2,4,6]]
    for i in rows:
        if grid[i[0]]==grid[i[1]]==grid[i[2]] and grid[i[0]]:
            return grid[i[0]]
    return 0