O jogo de cartas Guerra é interessante, pois o resultado final é inteiramente determinado pelo arranjo inicial do baralho, desde que certas regras sejam seguidas na ordem em que as cartas são retiradas do campo de jogo e movidas para os decks. Neste desafio, haverá apenas 2 jogadores, simplificando bastante as coisas.

O jogo

1. Cada jogador recebe um baralho de 26 cartas.
2. Cada jogador coloca a carta do topo no baralho com a face para cima. O jogador com a carta de melhor classificação ( Ace > King > Queen > Jack > 10 > 9 > 8 > 7 > 6 > 5 > 4 > 3 > 2) vence a rodada e coloca a carta em cima da carta do oponente, vira-a e os adiciona ao fundo do baralho (para que a carta vencedora esteja no fundo do baralho) , e a carta perdida do outro jogador está logo acima dela). Isso é feito até que um dos jogadores fique sem cartas.
   • Se as cartas tiverem o mesmo valor, cada jogador coloca as 2 primeiras cartas do seu baralho com a face para cima em cima da carta anterior (de modo que a carta que estava no topo do baralho seja a segunda carta da pilha, e o o cartão que estava em segundo lugar está no topo). Em seguida, as classificações (da carta superior de cada pilha) são comparadas novamente, e o vencedor coloca sua pilha inteira no topo da pilha inteira do perdedor, vira a pilha de cabeça para baixo e a coloca no fundo do seu baralho. Se houver outro empate, mais cartas são jogadas da mesma maneira, até que um vencedor seja escolhido ou um jogador fique sem cartas.

Se a qualquer momento um dos jogadores precisar tirar uma carta do baralho, mas o baralho estiver vazio, eles imediatamente perderão o jogo.

O desafio

Dadas duas listas de cartas nos decks dos jogadores, em qualquer formato conveniente, produz um valor verdadeiro se o Jogador 1 vencer e um valor falso se o Jogador 2 vencer.

Por conveniência, uma carta de 10 será representada por a T, e as cartas de face serão abreviadas ( Ace -> A, King -> K, Queen -> Q, Jack -> J), para que todas as cartas tenham um caractere. Como alternativa, as classificações podem ser representadas com números inteiros decimais 2-14 ( Jack -> 11, Queen -> 12, King -> 13, Ace -> 14) ou dígitos hexadecimais 2-E ( 10 -> A, Jack -> B, Queen -> C, King -> D, Ace -> E). Como os fatos não importam, as informações dos fatos não serão fornecidas.

• Você pode presumir que todos os jogos terminarão em algum momento (embora isso leve muito tempo), e um jogador sempre ficará sem cartas antes do outro.
• Cada jogador coloca as cartas simultaneamente e uma por vez, para que nunca haja ambiguidade sobre qual jogador ficou sem cartas primeiro.

Casos de teste

Os casos de teste são usados 23456789ABCDEpara representar as classificações (em ordem crescente).

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

Implementação de referência

Essa implementação de referência é escrita em Python 3 e recebe entrada no mesmo formato dos casos de teste (exceto separados por uma nova linha em vez de vírgula e espaço).

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

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

Retorne undefinedse o Jogador 2 vencer, truecaso contrário. Aceita iteradores comparáveis, geralmente matrizes de números inteiros ou seqüências de caracteres hexadecimais. A resposta é composta por mais de 22% dos .caracteres, o que acho que deve ser um recorde para mim.

Python, 160 (155?) Bytes

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)

Essa solução é teoricamente válida, mas exige que a profundidade máxima de recursão do python padrão seja aumentada para alguns dos casos de teste.

A segunda solução tem 5 bytes mais, mas funciona para todos os casos de teste.

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)

Edit: Solução 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 a 265 bytes

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)

Conforme publicado, são 265 bytes e funciona no Python 2 e no Python 3. Você pode salvar 4 bytes no Python 2 substituindo os espaços por uma única guia no loop while.

Experimente online

Haskell, 372

Meu primeiro programa Haskell

(É a minha primeira programação funcional també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)

Eu adoraria ter dicas de como melhorar.

Uso:

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ápido ... :)

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