Permainan permainan kartu War menarik karena hasil akhir sepenuhnya ditentukan oleh pengaturan awal geladak, selama aturan tertentu diikuti untuk urutan pengambilan kartu dari lapangan permainan dan dipindahkan ke geladak. Dalam tantangan ini, hanya akan ada 2 pemain, sangat menyederhanakan banyak hal.

Permainan

1. Setiap pemain diberikan setumpuk 26 kartu.
2. Setiap pemain menempatkan kartu teratas di dek mereka menghadap ke atas. Pemain dengan kartu berpangkat lebih tinggi ( Ace > King > Queen > Jack > 10 > 9 > 8 > 7 > 6 > 5 > 4 > 3 > 2) memenangkan ronde, dan menempatkan kartu mereka di atas kartu lawan mereka, membalikkannya, dan menambahkannya ke bagian bawah geladak mereka (jadi kartu kemenangan mereka ada di bagian bawah geladak , dan kartu yang hilang pemain lain tepat di atasnya). Ini dilakukan sampai salah satu pemain kehabisan kartu.
   • Jika kartu memiliki peringkat yang sama, maka masing-masing pemain menempatkan 2 kartu teratas dari dek mereka menghadap ke atas di atas kartu mereka sebelumnya (sehingga kartu yang berada di atas dek adalah kartu kedua dalam tumpukan, dan kartu yang kedua-dari-atas ada di atas). Kemudian, jajaran (dari kartu teratas dari setiap tumpukan) dibandingkan lagi, dan pemenang menempatkan seluruh tumpukan mereka di atas seluruh tumpukan yang kalah, memutar tumpukan terbalik, dan menempatkannya di bagian bawah dek mereka. Jika ada seri lain, lebih banyak kartu dimainkan dengan cara yang sama, sampai pemenang dipilih atau satu pemain kehabisan kartu.

Jika suatu saat salah satu pemain perlu mengambil kartu dari dek mereka, tetapi dek mereka kosong, mereka segera kehilangan permainan.

Tantangan

Diberikan dua daftar kartu di deck pemain, dalam format apa pun yang nyaman, mengeluarkan nilai kebenaran jika Player 1 menang, dan nilai falsey jika Player 2 menang.

Untuk kenyamanan, 10 kartu akan diwakili dengan T, dan kartu wajah akan disingkat ( Ace -> A, King -> K, Queen -> Q, Jack -> J), sehingga semua kartu panjangnya satu karakter. Atau, jajaran dapat diwakili dengan bilangan desimal 2-14 ( Jack -> 11, Queen -> 12, King -> 13, Ace -> 14) atau digit hex 2-E ( 10 -> A, Jack -> B, Queen -> C, King -> D, Ace -> E). Karena jas tidak penting, informasi jas tidak akan diberikan.

• Anda dapat mengasumsikan bahwa semua permainan akan berakhir pada titik tertentu (meskipun mungkin membutuhkan waktu yang sangat lama), dan satu pemain akan selalu kehabisan kartu sebelum yang lain.
• Setiap pemain menempatkan kartu secara bersamaan, dan satu kartu pada satu waktu, sehingga tidak pernah ada ambiguitas tentang pemain yang kehabisan kartu terlebih dahulu.

Uji Kasus

Kasus uji digunakan 23456789ABCDEuntuk mewakili peringkat (dalam urutan menaik).

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

Implementasi Referensi

Implementasi referensi ini ditulis dalam Python 3, dan mengambil input dalam format yang sama dengan test case (kecuali dipisahkan oleh baris baru, bukan koma dan spasi).

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

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

Kembali undefinedjika Player 2 menang, truejika tidak. Menerima iterator yang sebanding, biasanya array bilangan bulat atau string karakter hex. Jawaban terdiri dari lebih dari 22% .karakter, yang menurut saya harus menjadi catatan bagi saya.

Python, 160 (155?) Byte

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)

Solusi ini secara teoritis valid, tetapi membutuhkan kedalaman rekursi maksimum python default untuk ditingkatkan untuk beberapa kasus uji.

Solusi kedua adalah 5 byte lebih lama, tetapi berfungsi untuk semua kasus uji.

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)

Sunting: Solusi tidak disatukan 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 hingga 265 byte

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)

Seperti yang diposting, ini adalah 265 byte dan berfungsi baik di Python 2 dan Python 3. Anda dapat menyimpan 4 byte di Python 2 dengan mengganti spasi dengan satu tab di loop sementara.

Cobalah online

Haskell, 372

Program Haskell pertama saya

(Ini pemrograman fungsional pertama saya, juga ...)

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)

Saya ingin memiliki tips tentang cara meningkatkan.

Pemakaian:

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 cepat ... :)

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