Regole di base (diverse dalle mie)

Storia

È l'anno 4579, gli umani ora hanno 2 mani con 1001 dita ciascuna. Le bacchette si sono basate su punti. E @Dennis ha più rappresentanti di @Martin ... I cerchi rossi disegnati a mano sono ora sottoposti a downvoting ... Jon Skeet ha raggiunto 2 trilioni di rep su ogni sito SE ... Sì, lo so, lo so

Le bacchette sono un gioco a mano che è stato risolto. Quindi per aggirare questo l'ho creato mutato. Ho aumentato la quantità di dita.

Le regole del gioco

Il modo in cui questo è giocato

Tutti iniziano con 2 mani. Ogni mano ha 1001 dita. Ogni mano inizia con 1 (un) dito su ogni mano. Durante il tuo turno puoi "colpire" la mano degli altri giocatori. Per colpirti scegli 1 delle tue mani con cui colpire e 1 delle loro mani per colpire. La mano che è stata colpita ora ha la quantità di dita che inizialmente era E la quantità di dita che avevi sulla mano con cui hai colpito.

EX

P1: 1,1 P2: 1,1. P1[0]colpi P2[1]. Adesso sono le dita P1:1,1 P2:1,2. Adesso P2[1]colpisce p1[0]. Le dita ora sono P1: 3,1P2 1,2.

Se una mano arriva a 1001 o più dita allora quella mano è fuori. Quindi il giocatore che ha ottenuto una mano (per il proprio turno) può "dividere". La divisione è quando prendi la mano che è dentro e dividi la metà delle dita (arrotondando per eccesso) e dai quelle dita all'altra mano per farla rientrare.

EX

P1: 1000,2P2 7,7. P2[0]colpi P1[0]. Il punteggio è P1: 0,2P2 1,1. P1[1]si divide per il suo turno e il punteggio è P1: 1,1e P2 7,7.

Il gioco termina quando un giocatore ha entrambe le mani. I punti vengono assegnati in base alla quantità di dita del vincitore. Più punti = meglio. Il perdente non guadagna punti.

Ci sono altre regole che vengono utilizzate, ma queste sono quelle utilizzate qui.

Tutti suonano tutti (round robin)

Fine del gioco

Totalizza i tuoi punti per ogni round vinto. Quindi fai la media di tutti i punti. Dividi il totale per i punti medi e ottieni il tuo punteggio finale. La maggior parte dei punti vince.

Regole effettive

Scappatoie standard

Per favore, non provare a risolvere il gioco. In realtà devo essere in grado di eseguirlo: P

Assicurati che il bot possa funzionare velocemente. A giudicare dalla durata dei round, ci vorrà del tempo

Tutte le librerie necessarie nel tuo programma devono essere nella libreria python predefinita. Elenca anche quelli che devi importare. Le importazioni saranno solo le importazioni di base (per la matematica che faccio import math:)

Le risposte devono funzionare in Python 3.x

handler

Il tuo bot sarà il suo file Python 3 con una playfunzione.

playsaranno passati due elenchi di due numeri ciascuno. Questo numero indica quante dita ci sono su ogni mano. Il primo elenco è di tua mano.

Se scegli di colpire la mano dell'altro giocatore, quindi restituisci un elenco di due bit. Il primo bit è l'indice della mano che stai usando per colpire ( 0per il primo, 1per l'ultimo), e il secondo bit è l'indice della mano che stai colpendo sull'avversario.

Se si sceglie di dividere, restituire qualsiasi altro valore di verità.

Tada!

Il controller può essere trovato qui . Salvare ciascun bot nel proprio file ed elencare il nome di ciascun bot (senza .py) in botnames.

Nota finale:

Tu e l'altro robot inizierete a turno per primi. Se il gioco non termina in 100.000 (centomila) round, il gioco verrà chiuso e nessuno dei due bot vincerà.

Il controller non è protetto dalle mosse che richiedono un'eternità, ma le spese generali non necessarie saranno fortemente disapprovate.

CodingAndAlgorithms

Questa risposta utilizza effettivamente la codifica e gli algoritmi, a differenza degli altri finora! _{riferimento: imgur} (batte anche tutte le risposte postate prima di questo)

def play(A, B):
    if sum(A) == 1:
        return [A.index(1), B.index(max(B))]
    elif max(A) + max(B) > 1000:
        return [A.index(max(A)), B.index(max(B))]
    elif 0 in A:
        return 1
    elif 0 in B:
        return [A.index(min(A)), 1-B.index(0)]
    else:
        return [A.index(min(A)), B.index(min(B))]

CautionBot

def play(s,o):
 if max(s)+max(o)>1000 and (all(s) or max(s)+min(o)<1001):
  return [s.index(max(s)),o.index(max(o))]
 else:
  return [s.index(min(s)),o.index(min(filter(bool,o)))]if all(s) else 'split'

CautionBot non vuole causare troppi problemi, quindi colpisce la più piccola delle mani dell'avversario con la sua mano più piccola se ha entrambe le mani, e altrimenti si divide. Tuttavia, CautionBot non è uno sciocco, quindi se può togliere la mano di un avversario senza perdere immediatamente il prossimo turno, lo farà invece della sua normale mossa.

Equalizzatore

def play(s, o):
    if not all(s):
        return 1
    else:
        return [s.index(max(s)), o.index(min(filter(bool, o)))]

Se all'equalizzatore manca una mano, si dividerà. Altrimenti, colpisce la mano più piccola dei suoi avversari con la sua mano più grande.

Aggressore

def play(s, o):
    return [s.index(max(s)),o.index(max(o))]if all(s)else 1

Un altro robot di partenza, Aggressor colpirà la più grande delle mani dell'avversario con la più grande delle sue stesse mani se entrambe le mani non sono vuote; altrimenti, si divide.

RandomBot

import random

def play(s, o):
    return [random.randint(0,1)for i in'  ']if all(s)else 1

Giusto per iniziare le cose, ecco un robot che fa un colpo casuale se le sue mani sono entrambe non vuote; altrimenti, si divide.

Golfato perché no: 3

Errore

Sì, questo è il nome del bot.

def play(s, o):
    if max(s)+max(o)>1000:
        return [s.index(max(s)),o.index(max(o))]
    if 0 in s:return ''
    return [s.index(max(s)),o.index(min(o))]

Ci sono arrivato testando con gli altri robot. Tuttavia è costantemente il penultimo nelle mie simulazioni. Quindi alla fine farò un altro robot.

Modifica: non riesco a scrivere alcun bot che vada al di sopra di WarningBot, e i miei test aggiuntivi sembrano indicare che questo è il secondo migliore, non il secondo peggiore.

marathoner

Ho modificato il codice di Aggressor fornito da "HyperNeutrino" per colpire semplicemente il più piccolo degli avversari con due mani con il più piccolo delle sue. Naturalmente è una strategia molto sciocca, ma non posso rifiutare di essere in cima a un grafico! (Anche se quel grafico sarebbe perdite)

Non sono sicuro se questo codice verrà eseguito senza errori perché non sono stato in grado di testarlo a causa del lavoro. Tuttavia, dovrebbe funzionare senza problemi.

def play(s, o):
     return [s.index(min(s)),o.index(min(o))]if all(s)else 1