Ausgehend von zwei Listen mit Würfeln für einen Kampf im Risiko muss Ihr Programm oder Ihre Funktion ausgeben, wie viele Truppen jeder Spieler verliert.

Hintergrund

^{Sie müssen dies nicht lesen, denn es handelt sich lediglich um Hintergrundinformationen. Springe zur Unterüberschrift "Aufgabe", um unvermindert fortzufahren.}

Im Risikospiel kann ein Spieler einen anderen Spieler angreifen (tatsächlich ist dies erforderlich, um zu gewinnen). Der Ausgang eines Kampfes wird durch das Würfeln bestimmt. Jede Schlacht besteht aus einer Abfolge von Teilkämpfen, in denen jeder Spieler bis zu einem 2seiner Armeestücke verlieren kann .

In einem Teilkampf werfen der Verteidiger und der Angreifer jeweils mehrere Würfel, deren Anzahl je nach Umständen variieren kann, die für diese Herausforderung nicht relevant sind. Der am höchsten bewertete Würfel des Angreifers wird mit dem am höchsten bewerteten Würfel des Verteidigers verglichen. Wenn der Würfel des Angreifers höher ist als der des Verteidigers, verliert der Verteidiger ein Teil. Ansonsten verliert der Angreifer ein Teil.

Wenn beide Spieler mindestens zwei Würfel haben, werden die zweithöchsten Würfel der beiden Spieler verglichen. Wenn der Würfel des Angreifers höher ist als der des Verteidigers, verliert der Verteidiger ein Teil. Ansonsten verliert der Angreifer ein Teil.

(Verteidiger gewinnt Unentschieden. Wenn sowohl Verteidiger als auch Angreifer einen Wurf 4ausführen, verliert der Angreifer eine Figur.)

_{In diesem Teilkampf aus dem Wikipedia-Artikel sind die Würfel des Angreifers rot und die des Verteidigers weiß. Der höchste Würfel des Angreifers 4und der höchste des Verteidigers 3. Da der Angreifer höher war, verliert der Verteidiger ein Stück. Die zweithöchsten sind 3für den Angreifer und 2für den Verteidiger. Da der Angreifer wieder höher war, verliert der Verteidiger ein weiteres Stück. In diesem Teilkampf verliert der Angreifer also keine Steine ​​und der Verteidiger verliert 2Steine.}

Beachten Sie, dass die dritthöchsten Stücke nicht verglichen werden. Dies liegt daran, dass der Verteidiger in einem Teilkampf nicht mehr als zwei Würfel hat. Es gibt also keine dritthöchsten Stücke, die jemals verglichen werden könnten.

Aufgabe

Ausgehend von den unsortierten Würfeln (ganze Zahlen im Bereich von 1 bis einschließlich 6) sowohl des Angreifers als auch des Verteidigers einer Teilschlacht des Risikos in einer beliebigen zweckmäßigen Form, geben Sie die Anzahl der Armeestücke aus, die jeder Spieler verliert. Die Ausgabe kann in einer beliebigen zweckmäßigen Form erfolgen, sofern sie unterschiedliche Ausgaben aufweist, um die fünf Möglichkeiten anzuzeigen. Sie müssen angeben, welche unterschiedlichen Ausgänge in Ihrer Frage enthalten sind.

Die Ausgabe wird wie folgt bestimmt: Beginnen Sie mit def=0und atk=0. Ist der größte Wert der Würfelwurfliste des Angreifers größer als der größte Wert der Würfelwurfliste des Verteidigers, erhöhen Sie ihn def. Andernfalls inkrementieren atk.

Wenn beide Würfelwurflisten mindestens eine Länge haben 2, gilt Folgendes: Wenn der zweitgrößte Wert der Würfelwurfliste des Angreifers größer ist als der zweitgrößte Wert der Liste, erhöhen Sie defund erhöhen Sie ihn ansonsten atk.

Schließlich muss das Programm oder die Funktion eine eindeutige Kennung für jede der folgenden 5 Ausgabemöglichkeiten ausgeben:

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

Beispiel

Verteidiger: [3, 2] Angreifer : Maximaler [2, 4, 1] Verteidiger 3und maximaler Angreifer 4. 4>3, so ist der def=1 Zweite des Verteidigers 2und der Zweite des Angreifers 2. Not(2>2)so atk=1. Die Ausgabe könnte dann sein [1,1].

Testfälle

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]

Beispielimplementierung

Python 2 oder 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]    

Spezifikationen

