Il gioco
Giocherai a un gioco (quasi) standard di Connect-4 . Sfortunatamente, si tratta di un gioco di corrispondenza e qualcuno ha inserito un nastro nero su ogni seconda fila a partire dal basso, in modo da non poter vedere nessuna delle mosse del tuo avversario all'interno di queste file.
Qualsiasi mossa all'interno di colonne già piene verrà considerata come passare il tuo turno, e se una partita dura più a lungo dei 6 * 7
turni verrà giudicata come un pareggio.
Specifica della sfida
Il tuo programma dovrebbe essere implementato come una funzione Python 3. Il primo argomento è una "vista" del tabellone, che rappresenta lo stato del tabellone noto come un elenco 2D di righe dal basso verso l'alto in cui si 1
trova una mossa del primo giocatore, 2
una mossa del secondo giocatore e 0
una posizione vuota o nascosta mossa dal tuo avversario.
Il secondo argomento è un numero di turno indicizzato da 0
, e la sua parità ti dice quale giocatore sei.
L'argomento finale è uno stato arbitrario, inizializzato None
all'inizio di ogni partita, che puoi usare per preservare lo stato tra i turni.
Dovresti restituire una 2 tupla dell'indice della colonna che desideri giocare e il nuovo stato deve essere restituito al tuo prossimo turno.
punteggio
Una vittoria vale come +1
, un pareggio come 0
e una perdita come -1
. Il tuo obiettivo è raggiungere il punteggio medio più alto in un torneo round robin. Cercherò di eseguire tutte le partite necessarie per identificare un chiaro vincitore.
Regole
Ogni concorrente dovrebbe avere al massimo un bot concorrente alla volta, ma è OK aggiornare la tua iscrizione se apporti miglioramenti. Prova a limitare il tuo bot a ~ 1 secondo di tempo di riflessione per turno.
analisi
Ecco il codice sorgente per il controller, insieme ad alcuni bot di esempio non concorrenti per riferimento:
import itertools
import random
def get_strides(board, i, j):
yield ((i, k) for k in range(j + 1, 7))
yield ((i, k) for k in range(j - 1, -1, -1))
yield ((k, j) for k in range(i + 1, 6))
yield ((k, j) for k in range(i - 1, -1, -1))
directions = [(1, 1), (-1, -1), (1, -1), (-1, 1)]
def diag(di, dj):
i1 = i
j1 = j
while True:
i1 += di
if i1 < 0 or i1 >= 6:
break
j1 += dj
if j1 < 0 or j1 >= 7:
break
yield (i1, j1)
for d in directions:
yield diag(*d)
DRAWN = 0
LOST = 1
WON = 2
UNDECIDED = 3
def get_outcome(board, i, j):
if all(board[-1]):
return DRAWN
player = board[i][j]
strides = get_strides(board, i, j)
for _ in range(4):
s0 = next(strides)
s1 = next(strides)
n = 1
for s in (s0, s1):
for i1, j1 in s:
if board[i1][j1] == player:
n += 1
if n >= 4:
return WON
else:
break
return UNDECIDED
def apply_move(board, player, move):
for i, row in enumerate(board):
if board[i][move] == 0:
board[i][move] = player
outcome = get_outcome(board, i, move)
return outcome
if all(board[-1]):
return DRAWN
return UNDECIDED
def get_view(board, player):
view = [list(row) for row in board]
for i, row in enumerate(view):
if i % 2:
continue
for j, x in enumerate(row):
if x == 3 - player:
row[j] = 0
return view
def run_game(player1, player2):
players = {1 : player1, 2 : player2}
board = [[0] * 7 for _ in range(6)]
states = {1 : None, 2 : None}
for turn in range(6 * 7):
p = (turn % 2) + 1
player = players[p]
view = get_view(board, p)
move, state = player(view, turn, states[p])
outcome = apply_move(board, p, move)
if outcome == DRAWN:
return DRAWN
elif outcome == WON:
return p
else:
states[p] = state
return DRAWN
def get_score(counts):
return (counts[WON] - counts[LOST]) / float(sum(counts))
def run_tournament(players, rounds=10000):
counts = [[0] * 3 for _ in players]
for r in range(rounds):
for i, player1 in enumerate(players):
for j, player2 in enumerate(players):
if i == j:
continue
outcome = run_game(player1, player2)
if outcome == DRAWN:
for k in i, j:
counts[k][DRAWN] += 1
else:
if outcome == 1:
w, l = i, j
else:
w, l = j, i
counts[w][WON] += 1
counts[l][LOST] += 1
ranks = sorted(range(len(players)), key = lambda i: get_score(counts[i]), reverse=True)
print("Round %d of %d\n" % (r + 1, rounds))
rows = [("Name", "Draws", "Losses", "Wins", "Score")]
for i in ranks:
name = players[i].__name__
score = get_score(counts[i])
rows.append([name + ":"] + [str(n) for n in counts[i]] + ["%6.3f" % score])
lengths = [max(len(s) for s in col) + 1 for col in zip(*rows)]
for i, row in enumerate(rows):
padding = ((n - len(s)) * ' ' for s, n in zip(row, lengths))
print(''.join(s + p for s, p in zip(row, padding)))
if i == 0:
print()
print()
def random_player(view, turn, state):
return random.randrange(0, 7), state
def constant_player(view, turn, state):
return 0, state
def better_random_player(view, turn, state):
while True:
j = random.randrange(0, 7)
if view[-1][j] == 0:
return j, state
def better_constant_player(view, turn, state):
for j in range(7):
if view[-1][j] == 0:
return j, state
players = [random_player, constant_player, better_random_player, better_constant_player]
run_tournament(players)
Happy KoTHing!
Risultati provvisori
Name Draws Losses Wins Score
zsani_bot: 40 5377 94583 0.892
better_constant_player: 0 28665 71335 0.427
constant_player: 3 53961 46036 -0.079
normalBot: 38 64903 35059 -0.298
better_random_player: 192 71447 28361 -0.431
random_player: 199 75411 24390 -0.510