Il gioco di carte War è interessante in quanto il risultato finale è interamente determinato dalla disposizione iniziale del mazzo, a condizione che vengano seguite alcune regole per l'ordine in cui le carte vengono prese dal campo di gioco e spostate sui mazzi. In questa sfida, ci saranno solo 2 giocatori, semplificando notevolmente le cose.

Il gioco

1. Ad ogni giocatore viene distribuito un mazzo di 26 carte.
2. Ogni giocatore piazza la prima carta nel proprio mazzo scoperta. Il giocatore con la carta di livello più alto ( Ace > King > Queen > Jack > 10 > 9 > 8 > 7 > 6 > 5 > 4 > 3 > 2) vince il round e posiziona la propria carta in cima alla carta dell'avversario, la gira e la aggiunge alla fine del mazzo (quindi la sua carta vincente si trova nella parte inferiore del mazzo e la carta perdente dell'altro giocatore è appena sopra di essa). Questo viene fatto fino a quando uno dei giocatori esaurisce le carte.
   • Se le carte hanno lo stesso valore, ogni giocatore piazza le prime 2 carte del proprio mazzo a faccia in su in cima alla propria carta precedente (in modo che la carta che si trovava in cima al mazzo sia la seconda carta nella pila, e il la carta che era la seconda dall'alto è in cima). Quindi, i ranghi (della carta in cima a ogni pila) vengono nuovamente confrontati e il vincitore posiziona il suo intero stack in cima all'intero stack del perdente, capovolge il mazzo e lo posiziona in fondo al proprio mazzo. Se c'è un altro pareggio, più carte vengono giocate allo stesso modo, fino a quando viene scelto un vincitore o un giocatore esaurisce le carte.

Se in qualsiasi momento uno dei giocatori deve pescare una carta dal proprio mazzo, ma il suo mazzo è vuoto, perde immediatamente la partita.

La sfida

Dati due elenchi di carte nei mazzi dei giocatori, in qualsiasi formato conveniente, producono un valore di verità se il giocatore 1 vince e un valore di falsa se il giocatore 2 vince.

Per comodità, una carta 10 sarà rappresentata con un T, e le carte faccia saranno abbreviate ( Ace -> A, King -> K, Queen -> Q, Jack -> J), in modo che tutte le carte siano lunghe un personaggio. In alternativa, i ranghi possono essere rappresentati con numeri decimali 2-14 ( Jack -> 11, Queen -> 12, King -> 13, Ace -> 14) o cifre esadecimali 2-E ( 10 -> A, Jack -> B, Queen -> C, King -> D, Ace -> E). Poiché i semi non contano, le informazioni sui semi non verranno fornite.

• Puoi presumere che tutti i giochi finiranno ad un certo punto (anche se potrebbe richiedere molto tempo) e che un giocatore finirà sempre le carte prima dell'altro.
• Ogni giocatore piazza le carte contemporaneamente e una carta alla volta, quindi non c'è mai alcuna ambiguità su quale giocatore abbia esaurito le carte per primo.

Casi test

I casi di test usano 23456789ABCDEper rappresentare i gradi (in ordine 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

Implementazione di riferimento

Questa implementazione di riferimento è scritta in Python 3 e accetta input nello stesso formato dei casi di test (tranne separati da una nuova riga anziché da una virgola e uno spazio).

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

Ritorna undefinedse il Giocatore 2 vince, truealtrimenti. Accetta iteratori comparabili, generalmente matrici di numeri interi o stringhe di caratteri esadecimali. La risposta è composta da oltre il 22% di .personaggi, che penso debba essere un record per me.

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)

Questa soluzione è teoricamente valida, ma richiede che la profondità massima di ricorsione di Python predefinita sia aumentata per alcuni dei casi di test.

La seconda soluzione è più lunga di 5 byte, ma funziona per tutti i casi di test.

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)

Modifica: soluzione non golfata 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, da 261 a 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)

Come pubblicato, questo è 265 byte e funziona sia in Python 2 che in Python 3. Puoi salvare 4 byte in Python 2 sostituendo gli spazi con una singola scheda nel ciclo while.

Provalo online

Haskell, 372

Il mio primo programma Haskell

(È anche la mia prima programmazione funzionale ...)

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)

Mi piacerebbe avere consigli su come migliorare.

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 è veloce ... :)

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