टिक टीएसी टोरस के इष्टतम खेल

Question

यह चुनौती खेल टिक टीएसी को पैर की अंगुली के बारे में है, लेकिन यह एक टोरस पर खेला जाता है।

कैसे खेलें

आवश्यक गेम बोर्ड बनाने के लिए, आप एक नियमित टिक टीएसी पैर की अंगुली बोर्ड के साथ शुरुआत करते हैं। पहले इसे बाएँ और दाएँ किनारे से जोड़कर एक सिलेंडर में मोड़ो। फिर इसे ऊपर और नीचे के किनारे से जोड़कर टोरस में मोड़ें। इस तरह के गेम बोर्ड का एक सरल दृश्य कुछ चालों (सिक पेंट कौशल!) के साथ खेला जाता है।

एक टोरस पर टिक टीएसी को पैर की अंगुली के नियम नियमित टिक टीएसी को पैर की अंगुली के समान हैं। प्रत्येक खिलाड़ी X और Os को एकांतर स्थान देता है। पंक्ति, स्तंभ या विकर्ण में 3 समान प्रतीकों वाला पहला वाला जीतता है।

चूंकि एक टोरस की कल्पना करना काफी कठिन है, हम बस बोर्ड को एक कागज पर वापस प्रोजेक्ट करते हैं। अब हम नियमित टिक टीएसी को पैर की अंगुली के रूप में खेल खेल सकते हैं। एकमात्र अंतर यह है, कि आप टूटे हुए विकर्ण में 3 समान प्रतीकों के साथ भी जीत सकते हैं। उदाहरण के लिए प्लेयर 1 (X) निम्नलिखित बोर्ड जीतता है। टोरस पर दृश्य को थोड़ा बदलकर आप इसे आसानी से देख सकते हैं।

यदि आपकी रुचि है, तो आप टोरस गेम्स में एक टॉस्क पर टिक टीएसी को पैर की अंगुली खेल सकते हैं । एक विंडोज, मैक और Android संस्करण है।

इष्टतम खेल

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

इष्टतम रणनीति वास्तव में आसान है:

• यदि आप अपना प्रतीक रखकर जीत सकते हैं, तो करें।
• अन्यथा यदि आपके प्रतिद्वंद्वी के पास एक पंक्ति / स्तंभ / ,iagonal में दो प्रतीक हैं, तो उसे ब्लॉक करने का प्रयास करें। अन्यथा, जो आप चाहते हैं वह करें।
• नहीं तो तुम जो चाहते हो।

हर इष्टतम गेम में 7 चालें होती हैं और इन चालों का वर्णन निम्न तरीके से किया जा सकता है:

1. खिलाड़ी 1 बोर्ड पर कहीं भी एक एक्स (9 विकल्प) रखता है
2. खिलाड़ी 2 बोर्ड पर कहीं भी एक ओ (8 विकल्प) रखता है
3. खिलाड़ी 1 बोर्ड पर कहीं भी एक एक्स (7 विकल्प) रखता है
4. प्लेयर 2 की चाल को मजबूर किया जा सकता है (1 विकल्प), यदि नहीं, तो वह ओ को कहीं भी रखता है (6 विकल्प)
5. प्लेयर 1 की चाल मजबूर है (1 पसंद)
6. खिलाड़ी 2 एक कांटे में पकड़ा जाता है (खिलाड़ी 1 दो अलग-अलग तरीकों से जीत सकता है), इसलिए खिलाड़ी 2 को एक तरह से प्लेयर 1 को ब्लॉक करना होगा (2 विकल्प)
7. खिलाड़ी 1 अपनी अंतिम चाल रखता है और जीतता है (1 विकल्प)

हमारे अनुमानित बोर्ड पर 9 * 8 * 1 * 6 * 1 * 2 * 1 + 9 * 8 * 6 * 1 * 1 * 2 * 1 = 1728 विभिन्न इष्टतम खेल हैं। यहाँ आप एक विशिष्ट इष्टतम खेल देख सकते हैं:

यदि हम बोर्ड के प्रत्येक सेल को अंकों के साथ लेबल करते हैं 0-8, तो हम अंकों द्वारा इस खेल का वर्णन कर सकते हैं 3518207। पहले एक X सेल 3 में एक जगह है सेल 3 (मध्य पंक्ति, दायां कॉलम) में सेल 1 (ऊपरी पंक्ति, मध्य स्तंभ) में एक एक्स की तुलना में सेल 3 (मध्य पंक्ति, बाएं स्तंभ) में स्थान है, ...

इस अंक संकेतन का उपयोग करके हमने स्वचालित रूप से एक आदेश उत्पन्न किया। अब हम सभी १ games२ and इष्टतम खेलों को सॉर्ट कर सकते हैं और हमें सूची मिलती है:

