থ্রি মেনস মরিসে আপনি আরও দুটি চাল নিয়ে জিততে পারবেন?

Question

অনুগ্রহ

নং 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 বা তার চেয়ে কম চাল দিয়ে জিততে পারবেন না, কারণ আপনার আরও চালচলনের প্রয়োজন হবে বা জোর করে চালানো আপনার প্রতিপক্ষকে জয়ের দিকে নিয়ে যায় (জিততে অসম্ভব )

আবশ্যকতা

• যদিও আপনি অবশ্যই আপনার প্রতিপক্ষকে মৃত্যুর কাছে নিয়ে যাওয়ার সময় অবশ্যই জিতে গেছেন, আপনার প্রোগ্রাম অবশ্যই সীমাবদ্ধ সময়ে শেষ করবে।
• আপনি একটি প্রোগ্রাম বা একটি ফাংশন লিখতে পারেন।

ইনপুট

খেলোয়াড়দের দ্বারা প্রতিনিধিত্ব করা হয় 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

সম্পর্কিত ।

— insertusernamehere

আমি সেই

— আসকি

কোনও খেলোয়াড় নড়তে না পারলে কী ঘটে? যেমন [1,0,0,2,1,0,2,2,1], প্লেয়ার 2 চলাচল করতে পারে না - এটি কি প্লেয়ার 1 এর জন্য একটি জয়?

— ভিজুয়ালমেলন

@ লিফওয়িলার্টস আপনার অর্থ বলতে আমি ভুল বোঝাবুঝি হতে পারি, তবে সেই ক্ষেত্রে কোনও খেলোয়াড়ই বিজয়ী অবস্থায় নেই - তারা কেবল একটি অনুভূমিক বা উল্লম্ব রেখার (তির্যক নয়) জিতে জয়লাভ করে।

— ভিজুয়ালমেলন

ঠিক আছে, কেবলমাত্র 1680 টি বৈধ বোর্ড পজিশন রয়েছে, তাই হার্ডকোডিং 210 বাইটের বেশি দিতে পারে। (যদি প্রতিসাম্য বিবেচনা করা হয় তবে কম)

— lirtosiast

Answer 1

হাস্কেল, 580 564 441 বাইট

এই মুহূর্তে আমি এটি কতদূর গল্ফ করতে পারি। অন্যান্য ভাষা এটি মারতে পারে কিনা তা নিশ্চিত নয় Not

(ডিফিনেট এ) এর 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 বাইট

সম্পূর্ণ প্রোগ্রাম, আরজিভি থেকে ইনপুট পড়ে এবং কাজ করে বলে মনে হয়। এটি চালান

ThreeMill 1 2 1 1 2 0 0 0 2

যদি এই ইনপুট পদ্ধতিটি গ্রহণযোগ্য না হয় তবে আমি এটি পরিবর্তন করে খুশি হব (কখনই আরআরভি ব্যবহার করা পছন্দ করবে না)।

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))]);}}

আমি গতকাল এটি পোস্ট করতে আগ্রহী ছিলাম, কারণ আমি এটিকে খুব বেশি গল্ফ করতে সক্ষম হইনি (এতটা সময় ছিল না এবং আমি অনুশীলনের বাইরে থাকতে পারি), তবে যেহেতু এখনও কোনও প্রতিক্রিয়া আসেনি, আমি ' এটি যাইহোক পোস্ট করুন, আমি অবশ্যই অনুগ্রহের আশা করি না, আমি বরং এটি এমন কাউকে গিয়েছিলাম যিনি পোস্ট করার আগে তাদের আরও কিছুটা চেষ্টা করেছেন!

সম্পাদনা করুন: সমস্ত কুলকে ইনট দিয়ে প্রতিস্থাপন করা হয়েছিল, যার অর্থ আমি লিনককে আরও ভালভাবে ব্যবহার করতে পারি এবং বড় সঞ্চয় দিয়ে উভয় ফোরচ লুপগুলি ভেঙে ফেলতে সক্ষম হয়েছি। আমি সামান্য বিস্মিত হয়েছি যে hকাউন্টারটি কাজ করে ... ++ এমন একটি সূক্ষ্ম ইউটিলিটি।

