Dati due elenchi di tiri di dado per una battaglia in Rischio, il tuo programma o funzione deve generare quante truppe perde ogni giocatore.
sfondo
Non devi leggere questo, perché è solo uno sfondo. Passa al sottotitolo "Attività" per continuare senza sosta.
Nel gioco del Rischio , un giocatore può attaccare un altro giocatore (in effetti, questo è necessario per vincere). Il risultato di una battaglia è determinato dal lancio di dadi. Ogni battaglia si svolge come una successione di sotto-battaglie in cui ogni giocatore può perdere fino a 2dei propri pezzi dell'esercito.
In una battaglia secondaria, il difensore e l'attaccante lanciano ciascuno diversi dadi il cui numero può variare in base a circostanze irrilevanti per questa sfida. Il dado più valutato dell'attaccante viene confrontato con il dado più valutato del difensore. Se il dado dell'attaccante è più alto del dado del difensore, il difensore perde un pezzo. Altrimenti, l'attaccante perde un pezzo.
Quindi, se entrambi i giocatori hanno almeno due dadi, vengono confrontati i dadi con il secondo valore più alto dei due giocatori. Ancora una volta, se il dado dell'attaccante è più alto del dado del difensore, il difensore perde un pezzo. Altrimenti, l'attaccante perde un pezzo.
(Il difensore vince i pareggi. Se sia il difensore che l'attaccante tirano a 4, l'attaccante perde un pezzo.)
In questa sotto-battaglia dell'articolo di Wikipedia, i dadi dell'attaccante sono rossi e i dadi del difensore sono bianchi. Il più alto dei dadi dell'attaccante è 4e il più alto dei difensori è 3. Poiché l'attaccante era più alto, il difensore perde un pezzo. I secondi più alti sono 3per l'attaccante e 2per il difensore. Dato che l'attaccante era di nuovo più alto, il difensore perde un altro pezzo. Pertanto, in questa sotto-battaglia, l'attaccante non perde pezzi e il difensore perde 2pezzi.
Si noti che i terzi pezzi più alti non vengono confrontati. Questo perché il difensore non ha più di due dadi in una singola battaglia secondaria, quindi non ci sono pezzi del terzo più alto da confrontare in assoluto.
Compito
Dati i tiri di dado non ordinati (numeri interi compresi tra 1 e 6) sia dell'attaccante che del difensore di una sotto-battaglia di Rischio in qualsiasi forma conveniente, ottieni il numero di pezzi dell'esercito che ogni giocatore perde. L'output può essere in qualsiasi forma conveniente, purché abbia output diversi per indicare le cinque possibilità. Devi indicare quali sono questi diversi output nella tua domanda.
L'output è determinato come segue: iniziare con def=0e atk=0. Se il valore più grande dell'elenco dei tiri di dado dell'attaccante è maggiore del valore più grande dell'elenco dei tiri di dado del difensore, quindi incrementare def. Altrimenti, incremento atk.
Se almeno entrambi gli elenchi di tiri di dado hanno lunghezza 2, quindi: se il secondo valore più grande dell'elenco di tiri di dado dell'attaccante è maggiore del secondo valore più grande dell'elenco, incrementare defe altrimenti aumentare atk.
Infine, il programma o la funzione deve generare un identificatore univoco per ciascuna delle seguenti 5 possibilità di output:
╔═══╦═══╗
║atk║def║
╠═══╬═══╣
║ 1 ║ 0 ║
║ 0 ║ 1 ║
║ 2 ║ 0 ║
║ 1 ║ 1 ║
║ 0 ║ 2 ║
╚═══╩═══╝
Esempio
Difensore: [3, 2]
attaccante: [2, 4, 1]
massimo del difensore è 3e massimo dell'attaccante 4. 4>3, quindi il def=1
secondo difensore è 2e il secondo attaccante è 2. Not(2>2)così atk=1. L'output potrebbe quindi essere [1,1].
Casi test
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]
Implementazione di esempio
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]
specificazioni
- L'input può essere preso come qualsiasi forma che codifica chiaramente solo i tiri del difensore e quelli dell'attaccante.
- L'output può essere in qualsiasi forma che fornisce un output unico per ciascuna delle cinque possibilità sopra elencate.
- I tiri del difensore sono un elenco
1o2numeri interi nel set[1,2,3,4,5,6]. Rotoli Il dell'attaccante sono un elenco di1per3interi nel set[1,2,3,4,5,6]. - Dato che si tratta di code-golf , vince il codice più corto in ogni lingua ! Do Non lasciare risposte in lingua golf scoraggiare dalle risposte pubblicazione in altre lingue.