Game 0000: 0123845
Game 0001: 0123854
Game 0002: 0124735
Game 0003: 0124753
Game 0004: 0125634
   ...
Game 0674: 3518207
   ...
Game 1000: 5167423
Game 1001: 5167432
Game 1002: 5168304
   ...
Game 1726: 8765034
Game 1727: 8765043

चुनौती

यह सूची आपकी नौकरी का हिस्सा है। आपको k0 और 1727 के बीच एक नंबर प्राप्त होगा और आपको kउस क्रमबद्ध सूची के अंकन में वें गेम को वापस करना होगा ।

एक फ़ंक्शन या एक प्रोग्राम लिखें, जो संख्या प्राप्त करता है k(पूर्णांक) संवाददाता गेम की गणना करता है। आप STDIN, कमांड-लाइन तर्क, प्रॉम्प्ट या फ़ंक्शन तर्क के माध्यम से इनपुट पढ़ सकते हैं और परिणाम (7 अंक) को एक पठनीय प्रारूप (जैसे 0123845या [0, 1, 2, 3, 8, 4, 5]) में प्रिंट कर सकते हैं या इसे एक स्ट्रिंग (मानव पठनीय प्रारूप) या पूर्णांक (सभी युक्त) का उपयोग करके वापस कर सकते हैं आधार 10 में अंक), या किसी भी सरणी / सूची प्रारूप में।

चुनौती का प्रकार कोड-गोल्फ है। इसलिए सबसे छोटा कोड जीतता है।

Comments

खिलाड़ी 2 की पहली चाल खिलाड़ी की पहली चाल के समान पंक्ति या कॉलम में क्यों होती है? मैंने अपने सिर में कुछ गेम खेले हैं जहाँ खिलाड़ी 2 की पहली चाल एक समान विकर्णों में से एक है और वे उसी तरह के उत्कृष्ट पैटर्न पैटर्न का पालन करते हैं। यह मुझे लगता है कि टॉरॉयडल बोर्ड के पहलुओं में से एक यह है कि पंक्तियों, स्तंभों और विकर्णों का खेल पर सममित प्रभाव होता है।

— रनर

@ Runer112 इष्टतम रणनीति को बहुत सरल बनाया। एकमात्र नियम अब आपके प्रतिद्वंद्वी को अवरुद्ध कर सकता है यदि आप कर सकते हैं, अन्यथा आप जो चाहते हैं वह करें।

— जकुबे

बस एक पक्ष की टिप्पणी: वास्तव में यहां बहुत कम अनूठे खेल संभव हैं। अनुवादिक समरूपता पहली चाल की स्थिति को अप्रासंगिक बना देती है (क्योंकि आप हमेशा अपने विचार को केंद्र में रख सकते हैं), इसलिए 9 से विभाजित करें ... और बोर्ड का रोटेशन केवल 2 अलग-अलग दूसरी चाल (विकर्ण या आसन्न वर्ग) के लिए बनाता है ... इसलिए सबसे अलग 48 खेल। यदि आप प्रतिबिंब प्रतिबिंब समरूपता को ध्यान में रखते हैं, तो यह और भी नीचे चला जाता है। यह टोरस संस्करण नियमित की तुलना में बहुत अधिक उबाऊ है। गोल्फ दूर।

— ओरियन

@orion वास्तव में यह तथ्य है कि टोरस लपेटता है, हमें '0' के बारे में सोचने के लिए मना नहीं करता है क्योंकि टोरस बोर्ड पर 'पहले' की परिभाषा है और सामान्य रूप से सभी नौ क्षेत्रों को अलग करती है ... फिर भी हम "मेरिडियन 0" पर ग्रीनविच से सहमत हैं। , जबकि पृथ्वी के विपरीत हम एक पैर उस स्थान पर हो सकते हैं जहां पर यह गुरुवार है, एक पैर बुधवार में है (स्थानीय समय में 24 घंटे!) - और इस तथ्य के बावजूद कि पृथ्वी गोल है और नहीं है एक "प्रारंभिक बिंदु" ...

— pawel.boczarski

@ रोडनी नोप, यह एक है, सात नहीं। इसकी गणना करने का प्रयास करें।

— जकुबे

Answer 1

जावास्क्रिप्ट (ईएस 6), 266 308 317 334 341

एक समारोह एक स्ट्रिंग लौट रहा है। संपादित मिले समारोह एम के लिए एक गणित समाधान (पिछले पर!)

