Dadas duas listas de jogadas de dados para uma batalha em Risco, seu programa ou função deve gerar quantas tropas cada jogador perde.

fundo

^{Você não precisa ler isso, pois é apenas um pano de fundo. Vá para o subtítulo "Tarefa" para continuar inabalável.}

No jogo de risco , um jogador pode atacar outro jogador (na verdade, isso é necessário para vencer). O resultado de uma batalha é determinado pelo lançamento de dados. Toda batalha ocorre como uma sucessão de sub-batalhas nas quais cada jogador pode perder até 2suas peças do exército.

Em uma sub-batalha, o defensor e o atacante jogam vários dados cujo número pode variar de acordo com circunstâncias irrelevantes para esse desafio. O dado de maior valor do atacante é comparado ao dado de maior valor do defensor. Se o dado do atacante for maior que o dado do defensor, o defensor perde uma peça. Caso contrário, o atacante perde uma peça.

Então, se ambos os jogadores tiverem pelo menos dois dados, o segundo valor mais alto dos dois jogadores será comparado. Novamente, se o dado do atacante for maior que o dado do defensor, o defensor perde uma peça. Caso contrário, o atacante perde uma peça.

(O defensor vence o empate. Se o defensor e o atacante rolarem a 4, o atacante perderá uma peça.)

_{Nesta sub-batalha do artigo da Wikipedia, os dados do atacante são vermelhos e os dados do defensor são brancos. O maior dos dados do atacante é 4e o maior dos dados do defensor 3. Como o atacante estava mais alto, o defensor perde uma peça. Os segundos mais altos são 3para o atacante e 2para o defensor. Como o atacante voltou a subir, o defensor perde outra peça. Assim, nesta sub-batalha, o atacante não perde peças e o defensor perde 2peças.}

Observe que as terceiras partes mais altas não são comparadas. Isso ocorre porque o defensor não tem mais do que dois dados em uma única sub-batalha, portanto, não há terceiros terceiros maiores para comparar.

Tarefa

Dadas as jogadas de dados não ordenadas (inteiros no intervalo de 1 a 6, inclusive), tanto do atacante quanto do defensor de uma sub-batalha de Risco, em qualquer forma conveniente, produza o número de peças do exército que cada jogador perde. A saída pode estar em qualquer forma conveniente, desde que tenha saídas diferentes para indicar as cinco possibilidades. Você deve indicar quais são essas diferentes saídas em sua pergunta.

A saída é determinada da seguinte forma: Comece com def=0e atk=0. Se o maior valor da lista de jogadas de dados do atacante for maior que o maior valor da lista de jogadas de dados do defensor, então aumente def. Caso contrário, incremente atk.

Se as duas listas de jogadas de dados tiverem pelo menos comprimento 2, então: se o segundo maior valor da lista de jogadas de dados do atacante for maior que o segundo maior valor da lista, aumente defe, de outra forma, aumente atk.

Por fim, o programa ou função deve gerar um identificador exclusivo para cada uma das 5 possibilidades de saída a seguir:

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

Exemplo

Defensor: [3, 2] Atacante: [2, 4, 1] Máximo de defensor 3e máximo de atacante 4. 4>3, então o def=1 segundo do defensor é 2e o segundo do atacante é 2. Not(2>2)então atk=1. A saída poderia ser então [1,1].

Casos de teste

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]

Implementação de amostra

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

Especificações

• A entrada pode ser tomada como qualquer forma que codifique claramente apenas as jogadas do defensor e as jogadas do atacante.
• A saída pode estar em qualquer forma que forneça uma saída exclusiva para cada uma das cinco possibilidades listadas acima.
• Rolos do defensor são uma lista de 1ou 2inteiros no conjunto [1,2,3,4,5,6]. Rolos do atacante são uma lista de 1para 3inteiros no conjunto [1,2,3,4,5,6].
• Como se trata de código-golfe , o código mais curto em cada idioma vence! Você não deixar respostas em línguas golfe desanimá-lo de respostas postar em outras línguas.

Portões NAND, 237

Criado com o Logisim

As entradas são binárias sem sinal de 3 bits, inseridas à esquerda. As saídas (2 bits) estão à direita.

É muito grande para caber na tela e o Logisim não pode ampliar, portanto a imagem é em preto e branco. Desculpe :(

Funciona para todos os casos de teste.

Provavelmente, há uma maneira melhor de fazer isso usando algum circuito de memória, permitindo que grandes seções sejam reutilizadas.

Geléia ,  12  11 bytes

NṢ€>/Ṡḟ-o-S

Um link monádico que faz uma lista de Defender, Attackerjogadas (cada uma como listas), retornando um número inteiro entre -2e 2inclusive (perdas do defensor - perdas do atacante):

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

Experimente online! ou consulte um conjunto de testes (que mapeia os resultados para o formato OP).

Quão?

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`.

Experimente online! A primeira linha de entrada é o dado do atacante, a segunda é o dado do defensor. Retornos (em linhas separadas) AA, AD, DD, Aou Dcomo apropriado.

Python 2 , 83 75 bytes

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

Experimente online!

Saída é perdas do defensor - perdas do atacante

MATL , 23 bytes

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

Experimente online!

Não sei por que os defensores têm mais dados do que os atacantes, mas talvez eu não seja tão versado em risco. O programa principal é justo >t~,sD, todos os outros bytes existem para permitir diferentes comprimentos de entrada, com um pouco de classificação. A entrada é atacante seguida pelo defensor, a saída é perda do atacante seguida por perdas do 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]}

Experimente online!

-4 bytes e correções graças a @ovs e @Craig Ayre
-1 byte graças a @Shaggy

Casca , 10 bytes

M#eI¬¤z>Ö>

Experimente online!

Introduza como duas listas separadas de rolos, produza como no op.

Explicação

¤z>Ö> classifica cada lista em ordem decrescente e, em seguida, compacta-os comparando os elementos correspondentes (e truncando a lista mais longa).

M#eI¬cria uma lista de 2 elementos ( e) com contagens ( #) de valores verdadeiros (através da identidade I) e valores falsificados (através da negação lógica ¬)

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

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

Experimente online!

Entrada:

Duas linhas. A primeira linha é defensora (jogador 1), a segunda é atacante (jogador 2). Rolos individuais separados por espaços.

Resultado:

Indica mudança efetiva na força do defensor contra o 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

Gelatina , 30 bytes

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

Experimente online!

Veeeeeeeery ungolfed! > _ <

Emite valores exatamente como nos casos de teste.

R , 46 bytes

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

Experimente online!

Tudo isso faz três tipos e uma comparação ... além de extrair os dois primeiros elementos no meio.

A entrada é dois vetores de rolos de dados.

Saída codificada da seguinte forma:

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

Funciona porque a extração em R não recicla seu argumento, mas preenche o resultado com NAo comprimento solicitado.