Biorąc pod uwagę dwie listy rzutów kostką na bitwę w ryzyku, twój program lub funkcja musi wypisać ile żołnierzy traci każdy gracz.

tło

^{Nie musisz tego czytać, ponieważ jest to jedynie tło. Przejdź do podtytułu „Zadanie”, aby kontynuować.}

W grze Ryzyko jeden gracz może zaatakować innego gracza (w rzeczywistości jest to konieczne, aby wygrać). Wynik bitwy zależy od rzutu kostką. Każda bitwa występuje jako kolejność pod bitew, w których każdy gracz może przegrać do 2swoich części armii.

W bitwie podrzędnej obrońca i atakujący rzucają kilkoma kostkami, których liczba może się różnić w zależności od okoliczności nieistotnych dla tego wyzwania. Kość o najwyższej wartości atakującego jest porównywana z kośćą o najwyższej wartości obrońcy. Jeśli kość atakującego jest wyższa niż kość obrońcy, obrońca traci jeden kawałek. W przeciwnym razie atakujący traci jeden kawałek.

Następnie, jeśli obaj gracze mają co najmniej dwie kości, porównywane są kości o drugiej wartości. Ponownie, jeśli kość atakującego jest wyższa niż kość obrońcy, obrońca traci jeden kawałek. W przeciwnym razie atakujący traci jeden kawałek.

(Defender wygrywa remisy. Jeśli zarówno obrońca, jak i atakujący rzuci a 4, atakujący traci pionek.)

_{W tej pod bitwie z artykułu z Wikipedii kości atakującego są czerwone, a kości obrońcy są białe. Najwyższa z kości atakującego 4i najwyższa z obrońców 3. Ponieważ atakujący był wyższy, obrońca traci kawałek. Drugie najwyższe dotyczą 3atakującego i 2obrońcy. Ponieważ atakujący znów był wyżej, obrońca traci kolejny kawałek. Zatem w tej pod bitwie atakujący nie traci żadnych elementów, a obrońca traci je 2.}

Zauważ, że trzecie najwyższe elementy nie są porównywane. Wynika to z faktu, że obrońca ma nie więcej niż dwie kości w jednej bitwie podrzędnej, więc nie ma nigdy trzech najwyższych pionków do porównania.

Zadanie

Biorąc pod uwagę nieposortowane rzuty kostkami (liczby całkowite w zakresie od 1 do 6 włącznie) zarówno atakującego, jak i obrońcy podgrupy Ryzyka w dowolnej dogodnej formie, wypisz liczbę sztuk armii, które każdy gracz traci. Dane wyjściowe mogą być w dowolnej dogodnej formie, o ile mają różne dane wyjściowe wskazujące pięć możliwości. Musisz wskazać, jakie te różne wyniki są w twoim pytaniu.

Dane wyjściowe są określane w następujący sposób: Zacznij od def=0i atk=0. Jeśli największa wartość listy rzutów kostką atakującego jest większa niż największa wartość listy rzutów kostek obrońcy, zwiększaj def. W przeciwnym razie przyrost atk.

Jeśli obie listy rzutów kością mają co najmniej długość 2, wówczas: jeśli druga co do wielkości wartość listy rzutów kości atakującego jest większa niż druga największa wartość listy, wówczas zwiększaj defi zwiększaj w inny sposób atk.

Na koniec program lub funkcja musi wypisać unikalny identyfikator dla każdej z następujących 5 możliwości wyjścia:

  ╔═══╦═══╗
  ║atk║def║
  ╠═══╬═══╣
  ║ 1 ║ 0 ║
  ║ 0 ║ 1 ║
  ║ 2 ║ 0 ║
  ║ 1 ║ 1 ║
  ║ 0 ║ 2 ║
  ╚═══╩═══╝

Przykład

Obrońca: [3, 2] atakujący: [2, 4, 1] maks. Obrońca 3i maks. Atakujący 4. 4>3, więc def=1 Drugi obrońca jest, 2a drugi atakujący jest 2. Not(2>2), Tak atk=1. Wynik może być wtedy [1,1].

Przypadki testowe

