Dadas dos listas de tiradas de dados para una batalla en Riesgo, tu programa o función debe generar cuántas tropas pierde cada jugador.

Antecedentes

^{No tiene que leer esto, ya que es simplemente un fondo. Pase al subtítulo "Tarea" para continuar sin disminuir.}

En el juego de Riesgo , un jugador puede atacar a otro jugador (de hecho, esto es necesario para ganar). El resultado de una batalla está determinado por el lanzamiento de dados. Cada batalla ocurre como una sucesión de sub-batallas en las que cada jugador puede perder hasta 2sus piezas de ejército.

En una sub batalla, el defensor y el atacante lanzan varios dados cuyo número puede variar según las circunstancias irrelevantes para este desafío. El dado de mayor valor del atacante se compara con el dado de mayor valor del defensor. Si el dado del atacante es más alto que el dado del defensor, el defensor pierde una pieza. De lo contrario, el atacante pierde una pieza.

Luego, si ambos jugadores tienen al menos dos dados, se comparan los segundos dados con el valor más alto de los dos jugadores. Nuevamente, si el dado del atacante es más alto que el dado del defensor, el defensor pierde una pieza. De lo contrario, el atacante pierde una pieza.

(El defensor gana lazos. Si tanto el defensor como el atacante tiran un 4, entonces el atacante pierde una pieza).

_{En esta sub batalla del artículo de Wikipedia, los dados del atacante son rojos y los dados del defensor son blancos. El más alto de los dados del atacante es 4y el más alto del defensor es 3. Como el atacante era más alto, el defensor pierde una pieza. Los segundos más altos son 3para el atacante y 2para el defensor. Como el atacante volvió a estar más alto, el defensor pierde otra pieza. Así, en esta subbatalla, el atacante no pierde piezas y el defensor pierde 2piezas.}

Tenga en cuenta que las terceras piezas más altas no se comparan. Esto se debe a que el defensor no tiene más de dos dados en una sola sub-batalla, por lo que no hay terceras piezas más altas para comparar.

Tarea

Dadas las tiradas de dados sin clasificar (enteros en el rango de 1 a 6 inclusive) tanto del atacante como del defensor de una sub-batalla de Riesgo en cualquier forma conveniente, genera el número de piezas de ejército que pierde cada jugador. La salida puede estar en cualquier forma conveniente, siempre que tenga diferentes salidas para indicar las cinco posibilidades. Debe indicar cuáles son esos diferentes resultados en su pregunta.

La salida se determina de la siguiente manera: Comience con def=0y atk=0. Si el mayor valor de la lista de tiradas de dados del atacante es mayor que el mayor valor de la lista de tiradas de dados del defensor, entonces incremente def. De lo contrario, incremente atk.

Si ambas listas de tiradas de dados tienen una longitud de al menos 2, entonces: si el segundo mayor valor de la lista de tiradas de dados del atacante es mayor que el segundo mayor valor de la lista, entonces incremente defe incremente de otro modo atk.

Finalmente, el programa o función debe generar un identificador único para cada una de las siguientes 5 posibilidades de salida:

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

Ejemplo

Defensor: [3, 2] atacante: el [2, 4, 1] máximo de defensor es 3y el máximo de atacante es 4. 4>3, entonces el def=1 segundo del defensor es 2y el segundo del atacante es 2. Not(2>2), De modo atk=1. La salida podría ser entonces [1,1].

Casos de prueba

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]

Implementación de muestra

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

Especificaciones

• La entrada puede tomarse como cualquier forma que codifique claramente solo las tiradas del defensor y las tiradas del atacante.
• El resultado puede ser de cualquier forma que proporcione un resultado único para cada una de las cinco posibilidades enumeradas anteriormente.
• Las tiradas del defensor son una lista de 1o 2enteros en el conjunto [1,2,3,4,5,6]. Rollos del atacante son una lista de 1a 3números enteros en el conjunto [1,2,3,4,5,6].
• Como se trata de código de golf , ¡el código más corto en cada idioma gana! No , no permiten respuestas en idiomas golf que desalientan de publicar respuestas en otros idiomas.

Puertas NAND, 237

Creado con Logisim

Las entradas son binarias sin signo de 3 bits, ingresadas a la izquierda. Las salidas (2 bits) están a la derecha.

Es demasiado grande para caber en la pantalla y Logisim no puede hacer zoom, por lo que la imagen es en blanco y negro. Lo siento :(

Funciona para todos los casos de prueba.

Es probable que haya una mejor manera de hacer esto usando un circuito de memoria, permitiendo reutilizar grandes secciones.

Jalea ,  12  11 bytes

NṢ€>/Ṡḟ-o-S

Un enlace monádico que toma una lista de Defender, Attackertiradas (cada una como listas), que devuelve un número entero entre -2e 2inclusivo (pérdidas del defensor - pérdidas del atacante):

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

Pruébalo en línea! o vea un conjunto de pruebas (que asigna los resultados al formato OP).

¿Cómo?

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

Retina , 82 bytes

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

1+D
A
O`.

Pruébalo en línea! La primera línea de entrada es el dado del atacante, la segunda es el dado del defensor. Devuelve (en líneas separadas) AA, AD, DD, Ao Dsegún el caso.

Python 2 , 83 75 bytes

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

Pruébalo en línea!

La salida es pérdidas del defensor - pérdidas del atacante

MATL , 23 bytes

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

Pruébalo en línea!

No estoy seguro de por qué a los defensores se les permiten más dados que atacantes, pero tal vez no estoy tan versado en Riesgo. El programa principal es justo >t~,sD, todos los otros bytes están ahí para permitir diferentes longitudes de entrada, con un poco de clasificación. La entrada es el atacante seguido por el defensor, la salida son las pérdidas del atacante seguidas por las pérdidas del defensor.

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]}

Pruébalo en línea!

-4 bytes y arreglado gracias a @ovs y @Craig Ayre
-1 byte gracias a @Shaggy

Casco , 10 bytes

M#eI¬¤z>Ö>

Pruébalo en línea!

Entrada como dos listas separadas de rollos, salida como en el op.

Explicación

¤z>Ö> ordena cada lista en orden descendente y luego las comprime comparando los elementos correspondientes (y truncando la lista más larga).

M#eI¬crea una lista de 2 elementos ( e) con recuentos ( #) de valores verdaderos (a través de la identidad I) y valores falsos (a través de la negación lógica ¬)

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

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

Pruébalo en línea!

Entrada:

Dos lineas. La primera línea es defensor (jugador 1), la segunda es atacante (jugador 2). Rollos individuales separados por espacios.

Salida:

Indica un cambio efectivo en la fuerza del defensor contra el atacante.

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

Jalea , 30 bytes

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

Pruébalo en línea!

¡ Veeeeeeeery sin golf! > _ <

Emite valores exactamente como en los casos de prueba.

R , 46 bytes

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

Pruébalo en línea!

Todo esto hace tres tipos y una comparación ... además de extraer los dos primeros elementos en el medio.

La entrada es dos vectores de tiradas de dados.

Salida codificada de la siguiente manera:

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

Funciona porque la extracción en R no recicla su argumento, pero rellena el resultado NApara llegar a la longitud solicitada.