वायथॉफ का निम पूरी तरह से खेलें

Question

आपका लक्ष्य वायथॉफ के निम के खेल के लिए एक आदर्श खिलाड़ी लिखना है ।

वीथॉफ के निम के नियम

वीथॉफ का निम एक नियतात्मक दो-खिलाड़ी खेल है जो समान काउंटरों के दो ढेर के साथ खेला जाता है। खिलाड़ी वैकल्पिक रूप से बदल जाते हैं, जिसमें वे इनमें से एक करते हैं:

1. पहले ढेर से एक या एक से अधिक काउंटर निकालें
2. दूसरे ढेर से एक या अधिक काउंटर निकालें
3. पहले ढेर और दूसरे ढेर दोनों से, समान संख्या में काउंटर (एक या अधिक) निकालें।

बेशक, बवासीर नकारात्मक नहीं जा सकते हैं, लेकिन वे कर सकते हैं। 0. जो भी खिलाड़ी अंतिम काउंटर को हटाता है वह गेम जीतता है।

अधिक ज्यामितीय-दिमाग के लिए, यहाँ खेल का एक समान सूत्रीकरण है जिसे आप इस एप्लेट पर खेल सकते हैं । एक एकल रानी क्वार्टर-अनंत शतरंज के कुछ वर्ग पर शुरू होती है जिसका कोने नीचे-बाएँ में होता है। खिलाड़ी वैकल्पिक रूप से रानी को आगे बढ़ाते हैं, जो शतरंज की रानी की तरह चलती है लेकिन तीन दिशाओं तक सीमित रहती है:

1. नीचे
2. बाएं
3. तिरछे नीचे और बाएँ

जो भी रानी को कोने में ले जाता है वह जीत जाता है।

रानी के निर्देशांक (कोने के साथ (0,0)) को संबंधित बवासीर के आकार से जोड़कर, यह देखना आसान है कि दोनों खेल समान हैं।

सही खेल

(यदि आप सही खेल और जीतने की चाल की धारणाओं से परिचित हों तो आप इसे छोड़ सकते हैं।)

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

एक विजेता रणनीति होने के लिए, यह हमेशा उस खिलाड़ी के लिए एक सैद्धांतिक जीतने की स्थिति में जाने के लिए आगे बढ़ता है, जो सिर्फ स्थानांतरित हो गया है, और इस प्रकार खिलाड़ी आगे नहीं जा रहा है। इनमें से पहली जीत की स्थिति (जिसे ठंडे स्थान भी कहा जाता है ) हैं (0,0), (1,2), (2,1), (3,5), (5,3)। विकिपीडिया लेख देखेंवाइथॉफ की निम के लिए एक जीत की रणनीति खोजने के लिए एक एल्गोरिथ्म की व्याख्या के लिए , साथ ही साथ जीत की स्थिति उत्पन्न करने के लिए एक सूत्र।

कार्यक्रम की आवश्यकताएं

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

यदि कोई जीत की चाल मौजूद नहीं है, यानी, स्थिति एक सैद्धांतिक नुकसान है, तो आपके कार्यक्रम को संकेत देना चाहिए।

आपका कार्यक्रम उचित समय के भीतर चलना चाहिए। तो, एक घातीय पुनरावर्ती गेम ट्री खोज पर्याप्त नहीं होगी। यदि आप किसी रणनीति को कठिन बनाना चाहते हैं, तो यह ठीक है।

इनपुट

(i,j)गैर-ऋणात्मक संख्याओं की एक जोड़ी जो ढेर के आकार का प्रतिनिधित्व करती है, प्रत्येक में सबसे अधिक 99। यह दो नंबर हो सकता है, एक ट्यूपल, एक सूची, या जो भी कंटेनर आप पसंद करते हैं।

उत्पादन

अपनी चाल के बाद स्थिति को प्रिंट करें या आउटपुट करें, फिर से दो नंबर या एक कंटेनर। यह एक जीतने की स्थिति के लिए एक कानूनी कदम होना चाहिए। यदि इस तरह के कई कदम हैं, तो कोई भी ठीक है, लेकिन केवल एक ही है।

