युद्ध के खेल के विजेता का निर्धारण करें

19

कार्ड गेम युद्ध दिलचस्प है कि अंतिम परिणाम पूरी तरह से डेक की प्रारंभिक व्यवस्था द्वारा निर्धारित किया जाता है, इसलिए जब तक कार्ड खेल मैदान से उठाए जाते हैं और डेक पर चले जाते हैं, तब तक कुछ नियमों का पालन किया जाता है। इस चुनौती में, केवल 2 खिलाड़ी होंगे, चीजों को सरल बनाना।

खेल

  1. प्रत्येक खिलाड़ी को 26 कार्ड का एक डेक दिया जाता है।
  2. प्रत्येक खिलाड़ी अपने डेक फेस-अप में शीर्ष कार्ड रखता है। उच्च रैंकिंग कार्ड वाला खिलाड़ी ( Ace > King > Queen > Jack > 10 > 9 > 8 > 7 > 6 > 5 > 4 > 3 > 2गोल जीतता है, और अपने कार्ड को अपने प्रतिद्वंद्वी के कार्ड के ऊपर रखता है, उन्हें ऊपर की ओर घुमाता है, और उन्हें अपने डेक के नीचे जोड़ता है) (इसलिए उनका जीतने वाला कार्ड डेक के नीचे होता है , और दूसरे खिलाड़ी का खोने वाला कार्ड इसके ठीक ऊपर है)। यह तब तक किया जाता है जब तक कि कोई एक खिलाड़ी ताश के पत्तों से नहीं चलता।
    • यदि कार्ड समान रैंक के हैं, तो प्रत्येक खिलाड़ी अपने पिछले कार्ड के शीर्ष पर अपने डेक-अप के शीर्ष 2 कार्ड रखता है (ताकि डेक के शीर्ष पर स्थित कार्ड स्टैक में दूसरा कार्ड हो, और कार्ड जो दूसरे से शीर्ष पर था) शीर्ष पर है। फिर, रैंकों (प्रत्येक स्टैक के शीर्ष कार्ड) की तुलना फिर से की जाती है, और विजेता अपने पूरे स्टैक को हारने वाले के पूरे स्टैक के ऊपर रखता है, स्टैक को उल्टा-सीधा करता है, और इसे अपने डेक के नीचे रखता है। यदि कोई अन्य टाई है, तो अधिक कार्ड उसी तरह से खेले जाते हैं, जब तक कि एक विजेता नहीं चुना जाता या एक खिलाड़ी कार्ड से बाहर नहीं निकलता।

यदि किसी भी बिंदु पर खिलाड़ियों में से एक को अपने डेक से एक कार्ड खींचने की आवश्यकता होती है, लेकिन उनका डेक खाली है, तो वे तुरंत खेल खो देते हैं।

चुनौती

किसी भी सुविधाजनक प्रारूप में खिलाड़ियों के डेक में कार्ड की दो सूचियों को देखते हुए, यदि खिलाड़ी 1 जीतता है और खिलाड़ी 2 जीतता है तो एक गलत मूल्य, एक सत्य मूल्य का उत्पादन करता है।

सुविधा के लिए, एक 10 कार्ड को एक के साथ दर्शाया जाएगा T, और चेहरे के कार्ड संक्षिप्त ( Ace -> A, King -> K, Queen -> Q, Jack -> J) होंगे, ताकि सभी कार्ड एक वर्ण लंबे हों। वैकल्पिक रूप से, रैंक को दशमलव पूर्णांक 2-14 ( Jack -> 11, Queen -> 12, King -> 13, Ace -> 14) या हेक्स अंक 2-ई ( 10 -> A, Jack -> B, Queen -> C, King -> D, Ace -> E) के साथ दर्शाया जा सकता है । चूंकि सूट कोई मायने नहीं रखता, इसलिए सूट की जानकारी नहीं दी जाएगी।

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

परीक्षण के मामलों

परीक्षण मामले 23456789ABCDEरैंकों का प्रतिनिधित्व करने के लिए उपयोग करते हैं (आरोही क्रम में)।