Defender
Attacker
Output (as [def,atk])
-----
[1]
[1]
[0,1]
-----
[6,6]
[1,1,1]
[0,2]
-----
[1,2]
[5,2,3]
[2,0]
-----
[5]
[3,4]
[0,1]
-----
[4]
[4,5]
[1,0]
-----
[1,3]
[1,2,3]
[1,1]
-----
[4]
[4,5,6]
[1,0]
-----
[4,5]
[6,2]
[1,1]
-----
[5]
[6,1,3]
[1,0]
-----
[5,5]
[4,4,1]
[0,2]
-----
[2,5]
[2,2]
[0,2]
-----
[6,6]
[4,4,3]
[0,2]
-----
[2,1]
[4,3]
[2,0]
-----
[4]
[1,5]
[1,0]
-----
[1]
[5,2]
[1,0]
-----
[6,2]
[4]
[0,1]
-----
[4,2]
[2,5,5]
[2,0]
-----
[2]
[6,6,2]
[1,0]
-----
[6]
[2,6]
[0,1]
-----
[3,1]
[1]
[0,1]
-----
[6,2]
[3,5,2]
[1,1]
-----
[4,2]
[1,1]
[0,2]
-----
[4,3]
[5,4,1]
[2,0]
-----
[5,6]
[1,2]
[0,2]
-----
[3,2]
[4,4]
[2,0]
-----
[2]
[6,3,4]
[1,0]
-----
[1,4]
[6,2,4]
[2,0]
-----
[4,2]
[2,5,4]
[2,0]
-----
[5]
[6,2,1]
[1,0]
-----
[3]
[2,5,4]
[1,0]
-----
[5,4]
[2]
[0,1]
-----
[6,3]
[2,6,5]
[1,1]
-----
[3,1]
[4]
[1,0]
-----
[4]
[6,6,5]
[1,0]
-----
[6,3]
[4,2]
[0,2]
-----
[1,6]
[5,4]
[1,1]
-----
[3,6]
[4,4]
[1,1]
-----
[5,4]
[5,1,1]
[0,2]
-----
[6,3]
[5,4]
[1,1]
-----
[2,6]
[1,2]
[0,2]
-----
[4,2]
[3,5,5]
[2,0]
-----
[1]
[1,2,1]
[1,0]
-----
[4,5]
[1,6]
[1,1]
-----
[1]
[3,5,1]
[1,0]
-----
[6,2]
[6,2]
[0,2]

Przykładowa implementacja

Python 2 lub 3

def risk(atk_rolls,def_rolls):
    # set the rolls in descending order, e.g. [5,3,2]
    atk_rolls = sorted(atk_rolls,reverse = True)
    def_rolls = sorted(def_rolls,reverse = True)
    # minimum length.
    minlen = min(len(atk_rolls),len(def_rolls))
    atk_lost = 0
    def_lost = 0
    # compare the highest-valued rolls
    if atk_rolls[0]>def_rolls[0]:
        def_lost += 1
    else:
        atk_lost += 1
    if minlen == 2:
        # compare the second-highest-valued rolls
        if atk_rolls[1] > def_rolls[1]:
            def_lost += 1
        else:
            atk_lost += 1
    return [def_lost, atk_lost]    

Dane techniczne

• Dane wejściowe mogą być przyjmowane w dowolnej formie, która wyraźnie koduje tylko rzuty obrońcy i rzuty atakującego.
• Dane wyjściowe mogą mieć dowolną formę, która zapewnia unikalne dane wyjściowe dla każdej z pięciu wyżej wymienionych możliwości.
• Rzuty obrońcy to lista 1lub 2liczby całkowite w zestawie [1,2,3,4,5,6]. Rolki atakującego to lista 1do 3liczb całkowitych w zestawie [1,2,3,4,5,6].
• Ponieważ jest to gra w golfa , wygrywa najkrótszy kod w każdym języku ! Czy nie pozwolić odpowiedzi w językach golfa zniechęcić cię od odpowiedzi księgowania w innych językach.

Bramy NAND, 237

Utworzono za pomocą Logisim

Wejścia są 3-bitowymi binarnymi bez znaku, wprowadzonymi po lewej stronie. Wyjścia (2 bity) są po prawej stronie.

Jest zbyt duży, aby zmieścił się na ekranie, a Logisim nie może powiększyć, więc obraz jest czarno-biały. Przepraszam :(

Działa dla wszystkich przypadków testowych.

Prawdopodobnie jest lepszy sposób, aby to zrobić za pomocą obwodu pamięci, umożliwiając ponowne użycie dużych sekcji.

Galaretka ,  12  11 bajtów

NṢ€>/Ṡḟ-o-S

Monadyczny link pobierający listę Defender, Attackerrzutów (każda jako lista), zwracający liczbę całkowitą pomiędzy -2i 2włącznie (straty obrońcy - straty atakującego):

result : [def, atk]
    -2 : [  0,   2]
    -1 : [  0,   1]
     0 : [  1,   1]
     1 : [  1,   0]
     2 : [  2,   0]

Wypróbuj online! lub zobacz pakiet testowy (który mapuje wyniki do formatu OP).

W jaki sposób?

NṢ€>/Ṡḟ-o-S - Link: list [list Def, list Atk]
N           - negate all the rolls
 Ṣ€         - sort €ach of the lists of -1*rolls (max rolls are to the left now)
    /       - reduce by:
   >        -   is greater than?  (when len(Atk) > len(Def) leaves trailing negatives)
     Ṡ      - sign (maps all negatives to -1; zeros and ones of comparison unchanged)
       -    - literal -1
      ḟ     - filter discard (remove the -1s)
         -  - literal -1
        o   - logical or, vectorises (replaces the zeros with minus ones)
          S - sum

Siatkówka , 82 bajty

%O^`.
((.)+).*(¶(?<-2>.)+)(?(2)(?!)).*
$1$3
O$`.
$.%`
\d
$*1D
(1+)D1*\1

1+D
A
O`.

Wypróbuj online! Pierwsza linia danych to kości atakującego, druga to kości obrońcy. Powroty (w osobnych liniach) AA, AD, DD, Aczy Djest to właściwe.

Python 2 , 83 75 bajtów

x=0
k=map(sorted,input())
while all(k):x+=cmp(*map(list.pop,k))or 1
print-x

Wypróbuj online!

Wyjściem są straty obrońców - straty atakujących

MATL , 23 bajty

oH2$S1&Y)Y&t1M>t~b,Y&sD