यदि कोई जीतने की चाल नहीं है, तो आपको आउटपुट में यह इंगित करना होगा। कोई भी आउटपुट False, जैसे , None0, या (-1,-1)करेगा, जब तक कि यह कानूनी स्थिति नहीं है, और हर खोने वाले इनपुट के लिए समान है।

उदाहरण चलता है

f(5,0)   = (0,0)
f(2,2)   = (1,2)   # Or (2,1) or (0,0) 
f(1,2)   = False
f(13,9)  = (13,8)  # Or (10,6)
f(10,6)  = False
f(5,10)  = (5,3)
f(25,30) = (8,13)    

Comments

+1, आंशिक रूप से क्योंकि मुझे एक चौथाई अनंत का विचार पसंद है।

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

"समय की उचित मात्रा" को परिभाषित करें। क्या कई सेकंड (100,50) समय की उचित मात्रा है?

— जॉन ड्वोरक

ओह। रुको। इनपुट से घिरा है ... 30 ??? यह थोड़ा कम है, है ना?

— जॉन ड्वोरक

@JanDvorak तुम सही हो, यह सस्ते शॉर्टकट की अनुमति दे सकता है। 99 में बदल गया - मुझे लगता है कि पर्याप्त है? पोस्टिंग के बाद एडिटिंग स्पेक्स के लिए माफी।

— xnor

@PeterTaylor धन्यवाद, निश्चित।

— xnor

Answer 1

हास्केल, 167 165 वर्ण

c p=o p:c(o p:p)
o p=[(a,b)|a<-[0..],b<-[0..a],(a,b)?p==[]]!!0
(a,b)?p=[y|y@(c,d)<-p,c==a||c==b||d==b||a+d==b+c]
f x@(a,b)|a<b=f(b,a)|x?c[]!!0==x=(0,-1)|1>0=x?c[]!!0

एल्गोरिथ्म अक्षम है, लेकिन यह अब भी इनपुट के लिए एक सेकंड (हालांकि इंटरैक्टिव कंसोल में नहीं) <100 के भीतर चलता है।

स्पष्टीकरण:

c p=o p:c(o p:p)

पिछले ठंडे पदों का एक सेट दिए गए ठंडे पदों की सूची एक ठंडी स्थिति है जिसके बाद ठंडे पदों की सूची दी गई है और पिछले वाले (अक्षमता: यह स्थिति दो बार उत्पन्न होती है)

o p=[(a,b)|a<-[0..],b<-[0..a],(a,b)?p==[]]!!0

एक ठंडी स्थिति पहली जोड़ी है जैसे कि उस जोड़ी से कोई ठंडी स्थिति नहीं आती है (अक्षमता: हमें इसके बजाय पिछले जोड़े से खोजना चाहिए)

(a,b)?p=[y|y@(c,d)<-p,c==a||c==b||d==b||a+d==b+c]

एक जोड़ी से प्राप्त होने वाली स्थिति ऐसी होती है कि उनका पहला तत्व मैच करता है, उनका दूसरा तत्व मैच करता है, उनका अंतर मैच करता है, या हटाने से पहले छोटा ढेर हटाने के बाद बड़ा ढेर होता है।

f x@(a,b)|a<b=f(b,a)
         |x?c[]!!0==x=(0,-1)
         |1>0=x?c[]!!0

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

Comments

लगता है कि " तो, एक घातीय पुनरावर्ती गेम ट्री खोज पर्याप्त नहीं होगा " आशावादी था, क्योंकि आप जो भी वर्णन करते हैं, वह वास्तव में लगता है।

— पीटर टेलर

@PeterTaylor यह O (n ^ 4) है। प्रत्येक ठंडे जोड़े को खोजने के लिए O (n ^ 3) समय लगता है और उनमें से O (n) होते हैं। पीढ़ी का अनुकूलन इसे O (n ^ 2) में लाएगा (यदि मैं अनुक्रम को सही ढंग से पढ़ूं)। एक घातांक-समय एल्गोरिथ्म बहुत धीमा होगा। क्या मुझे कुछ परीक्षण चलाने चाहिए?