F=(n,x=[],M=(a,b,t=-a-b)=>(a-b)%3?a<3&b<3?3+t:a>5&b>5?21+t:12+t:9+t+a%3*3)=>
[for(a of z='012345678')for(b of z)for(c of z)for(d of z) 
a-b&&c-a&&c-b&&(b-(y=M(a,c))?d==y:d-a&&d-b&&d-c)&&(
f=M(c,e=M(b,d)),g=M(a,e),g<f?[f,g]=[g,f]:0,r=a+b+c+d+e,x.push(r+f+g,r+g+f))]
&&x[n]

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

अधिक पठनीय

F=(n,x=[],
  M=(a,b,t=-a-b)=>(a-b)%3? 
     a<3&b<3?
       3+t // first row
       :a>5&b>5?
          21+t // last row
          :12+t // middle row and diags
     :9+t+a%3*3 // columns
  )=>
  [for(a of z='012345678') // enumerate the first 4 moves
     for(b of z)
       for(c of z)
         for(d of z) 
           a-b&&c-a&&c-b // avoid duplicates
           &&(b-(y=M(a,c))?d==y:d-a&&d-b&&d-c) // and check if d must block a-c or it's free
           &&(
             e=M(b,d), // forced to block b-d
             f=M(c,e),g=M(a,e),g<f?[f,g]=[g,f]:0, // f and g could be in the wrong order
             r=a+b+c+d+e, // start building a return string
             x.push(r+f+g,r+g+f) // store all values in x
  )]&&x[n] // return value at requested position

Answer 2

ऑक्टेव, 467 369 363 309 297 वर्ण

297:

global t=0*(1:9)m=dec2bin([15;113;897;1170;1316;1608;2370;2216;2580])-48 a;
function g(s,p)global a t m;
if nnz(s)<8&&any((t==1)*m>2)a=[a;s];return;end;q=t==3-p;
(r=sort(~q.*(1:9)*m(:,find([3 1]*([q;t==p]*m)==6)')))||(r=find(~t));
for i=r t(i)=p;g([s i+47],3-p);t(i)=0;end;end;g('',1);f=@(n)a(n+1,:);

एकमात्र प्रासंगिक परिवर्तन यह है कि हम कभी भी जांच नहीं करते हैं कि क्या वर्तमान खिलाड़ी जीत सकता है, केवल अगले मोड़ को जीतने के लिए प्रतिद्वंद्वी की संभावना की जांच करें । जैसा कि केवल 1 खिलाड़ी बदल सकता है जीत सकता है 7 वर्ष की है , यह एकमात्र ऐसी जगह है जब एल्गोरिथ्म गेम का उत्पादन करेगा जो इष्टतम नहीं है, लेकिन ऐसी स्थिति को फ़िल्टर करना बहुत आसान है। यदि हम खिलाड़ी 1 से जीत गए हैं तो हम केवल प्रत्येक गेम को सत्यापित करते हैं - यदि यह नहीं था, तो बदले में कदम 7 गलत था, इसलिए हम इस गेम को इष्टतम गेम टेबल में नहीं जोड़ते हैं।

(इस नियम से उत्पन्न आधे खेल झूठे हैं । 7 वें मोड़ में खिलाड़ी 1 में हमेशा खिलाड़ी दो को ब्लॉक करने की दो संभावनाएं होती हैं, लेकिन केवल एक ही उसे तुरंत जीत दिलाएगा)।

उपयोग:

$ octave
octave:1>> source script.m
octave:2>> f(634)
ans = 3270148

असंगठित कोड ऐसा दिखता है:

 global t=0*(1:9);
 global m=dec2bin([15;113;897;1170;1316;1608;2370;2216;2580])-48;
 global allgames;
 allgames=[];

 function r=canbewon(by)
  global t m
  q=[t==by;t==(3-by)]*m;
  g=(find([3 1]*q==6))';
  r=sort((~(t==by).*(1:9)) * m(:,g));
 end

 function games_starting_with(s)
 global allgames t;
 if 7==numel(s) && any((t==1)*m==3) # it's 7th move and first player won
  allgames=[allgames;s];
  return;
 end;
 poss=(find(~t));                  # for now all free slots are possible
 player=1+mod(numel(s),2);
 moves = canbewon(3-player);
 if numel(moves) poss=moves; end;  # ... no, we must block the other player
 for i=poss
  t(i)=player;
  games_starting_with([s char(i+47)]);
  t(i)=0;
 end
end

games_starting_with('');
f=@(n)(allgames(n+1,:));

Comments

छोटे संकेत: आप पुराने संस्करणों को काट सकते हैं यदि वे उसी तर्क का उपयोग करते हैं क्योंकि ये संपादित इतिहास में संग्रहीत हैं, इसलिए वे अभी भी उपलब्ध हैं

— मास्टरएक्स 244