Kart oyunu Savaşı , kartların oyun alanından alındığı ve destelere taşındığı sıra için belirli kurallara uyulduğu sürece, nihai sonucun tamamen destenin ilk düzenlemesi ile belirlenmesi ilginçtir. Bu mücadelede, sadece 2 oyuncu olacak ve işleri büyük ölçüde basitleştirecek.

Oyun

1. Her oyuncuya 26 kartlık bir deste dağıtılır.
2. Her oyuncu en üstteki kartı üst üste açık olarak yerleştirir. Daha yüksek rütbeli kartı ( Ace > King > Queen > Jack > 10 > 9 > 8 > 7 > 6 > 5 > 4 > 3 > 2) olan oyuncu raundu kazanır ve kartını rakibinin kartının üstüne yerleştirir, ters çevirir ve destelerinin dibine ekler (böylece kazanan kartları destenin dibinde olur ve diğer oyuncunun kaybetme kartı hemen üstündedir). Bu, oyunculardan biri kart bitene kadar yapılır.
   • Kartlar eşit derecedeyse, her oyuncu destesinin ilk 2 kartını yüzü yukarı gelecek şekilde önceki kartlarının üstüne yerleştirir (böylece destenin üstündeki kart destedeki ikinci kart olur ve üstten ikinci olan kart üstte). Daha sonra, sıralar (her bir yığının üst kartının) tekrar karşılaştırılır ve kazanan tüm destelerini kaybedenlerin tüm yığının üstüne yerleştirir, yığını baş aşağı çevirir ve destelerinin altına yerleştirir. Başka bir beraberlik varsa, kazanan seçilene veya bir oyuncu kart bitene kadar aynı şekilde daha fazla kart oynanır.

Herhangi bir noktada oyunculardan birinin destesinden bir kart çekmesi gerekiyorsa, ancak desteleri boşsa, derhal oyunu kaybederler.

Meydan okuma

Oyuncuların destelerinde, herhangi bir uygun formatta iki kart listesi verildiğinde, Oyuncu 1 kazanırsa gerçek bir değer ve Oyuncu 2 kazanırsa bir falsey değeri verir.

Kolaylık sağlamak için, 10 kart a ile temsil edilecek Tve yüz kartları kısaltılacaktır ( Ace -> A, King -> K, Queen -> Q, Jack -> J), böylece tüm kartlar bir karakter uzunluğunda olacaktır. Alternatif olarak, sıralar ondalık tam sayı 2-14 ( Jack -> 11, Queen -> 12, King -> 13, Ace -> 14) veya onaltılık basamak 2-E ( 10 -> A, Jack -> B, Queen -> C, King -> D, Ace -> E) ile temsil edilebilir. Takım elbise önemli olmadığı için takım elbise bilgileri verilmeyecektir.

• Tüm oyunların bir noktada sona ereceğini (çok uzun zaman alabilmesine rağmen) ve bir oyuncunun her zaman diğerinden önce kartlarının biteceğini varsayabilirsiniz.
• Her oyuncu aynı anda ve her seferinde bir kart yerleştirir, bu yüzden hangi oyuncunun ilk önce kart tükettiği konusunda hiçbir belirsizlik yoktur.

Test Durumları

Test senaryoları 23456789ABCDEkademeleri temsil etmek için kullanılır (artan sırada).

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

Referans uygulaması

Bu başvuru uygulaması Python 3'te yazılmıştır ve girdiyi test senaryolarıyla aynı biçimde alır (virgül ve boşluk yerine satırsonu ile ayrılmış olanlar hariç).

#!/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)

JavaScript (ES6), 134 bayt

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

undefinedOyuncu 2 kazanırsa, geri dön true. Karşılaştırılabilir yineleyicileri, genellikle tamsayı dizilerini veya onaltılık karakter dizelerini kabul eder. Cevap, .benim için bir kayıt olması gerektiğini düşündüğüm karakterlerin % 22'den fazlasından oluşuyor .

Python, 160 (155?) Bayt

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)

Bu çözüm teorik olarak geçerlidir, ancak bazı test durumları için varsayılan python maksimum özyineleme derinliğinin artırılmasını gerektirir.

İkinci çözüm 5 bayt daha uzun, ancak tüm test vakaları için çalışıyor.

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)

Düzenleme: Çözümsüz çözüm 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])

Python, 261 ila 265 bayt

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)

Gönderildiği gibi, bu 265 bayttır ve hem Python 2 hem de Python 3'te çalışır. Boşlukları while döngüsünde tek bir sekmeyle değiştirerek Python 2'ye 4 bayt kaydedebilirsiniz.

Çevrimiçi deneyin

Haskell, 372

İlk Haskell Programım

(Benim de ilk işlevsel programım ...)

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)

Nasıl geliştirileceğine dair ipuçlarına sahip olmak isterim.

Kullanımı:

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"

Haskell hızlı ... :)

real    0m0.039s
user    0m0.022s
sys     0m0.005s