D58B35926B92C7C4C7E8D3DAA2, 8E47C38A2DEA43467EB9566B95 -> False
669D9D846D4B3BA52452C2EDEB, E747CA988CC76723935A3B8EA5 -> False
5744B95ECDC6D325B28A782A72, 68394D9DA96EBBA8533EE7C6C4 -> True
87DB6C7EBC6C8D722389923DC6, E28435DBEBEA543AA47956594A -> False
589EAB9DCD43E9EC264A5726A8, 48DC2577BD68AB9335263B7EC4 -> True
E3698D7C46A739AE5BE2C49286, BB54B7D78954ED526A83C3CDA2 -> True
32298B5E785DC394467D5C9CB2, 5ED6AAD93E873EA628B6A4BC47 -> True
B4AB985B34756C624C92DE5E97, 3EDD5BA2A68397C26CE837AD48 -> False
9A6D9A5457BB6ACBC5E8D7D4A9, 73E658CE2C3E289B837422D463 -> True
96E64D226BC8B7D6C5974BAE32, 58DC7A8C543E35978AEBA34D29 -> True
C2978A35E74D7652BA9762C458, 9A9BB332BE8C8DD44CE3DE66A5 -> False
BEDB44E947693CD284923CEA82, 8CC3B75756255A683A6AB9E7DD -> False
EEDDCCBBAA8877665544332299, EEDDCCBBAA9988776655443322 -> False
EEDDCCBBAA9988776655443322, DDCCBBAA9988776655443E3E22 -> True

संदर्भ कार्यान्वयन

यह संदर्भ कार्यान्वयन पायथन 3 में लिखा गया है, और परीक्षण मामलों के समान प्रारूप में इनपुट लेता है (अल्पविराम और एक स्थान के बजाय एक नई पंक्ति द्वारा अलग करके)।

#!/usr/bin/env python3

from collections import deque

p1, p2 = [deque(s) for s in (input(),input())]
print(''.join(p1))
print(''.join(p2))

try:
    while p1 and p2:
        p1s = [p1.popleft()]
        p2s = [p2.popleft()]
        while p1s[-1] == p2s[-1]:
            p1s.append(p1.popleft())
            p2s.append(p2.popleft())
            p1s.append(p1.popleft())
            p2s.append(p2.popleft())
        if p1s[-1] > p2s[-1]:
            p1.extend(p2s+p1s)
        else:
            p2.extend(p1s+p2s)
except IndexError:
    pass
finally:
    print(len(p1) > 0)
code-golf  string  game  card-games  decision-problem 
— मै जाऊं
स्रोत
2
— बैसब्रांड कंबरवबूबवब
1
कार्ड के एक डेक के 1, 2, 3लिए खेल का कोई अंत नहीं है क्योंकि आप अपने प्रतिद्वंद्वी को जीतते रहते हैं 1। कि कार्ड की एक विषम संख्या होने का एक विचित्रता है?
— नील
@ नील कार्ड के किस डेक में ए है 1?
— मुकदमा
@Suever क्षमा करें, मैंने बहुत मुश्किल नहीं सोचा, मैंने अपने सिर पर आने वाले पहले तीन अलग-अलग नंबरों को चुना। बस किसी भी तीन कार्ड को चुनें जहां पहला सबसे कम है।
— नील
@ नील बस आपको एक कठिन समय दे रहा है :) बिंदु लिया!
— स्वेवर

जवाबों:

3

जावास्क्रिप्ट (ईएस 6), 134 बाइट्स

f=([p,...r],[q,...s],t=[],u=[],v)=>!q||p&&(v|p==q?f(r,s,[...t,p],[...u,q],!v):p>q?f([...r,...u,q,...t,p],s):f(r,[...s,...t,p,...u,q]))
<div oninput=o.checked=f(p.value,q.value)>
Player 1's cards: <input id=p><br>
Player 2's cards: <input id=q><br>
<input id=o type="checkbox"> Player 2 loses
स्निपेट का विस्तार करें

वापसी undefinedयदि खिलाड़ी 2 जीतता है, तो , trueअन्यथा। तुलनीय पुनरावृत्तियों को स्वीकार करता है, आमतौर पर पूर्णांक या हेक्स वर्णों के तार। उत्तर 22% से अधिक .पात्रों से बना है , जो मुझे लगता है कि मेरे लिए एक रिकॉर्ड होना चाहिए।

— नील
स्रोत
जब मैं परीक्षण मामलों के साथ यह कोशिश करता हूं तो मुझे सही परिणाम नहीं मिल रहे हैं। Jsfiddle.net/xbq5xzco
— चक मोरिस
@ChuckMorris इसके बारे में क्षमा करें, मैंने एक नियम की अनदेखी की है। अब तय होना चाहिए।
— नील
@ मेगो फिर से कोशिश करो, मैंने अभी इसे अपडेट किया है।
— नील
सब कुछ अब बाहर की जाँच करने लगता है।
— Mego
ठीक है, अब मैं प्रभावित हूँ!
— चक मोरिस
4

पायथन, 160 (155?) बाइट्स

f=lambda x,y,z=1:f(*((x,y,z+2),(x[z:]+y[:z]+x[:z],y[z:]),(x[z:],y[z:]+x[:z]+y[:z]))[(x[z-1]>y[z-1])+(x[z-1]<y[z-1])*2])if len(y)>z<len(x)else len(x)>len(y)

