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
1o2enteros en el conjunto[1,2,3,4,5,6]. Rollos del atacante son una lista de1a3nú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.