Wypróbuj online!

Nie jestem pewien, dlaczego obrońcy mają więcej kości niż atakujący, ale może nie jestem zbyt dobrze zorientowany w ryzyku. Program podstawowy jest taki >t~,sD, że wszystkie pozostałe bajty pozwalają na różne długości wejściowe, z odrobiną sortowania. Dane wejściowe to atakujący, a następnie obrońca, wyjście to straty atakującego, a następnie straty obrońcy.

o    % Convert input to numeric array, padding with zeroes 
H2$S % Sort row-wise (specified to prevent 1v1 sorting)
1&Y) % Split attacker/defender
Y&t  % Logical and to filter out excess dice. Duplicate for 'do twice' later.
1M>  % Get throws again, decide who won
t~   % And the inverse to decide who lost
b,   % Bubble filter to the top. Do twice:
  Y& % Apply filter
  sD % Sum of losses. Display.

JavaScript (SpiderMonkey) , 97 83 78 bajtów

d=>a=>{for(u=v=0;d.sort()>[]&a.sort()>[];)a.pop()>d.pop()?u++:v++
return[u,v]}

Wypróbuj online!

-4 bajty i naprawiono dzięki @ovs i @Craig Ayre
-1 bajt dzięki @Shaggy

Łuska , 10 bajtów

M#eI¬¤z>Ö>

Wypróbuj online!

Wprowadź jako dwie osobne listy rzutów, wyprowadzaj jak w op.

Wyjaśnienie

¤z>Ö> sortuje każdą listę w kolejności malejącej, a następnie zamyka je, porównując odpowiednie elementy (i obcinając dłuższą listę).

M#eI¬tworzy 2-elementową listę ( e) z counts ( #) wartości prawdziwych (poprzez tożsamość I) i wartości falsy (poprzez logiczną negację ¬)

Perl 5 , 66 + 1 (-a) = 67 bajtów

@A=sort split/ /,<>;$b+=@A?pop@A>$_?-1:1:0for reverse sort@F;say$b

Wypróbuj online!

Wejście:

Dwie linie. Pierwsza linia to obrońca (gracz 1), druga to atakujący (gracz 2). Poszczególne rolki oddzielone spacjami.

Wynik:

Wskazuje efektywną zmianę siły obrońcy w stosunku do atakującego.

Output Attacker Defender
   2      0        2        Defender wins both
   1      0        1        Defender wins the only roll
   0      1        1        Attacker wins first, defender wins second
  -1      1        0        Attacker wins the only roll
  -2      2        0        Attacker wins both rolls

Galaretka , 30 bajtów

0,0‘⁸Ṁ€</¤¦‘⁸ḟ"Ṁ€⁺</¤¦⁸L€Ṃ>1¤¡

Wypróbuj online!

Veeeeeeeery golfa! > _ <

Generuje wartości dokładnie tak, jak w przypadkach testowych.

R , 46 bajtów

function(x,y)s(s(y,T)[1:2]>s(x,T)[1:2])
s=sort

Wypróbuj online!

Wszystko to robi trzy rodzaje i jedno porównanie ... plus wyodrębnienie pierwszych dwóch elementów w środku.

Dane wejściowe to dwa wektory rzutów kostką.

Dane wyjściowe kodowane w następujący sposób:

╔═══╦═══╗
║atk║def║
╠═══╬═══╣
║ 1 ║ 0 ║ TRUE
║ 0 ║ 1 ║ FALSE
║ 2 ║ 0 ║ TRUE  TRUE
║ 1 ║ 1 ║ FALSE TRUE
║ 0 ║ 2 ║ FALSE FALSE
╚═══╩═══╝

Działa, ponieważ ekstrakcja w R nie przetwarza swojego argumentu, ale uzupełnia wynik, NAaby uzyskać żądaną długość.