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
1ou2inteiros no conjunto[1,2,3,4,5,6]. Rolos do atacante são uma lista de1para3inteiros 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.
