Trò chơi bài chiến tranh thú vị ở chỗ kết quả cuối cùng hoàn toàn được quyết định bởi sự sắp xếp ban đầu của bộ bài, miễn là tuân theo một số quy tắc nhất định theo thứ tự các lá bài được nhặt từ sân chơi và chuyển sang bộ bài. Trong thử thách này, sẽ chỉ có 2 người chơi, đơn giản hóa mọi thứ rất nhiều.

Tro choi

1. Mỗi người chơi được chia một bộ bài gồm 26 lá bài.
2. Mỗi người chơi đặt lá bài trên cùng trong bộ bài của họ. Người chơi có thẻ xếp hạng cao hơn ( Ace > King > Queen > Jack > 10 > 9 > 8 > 7 > 6 > 5 > 4 > 3 > 2) thắng vòng đấu và đặt thẻ của họ lên trên thẻ của đối thủ, lật chúng lại và thêm chúng vào cuối cỗ bài của họ (vì vậy thẻ chiến thắng của họ nằm ở cuối cỗ bài và thẻ thua của người chơi khác ở ngay trên nó). Điều này được thực hiện cho đến khi một trong những người chơi hết thẻ.
   • Nếu các thẻ có thứ hạng bằng nhau, thì mỗi người chơi sẽ đặt 2 thẻ trên cùng của bộ bài của họ lên trên thẻ của họ trước đó (sao cho thẻ nằm trên boong là thẻ thứ hai trong ngăn xếp và thẻ thứ hai từ trên xuống là trên cùng). Sau đó, các cấp bậc (của thẻ trên cùng của mỗi ngăn xếp) được so sánh lại và người chiến thắng đặt toàn bộ ngăn xếp của họ lên trên toàn bộ ngăn xếp của người thua cuộc, lật ngược ngăn xếp và đặt nó xuống dưới cùng của bộ bài. Nếu có một cà vạt khác, nhiều thẻ được chơi theo cùng một cách, cho đến khi một người chiến thắng được chọn hoặc một người chơi hết thẻ.

Nếu tại bất kỳ thời điểm nào, một trong những người chơi cần rút một lá bài từ bộ bài của họ, nhưng bộ bài của họ trống, họ ngay lập tức thua trò chơi.

Các thách thức

Đưa ra hai danh sách thẻ trong các cỗ bài của người chơi, ở bất kỳ định dạng thuận tiện nào, sẽ tạo ra giá trị trung thực nếu Người chơi 1 thắng và giá trị chim ưng nếu Người chơi 2 thắng.

Để thuận tiện, một thẻ 10 sẽ được biểu thị bằng a Tvà thẻ mặt sẽ được viết tắt ( Ace -> A, King -> K, Queen -> Q, Jack -> J), sao cho tất cả các thẻ đều dài một ký tự. Ngoài ra, các cấp bậc có thể được biểu diễn bằng số nguyên thập phân 2-14 ( Jack -> 11, Queen -> 12, King -> 13, Ace -> 14) hoặc chữ số hex 2-E ( 10 -> A, Jack -> B, Queen -> C, King -> D, Ace -> E). Vì bộ đồ không quan trọng, thông tin về bộ đồ sẽ không được cung cấp.

• Bạn có thể cho rằng tất cả các trò chơi sẽ chấm dứt tại một số thời điểm (mặc dù có thể mất một thời gian rất dài) và một người chơi sẽ luôn hết thẻ trước người khác.
• Mỗi người chơi đặt các thẻ cùng một lúc và mỗi lần một thẻ, do đó không bao giờ có bất kỳ sự mơ hồ nào về việc người chơi hết thẻ trước.

Các trường hợp thử nghiệm

Các trường hợp thử nghiệm được sử dụng 23456789ABCDEđể đại diện cho các cấp bậc (theo thứ tự tăng dần).

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

Thực hiện tham khảo

Việc triển khai tham chiếu này được viết bằng Python 3 và lấy đầu vào có cùng định dạng với các trường hợp thử nghiệm (ngoại trừ cách nhau bởi một dòng mới thay vì dấu phẩy và dấu cách).

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

Quay trở lại undefinednếu Người chơi 2 thắng, truenếu không. Chấp nhận các trình lặp tương đương, thường là các mảng số nguyên hoặc chuỗi các ký tự hex. Câu trả lời bao gồm hơn 22% các .ký tự, mà tôi nghĩ phải là một bản ghi cho tôi.

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)

Giải pháp này là hợp lệ về mặt lý thuyết, nhưng nó đòi hỏi độ sâu đệ quy tối đa python mặc định được tăng lên đối với một số trường hợp thử nghiệm.

Giải pháp thứ hai dài hơn 5 byte, nhưng hoạt động cho tất cả các trường hợp thử nghiệm.

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)

Chỉnh sửa: Giải pháp Ungolfed 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 đến 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)

Như đã đăng, đây là 265 byte và nó hoạt động trong cả Python 2 và Python 3. Bạn có thể lưu 4 byte trong Python 2 bằng cách thay thế khoảng trắng bằng một tab duy nhất trong vòng lặp while.

Dùng thử trực tuyến

Haskell, 372

Chương trình Haskell đầu tiên của tôi

(Đây cũng là chương trình chức năng đầu tiên của tôi ...)

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)

Tôi muốn có lời khuyên về cách cải thiện.

Sử dụng:

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 rất nhanh ... :)

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