প্রোগ্রামটি খুব সহজ, এটি প্রতিটি চলার প্রতিটি সেটকে সন্ধান করে (বোর্ড স্ট্রিং স্ট্রিংয়ে [] স্ট্রিং করে)। এটি আমাদের সম্ভাব্য সমস্ত পদক্ষেপের (তার ফলস্বরূপ বোর্ডগুলি) পুনরাবৃত্তি করে এবং আমাদের প্রতিপক্ষের প্রতিক্রিয়ার সংখ্যাকে গণনা করে যে আমরা সফলভাবে পরাজিত করতে পারি ( G) (আমরা যা জিতেছি, এবং সে পায় না)। এটি সম্ভাব্য প্রতিক্রিয়ার সংখ্যাও গণনা করে (h)। যদি আমরা যে কোনওটি জয় করতে পারি, তবে এটি একটি সম্ভাব্য, এবং আমরা যোগফলকে 1 যোগ করি, যদি আমরা সেগুলি সমস্তকেই জিততে পারি তবে এটি একটি সুনির্দিষ্ট, এবং আমরা যোগফলকে 2 যোগ করি। সর্বাধিক কিছু হ'ল আমাদের সেরা সম্ভাব্য ফলাফল এবং উপযুক্ত মুখটি ফিরিয়ে আনার জন্য আমরা "(|))" স্ট্রিংয়ে সূচি পাঠাই। নোট করুন যে আমাদের অতিরিক্ত প্রয়োজন ")" কারণ এটি যদি একটি নির্দিষ্ট থাকে তবে যোগফল 2 বা 3 হতে পারে (এটি সম্ভবত সম্ভব যে আমরা ইতিমধ্যে প্রথম দিকে জয়লাভ করে যে কোনও প্রতিক্রিয়াগুলি পরাজিত করতে সক্ষম হই না বলে সম্ভাব্য চেকটি হয় একটি বাচ্চা বিভ্রান্তিমূলক)।

প্রোগ্রামটি বোর্ড থেকে একটি স্ট্রিং তৈরি করে বিজয়ের জন্য পরীক্ষা করে, এটি স্পেস-বিভাজিত সারি এবং কলাম এবং এই স্ট্রিংটিতে প্লেয়ারের চরিত্রের কেবল 3 টি স্ট্রিং সন্ধান করে (যেমন "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

খুশী হলাম। প্রথম হওয়ার জন্য ধন্যবাদ। :) যদি ঠিক থাকে তবে বৈশিষ্ট্যযুক্ত ট্যাবে আরও কয়েক দিন রাখার জন্য আমি উইকএন্ডের পরে অনুদানটি দেব।

— সন্নিবেশকারী নাম এখানে

@ অন্তর্ভুক্তকারীর নামটি এখানে আমার পক্ষে ঠিক আছে, যদি আমি কোনও সত্যিকারের কাজ করতে বিরক্ত না হতে পারি তবে আগামীকালকে এই বিষয়ে আরও কিছু কাজ করতে পারি।

— ভিজুয়ালমেলন

এটি আমাকে এই মন্তব্যে স্মরণ করিয়ে দেয়: " আমি ফরটি মিনিটগুলির জন্য কোনও প্রশ্নের উত্তর দিতে সক্ষম হইনি This এটি সমালোচনামূলক! কেবল ডাটাবেসের বিবরণ প্রেরণ করুন এবং এসকিউএল আমার উত্তরগুলি সন্নিবেশ করবো। এড়াতে আমার এত কাজ আছে এবং কোনও কারণ নেই এটি এড়ানোর জন্য !! " স্ট্যাক ওভারফ্লো কেন কাজ করছে না? । :)

— সন্নিবেশকারী নাম

Answer 3

পাওয়ারশেল 576 550 বাইট

আমার এত সহজে বিঘ্ন হবে না - যদি আমি #৩১ বাইটের নিচে সি # না পাই তবে তার পরিবর্তে আমাকে অন্য একটি ভাষা ব্যবহার করতে হবে! আমি আশা করছি যে লিফ উইলার্টস তার উত্তরটি বন্ধ করে পাঁচটি বাইট ছুঁড়ে ফেলবেন, কারণ আমি সিদ্ধান্ত নিয়েছি যে আমি পাওয়ারশেলের অত্যধিক পছন্দ করি না, সম্ভবত আমার কেবল এটিকে বাইট গুনের দিক থেকে নিখরচায় দেখার প্রয়োজন ...

এটি একটি স্ক্রিপ্ট, আপনি এটি দ্বারা চালিত . .\mill.ps1 "201102021"। এটি খুব ভাল আমার সি # উত্তরটির একটি অনুলিপি, কেবলমাত্র এমন ভাষায় যা আমার খুব কম অভিজ্ঞতা হয়েছে। আমি এটিকে গল্ফ করার জন্য খুব বেশি প্রচেষ্টা করি নি, কারণ প্রথম উদাহরণে কাজ করতে এত বেশি পুষ্প লেগেছে, এবং ইতিমধ্যে সংগতভাবে সংক্ষিপ্ত।

সম্পাদনা: কেবলমাত্র সেই [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]

আপনি কীভাবে এটি কাজ করে তার বিবরণ যদি ... সি # উত্তরটি আপনার জন্য হয় তবে আশা করি মন্তব্যগুলি এটিকে যথেষ্ট পরিস্কার করে দেবে। সেমিকোলনগুলি সিঙ্গল-লাইন কমান্ডের সাথে পুরোপুরি মেলে না, আমি নিশ্চিত না যে তাদের কোথায় প্রয়োজন এবং কোথায় নয় এবং আমি যখন পুরো জিনিসটি এক লাইনে রাখি তখন সেগুলি অনুলিপি করিনি।

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