यह समाधान सैद्धांतिक रूप से मान्य है, लेकिन इसमें कुछ परीक्षण मामलों के लिए डिफ़ॉल्ट अजगर की अधिकतम पुनरावृत्ति गहराई की आवश्यकता होती है।

दूसरा समाधान 5 बाइट्स लंबा है, लेकिन सभी परीक्षण मामलों के लिए काम करते हैं।

f=lambda x,y,z=1:(f(x,y,z+2)if x[z-1]==y[z-1]else f(x[z:]+y[:z]+x[:z],y[z:])if x[z-1]>y[z-1]else f(x[z:],y[z:]+x[:z]+y[:z]))if len(y)>z<len(x)else len(x)>len(y)

संपादित करें: अनलॉल्फ़्ड समाधान 1:

def f(x,y,z=1):
    if len(y)<z>len(x):
        return len(x)>len(y)
    else:
        return f(*(
            (x,y,z+2),
            (x[z:],y[z:]+x[:z]+y[:z]),
            (x[z:]+y[:z]+x[:z],y[z:])
        )[(x[z-1]>y[z-1])+(x[z-1]<y[z-1])*2])
— Lulhum
स्रोत
चूंकि आयरनपायथन पहला समाधान ठीक चलाएगा (डिफ़ॉल्ट पुनरावृत्ति गहराई असीमित है), मैं यह कहने जा रहा हूं कि पहला समाधान मान्य है।
— मेगो जूल
2

पायथन, 261 से 265 बाइट्स

def f(a,b):
 if a==""or b=="":return b==""
 p=a[0];q=b[0];a=a[1:];b=b[1:]
 if p>q:a+=q+p
 if p<q:b+=p+q
 while p[-1]==q[-1]:
  if len(a)<2 or len(b)<2:return len(b)<2
  v=a[1];w=b[1];p+=a[0:2];q+=b[0:2];a=a[2:];b=b[2:]
  if v>w:a+=q+p
  if v<w:b+=p+q
 return f(a,b)

जैसा कि पोस्ट किया गया है, यह 265 बाइट्स है और यह पायथन 2 और पायथन 3 दोनों में काम करता है। आप पायथॉन 2 में 4 बाइट्स बचा सकते हैं, जबकि लूप में सिंगल टैब के साथ स्पेस बदल सकते हैं।

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

— चक मॉरिस
स्रोत
2

हास्केल, 372

मेरा पहला हास्केल कार्यक्रम

(यह मेरी पहली कार्यात्मक प्रोग्रामिंग है, ...)

w[]_=False
w _[]=True
w a b=if length j==0 then a>b else w (drop(d$head j)a++fst(head j))(drop(d$head j)b++snd(head j))where j=p a b
d(a,b)=quot(maximum[length a,length b])2
f (Just a)=a
p a b=map f$filter(/=Nothing)[t(a!!x,take(x+1)a,b!!x,take(x+1)b)|x<-[0,2..minimum[length a,length b]-1]]
t(a,b,c,d)=if a==c then Nothing else if a>c then Just(d++b,[])else Just([],b++d)

मैं कैसे सुधार करने के लिए सुझाव है प्यार करता हूँ।

उपयोग:

w "D58B35926B92C7C4C7E8D3DAA2" "8E47C38A2DEA43467EB9566B95"
w "669D9D846D4B3BA52452C2EDEB" "E747CA988CC76723935A3B8EA5"
w "5744B95ECDC6D325B28A782A72" "68394D9DA96EBBA8533EE7C6C4"
w "87DB6C7EBC6C8D722389923DC6" "E28435DBEBEA543AA47956594A"
w "589EAB9DCD43E9EC264A5726A8" "48DC2577BD68AB9335263B7EC4"
w "E3698D7C46A739AE5BE2C49286" "BB54B7D78954ED526A83C3CDA2"
w "32298B5E785DC394467D5C9CB2" "5ED6AAD93E873EA628B6A4BC47"
w "B4AB985B34756C624C92DE5E97" "3EDD5BA2A68397C26CE837AD48"
w "9A6D9A5457BB6ACBC5E8D7D4A9" "73E658CE2C3E289B837422D463"
w "96E64D226BC8B7D6C5974BAE32" "58DC7A8C543E35978AEBA34D29"
w "C2978A35E74D7652BA9762C458" "9A9BB332BE8C8DD44CE3DE66A5"
w "BEDB44E947693CD284923CEA82" "8CC3B75756255A683A6AB9E7DD"
w "EEDDCCBBAA8877665544332299" "EEDDCCBBAA9988776655443322"
w "EEDDCCBBAA9988776655443322" "DDCCBBAA9988776655443E3E22"

हास्केल जल्दी है ... :)

real    0m0.039s
user    0m0.022s
sys     0m0.005s
— Zylviij
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.