该卡的游戏战争是在最后的结局是完全由甲板的初始配置决定的，只要一定的规则并遵守在卡片从比赛场地拿起并移动到甲板的顺序有趣。在这次挑战中，将只有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-E（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

参考实施

该参考实现是用Python 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)

JavaScript（ES6），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％的.字符，我认为这对我来说是一个记录。

Python，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)

这个解决方案在理论上是有效的，但是对于某些测试用例，它需要增加默认的python最大递归深度。

第二种解决方案长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])

Python，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个字节，并且在Python 2和Python 3中均可使用。通过在while循环中用单个选项卡替换空格，可以在Python 2中节省4个字节。

在线尝试

哈斯克尔372

我的第一个Haskell程序

（这也是我的第一个函数式编程...）

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"

Haskell很快... :)

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