Gra karciana Wojna jest interesująca, ponieważ o ostatecznym wyniku decyduje początkowy układ talii, o ile przestrzegane są pewne zasady dotyczące kolejności wybierania kart z pola gry i przenoszenia ich na talie. W tym wyzwaniu będzie tylko 2 graczy, co znacznie uprości.

Gra

1. Każdy gracz otrzymuje talię 26 kart.
2. Każdy gracz kładzie odkrytą kartę w swojej talii. Gracz z kartą wyższego rzędu ( Ace > King > Queen > Jack > 10 > 9 > 8 > 7 > 6 > 5 > 4 > 3 > 2) wygrywa rundę i kładzie swoją kartę na karcie przeciwnika, odwraca ją i dodaje na spód talii (tak, aby zwycięska karta znajdowała się na dole talii , a przegrana karta drugiego gracza znajduje się tuż nad nią). Odbywa się to do momentu wyczerpania karty przez jednego z graczy.
   • Jeśli karty mają taką samą rangę, wówczas każdy gracz umieszcza odkryte 2 karty ze swojej talii na wierzchu poprzedniej karty (tak, aby karta znajdująca się na górze talii była drugą kartą na stosie, a karta, która była druga od góry, znajduje się na górze). Następnie szeregi (górnej karty każdego stosu) są ponownie porównywane, a zwycięzca umieszcza cały stos na wierzchu całego stosu przegranego, odwraca stos do góry nogami i umieszcza go na spodzie swojej talii. Jeśli jest inny remis, więcej kart jest rozgrywanych w ten sam sposób, dopóki nie zostanie wybrany zwycięzca lub jeden gracz nie skończy kart.

Jeśli w którymś momencie jeden z graczy będzie musiał wyciągnąć kartę ze swojej talii, ale jego talia jest pusta, natychmiast przegrywa.

Wyzwanie

Biorąc pod uwagę dwie listy kart w talii graczy, w dowolnym dogodnym formacie, wypisz prawdziwą wartość, jeśli Gracz 1 wygra, i falsey, jeśli Gracz 2 wygra.

Dla wygody karta 10 będzie oznaczona symbolem a T, a karty twarzy zostaną skrócone ( Ace -> A, King -> K, Queen -> Q, Jack -> J), dzięki czemu wszystkie karty będą miały jedną postać. Alternatywnie, szeregi można przedstawić za pomocą liczb całkowitych dziesiętnych 2-14 ( Jack -> 11, Queen -> 12, King -> 13, Ace -> 14) lub cyfr szesnastkowych 2-E ( 10 -> A, Jack -> B, Queen -> C, King -> D, Ace -> E). Ponieważ kolory nie mają znaczenia, informacje o kolorze nie zostaną podane.

• Możesz założyć, że wszystkie gry zakończą się w pewnym momencie (choć może to potrwać bardzo długo), a jeden gracz zawsze będzie miał karty przed drugim.
• Każdy gracz umieszcza karty jednocześnie i jedną kartę na raz, więc nigdy nie ma dwuznaczności co do tego, który gracz zabraknie kart jako pierwszy.

Przypadki testowe

Przypadki testowe służą 23456789ABCDEdo reprezentowania stopni (w porządku rosnącym).

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

Wdrożenie referencyjne

Ta implementacja referencyjna jest napisana w Pythonie 3 i pobiera dane wejściowe w tym samym formacie co przypadki testowe (oprócz oddzielonych znakiem nowej linii zamiast przecinka i spacji).

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

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

Zwróć, undefinedjeśli gracz 2 wygra, w trueprzeciwnym razie. Akceptuje porównywalne iteratory, zwykle tablice liczb całkowitych lub ciągi znaków szesnastkowych. Odpowiedź składa się z ponad 22% .znaków, co moim zdaniem musi być dla mnie rekordem.

Python, 160 (155?) Bajtów

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)

To rozwiązanie jest teoretycznie poprawne, ale wymaga zwiększenia domyślnej maksymalnej głębokości rekurencji w pythonie dla niektórych przypadków testowych.

Drugie rozwiązanie jest o 5 bajtów dłuższe, ale działa dla wszystkich przypadków testowych.

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)

Edycja: Nieskluczone rozwiązanie 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, od 261 do 265 bajtów

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)

Jak napisano, jest to 265 bajtów i działa zarówno w Pythonie 2, jak i Pythonie 3. W Pythonie 2 można zapisać 4 bajty, zastępując spacje pojedynczą tabulacją w pętli while.

Wypróbuj online

Haskell, 372

Mój pierwszy program Haskell

(To także moje pierwsze programowanie funkcjonalne ...)

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)

Chciałbym mieć wskazówki, jak poprawić.

Stosowanie:

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 jest szybki ... :)

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