— जॉन ड्वोरक

यह ठीक है, मुझे आप पर विश्वास है।

— पीटर टेलर

आप निकाल सकते हैं x@सेx@(a,b)?p=...

— गर्व haskeller

यकीन नहीं हुआ कि यह वहां कैसे पहुंचा। फिक्सिंग, धन्यवाद।

— जॉन ड्वोरक

Answer 2

GolfScript ( 63 57 बाइट्स)

{\]zip{~-}%0|$(!*,1=}+1,4*{..,,^[(.@,2/+.2$]+}38*2/?0]0=`

रूप में स्टड से इनपुट की अपेक्षा करता है [a b], और आउटपुट को उस रूप में स्टडआउट पर छोड़ देता है या 0यदि यह एक खोने की स्थिति है। ऑनलाइन डेमो

अवलोकन

,4*{..,,^[(.@,2/+.2$]+}38*2/

बीट्टी अनुक्रम संपत्ति का उपयोग करके ठंडे पदों की सूची ( [b a]प्रत्येक ठंडे स्थान के लिए फ़्लिप किए गए संस्करण सहित) की गणना करता है ।[a b]

फिर ?पहले ठंड की स्थिति के लिए बनाई गई ब्लॉक को संतुष्ट करता है

{\]zip{~-}%0|$(!*,1=}+

जो मूल रूप से जाँच करता है स्थिति वेक्टर अंतर की गणना और उसके बाद यह सत्यापित करते हुए यह भी है द्वारा इनपुट स्थिति से पहुंचा जा सकता है कि [0 x], [x 0]या [x x]कुछ के लिए x > 0। IMO कि परीक्षा सबसे चतुर बिट होती है: 0|$उन स्वरूपों में से किसी एक में किसी भी सरणी को [0 x]मैपिंग करते समय , जहां न तो [0 0]हो [0], [a b]में बाध्य करता हैa है और न ही bहै 0एक तीन तत्व सरणी के लिए, और [-x 0]या [-x -x]करने के लिए [-x 0]। फिर (!*,1=जाँचता है कि हमारे पास है [0 x]।

अंत 0]0=`में फालबैक केस और आउटपुट के लिए फॉर्मेटिंग है।

Answer 3

पायथ 57 58 61 62

K1.618Jm,s*dKs*d*KKU39M<smf|}TJ}_TJm,-Ghb-Hebt^,0hk2U99 1

इसे ऑनलाइन आज़माएं।

अन्य उत्तरों के समान ही सुंदर, लेकिन उस विकिपीडिया पृष्ठ पर जाने के लिए और कुछ नहीं दिया;) जादू की संख्या 39 मूल्यों के साथ ठंडे पदों की संख्या है < 99।

एक फ़ंक्शन को परिभाषित करता है gजिसे आप पसंद कर सकते हैं g 30 25। रिटर्न[] की विफलता के लिए, [(13,8)]सफलता पर।

व्याख्या

K1.618                            : K=phi (close enough for first 39 values)
      Jm,s*dKs*d*KKU39            : J=cold positions with the form (small,big)
M<s                              1: Define g(G,H) to return this slice: [:1] of the list below 
   mf|}TJ}_TJ                     : map(filter: T or reversed(T) in J, where T is each member of..
             m,-Ghb-Hebt^,0hk2    : [(G H) - (0 x+1),(x+1 0) and (x+1 x+1)]
                              U99 : for each x from 0 - 98

Comments

sइंट टू कास्ट - कुछ पात्रों को बचाता है /____1। rZ39द्वारा प्रतिस्थापित किया जा सकता है U39, unary रेंज का उपयोग करके। इसी तरह, आप के r99)साथ बदल सकते हैं U99।

— isaacg

@isaacg धन्यवाद! मैं पूरी तरह से भूल गया U। मुझे वास्तव में स्पष्टीकरण को अद्यतन करना चाहिए: P

— FryAmTheEggman