• Die Eingabe kann in jeder Form erfolgen, bei der nur die Würfel des Verteidigers und des Angreifers eindeutig codiert sind .
• Die Ausgabe kann in einer beliebigen Form erfolgen, die eine eindeutige Ausgabe für jede der fünf oben aufgeführten Möglichkeiten bietet.
• Die Rollen des Verteidigers sind eine Liste 1oder 2ganze Zahlen im Satz [1,2,3,4,5,6]. Der Angreifers Rollen sind eine Liste der 1zu 3ganzen Zahlen in der Menge [1,2,3,4,5,6].
• Da dies Codegolf ist , gewinnt der kürzeste Code in jeder Sprache ! Sie nicht lassen Antworten in Golf Sprachen entmutigen zu veröffentlichen Antworten in anderen Sprachen.

NAND-Tore, 237

Erstellt mit Logisim

Die Eingänge sind 3-Bit-Binäreingänge ohne Vorzeichen, die links eingegeben werden. Die Ausgänge (2 Bits) befinden sich rechts.

Es ist zu groß, um auf den Bildschirm zu passen, und Logisim kann nicht zoomen, sodass das Bild schwarzweiß ist. Es tut uns leid :(

Funktioniert für alle Testfälle.

Es gibt wahrscheinlich einen besseren Weg, dies mit einer Speicherschaltung zu tun, damit große Abschnitte wiederverwendet werden können.

Jelly ,  12  11 Bytes

NṢ€>/Ṡḟ-o-S

Ein monadischer Link, der eine Liste von Defender, AttackerWürfeln (jeweils als Listen) erstellt und eine ganze Zahl zwischen -2und 2einschließlich zurückgibt (Verteidigerverluste - Angreiferverluste):

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

Probieren Sie es online! oder sehen Sie sich eine Testsuite an (die die Ergebnisse dem OP-Format zuordnet).

Wie?

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

Netzhaut , 82 Bytes

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

1+D
A
O`.

Probieren Sie es online! Die erste Eingabezeile sind die Würfel des Angreifers, die zweite die Würfel des Verteidigers. Returns (in separaten Zeilen) AA, AD, DD, Aoder Dnach Bedarf.

Python 2 , 83 75 Bytes

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

Probieren Sie es online!

Das Ergebnis sind Verteidigerverluste - Angreiferverluste

MATL , 23 Bytes

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

Probieren Sie es online!

Ich bin mir nicht sicher, warum Verteidiger mehr Würfel als Angreifer haben dürfen, aber vielleicht kenne ich mich mit Risiko nicht so gut aus. Das Kernprogramm besteht darin >t~,sD, dass alle anderen Bytes unterschiedliche Eingabelängen zulassen, wobei eine gewisse Sortierung vorgenommen wird. Die Eingabe erfolgt durch Angreifer gefolgt von Verteidiger, die Ausgabe durch Angreifer gefolgt von Verteidigerverlusten.

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 Bytes

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

Probieren Sie es online!

-4 Bytes und fest dank @ovs und @Craig Ayre
-1 Bytes dank @Shaggy

Schale , 10 Bytes

M#eI¬¤z>Ö>

Probieren Sie es online!

Eingabe als zwei getrennte Listen von Rollen, Ausgabe wie bei der Operation.

Erläuterung

¤z>Ö> sortiert jede Liste in absteigender Reihenfolge und zippt sie dann, um die entsprechenden Elemente zu vergleichen (und die längere Liste abzuschneiden).

M#eI¬Erstellt eine 2-Elemente-Liste ( e) mit Zählwerten ( #) von Wahrheitswerten (durch Identität I) und falschen Werten (durch logische Negation ¬).

Perl 5 , 66 + 1 (-a) = 67 Bytes

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

Probieren Sie es online!

Eingang:

Zwei Linien. Die erste Linie ist Verteidiger (Spieler 1), die zweite ist Angreifer (Spieler 2). Einzelne Rollen durch Leerzeichen getrennt.

Ausgabe:

Zeigt eine effektive Änderung der Stärke des Verteidigers gegenüber dem Angreifer an.

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

Gelee , 30 Bytes

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

Probieren Sie es online!

Veeeeeeeery ungolfed! > _ <

Gibt Werte genau wie in Testfällen aus.

R , 46 Bytes

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

Probieren Sie es online!

Alles, was dies bewirkt, sind drei Sortierungen und ein Vergleich ... plus Extrahieren der ersten beiden Elemente in der Mitte.

Die Eingabe erfolgt über zwei Vektoren von Würfeln.

Ausgabe wie folgt codiert:

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

Funktioniert, weil beim Extrahieren in R das Argument nicht wiederverwendet wird, sondern das Ergebnis mit NAaufgefüllt wird, um die angeforderte Länge zu erhalten.