@isaacg Pyth के बारे में बस एक विचार है, मुझे लगता है कि आप @सेट चौराहा बना सकते हैं अगर इसका दूसरा तर्क अब एक सूची है। यह थोड़ा अजीब रूप से छोड़ दिया गया है क्योंकि aबदला गया था: P

— FryAmTheEggman

यह एक अच्छा विचार है - मैंने इसे लागू किया है। मैंने सूचियों के दो सूचियों के प्रतिच्छेदन को शामिल करने से पहले कुछ संभव नहीं होने देने के लिए चौराहे का कोड भी बदल दिया।

— isaacg

Answer 4

जावास्क्रिप्ट ईएस 6 - 280 बाइट्स

minified

r=x=>~~(x*1.618);g=(y,x)=>y(x)?g(y,x+1):x;s=A=>A?[A[1],A[0]]:A;f=(a,b)=>j([a,b])||j([a,b],1);j=(A,F)=>l(A,F)||s(l(s(A),F));l=(A,F)=>([a,b]=A,c=(F&&a+b>=r(b)&&(e=g(x=>a+b-2*x-r(b-x),0))?[a-e,b-e]:(e=g(x=>r(a+x)-2*a-x,0))+a<b?[a,a+e]:(e=r(b)-b)<a?[e,b]:0),c&&r(c[1]-c[0])==c[0]?c:0)

विस्तारित

r = x => ~~(x*1.618);
g = (y,x) => y(x) ? g(y,x+1) : x;
s = A =>A ? [A[1],A[0]] : A;
f = (a,b) => j([a,b]) || j([a,b],1);
j = (A,F) => l(A,F) || s(l(s(A),F));
l = (A,F) => (
    [a,b] = A,
    c = (
        F && a+b >= r(b) && (e = g( x => a+b - 2*x - r(b - x), 0 )) ? [a-e,b-e] :
        (e = g( x => r(a+x) - 2*a - x, 0)) + a < b ? [a,a+e] :
        (e = r(b) - b) < a ? [e,b] : 0
    ),
    c && r(c[1] - c[0]) == c[0] ? c : 0
);

अच्छा और त्वरित एल्गोरिथ्म। O (n) में चलता है, लेकिन निरंतर समय में चलेगा यदि बाइट-सेविंग लूप के लिए नहीं। लूप को पुनरावर्ती वृद्धिशील के रूप में कार्यान्वित किया जाता है, इसलिए स्क्रिप्ट अंततः सैकड़ों या हजारों में n के लिए पुनरावृत्ति त्रुटि के साथ विफल हो जाएगी । उसी बीट्टी अनुक्रम संपत्ति का उपयोग करता है जिसे श्री टेलर उल्लेख करते हैं, लेकिन अनुक्रम की गणना करने के बजाय, यह केवल सही शब्द (एस) तक कदम रखता है।

परीक्षण इनपुट के सभी पर ठीक से चलाता है और कई दर्जनों इसके अलावा मैंने परीक्षण किया।

आह्वान करने का कार्य है f। यह सफलता पर एक सरणी देता है और 0हार मान लेता है।

Comments

रुको, एक सरणी का उत्पादन ठीक है?

— जॉन ड्वोरक

@JDDvorak: xnor के पास एक आउटपुट है जो मान्य आउटपुट की सूची में सूचीबद्ध है, इसलिए मुझे लगा। शायद वह मामले को स्पष्ट कर सकता है। यह किसी भी दर पर एक तुच्छ निर्धारण है।

— COTO

जोड़ी की एक सरणी या एक सिंगलटन सरणी ठीक है; कई जीतने चालें नहीं हैं।

— xnor

Answer 5

पर्ल 5 - 109 (2 झंडे के साथ)

#!perl -pl
for$a(@v=0..99){for$b(@v){$c=$a;$d=$b;${$:="$a $b"}||
map{$$_||=$:for++$c.$".++$d,"$a $d","$c $b"}@v}}$_=$$_

उपयोग:

$ perl wyt.pl <<<'3 5'

$ perl wyt.pl <<<'4 5'
1 2

बस प्रत्येक संभव इनपुट के लिए समाधान की गणना करता है, तो बस एक ही खोज करता है।