sfondo

Hex è un gioco di strategia astratto per due giocatori giocato su un K×Krombo di tessere esagonali. Due lati opposti del rombo sono di colore bianco, e gli altri due neri e i due giocatori, bianchi e neri, si alternano posizionando un gettone del loro colore su una tessera non occupata. Il giocatore che per primo riesce a costruire un percorso tra i lati opposti del loro colore è il vincitore. È noto che il gioco non può concludersi con un pareggio e che il primo giocatore ha una strategia vincente indipendentemente dalle dimensioni del tabellone (vedi la pagina Wikipedia per i dettagli).

L'obiettivo

In questa sfida, fissiamo le dimensioni della scheda K = 4e rappresentiamo la scheda come la griglia seguente. Le linee spesse indicano piastrelle adiacenti.

Il tuo compito è quello di produrre una strategia vincente per il primo giocatore, che puoi scegliere di essere bianco o nero. Ciò significa che qualunque mossa legale faccia il giocatore avversario, il tuo gioco deve tradursi in una vittoria. Il tuo input è una posizione di gioco (la disposizione dei token sul tabellone) e il tuo output è una mossa legale, nel formato specificato di seguito. Se vuoi trovare tu stesso una strategia vincente, non leggere questo spoiler:

Schema di una possibile strategia vincente, supponendo che il bianco sia il primo. Selezionare prima 5. Successivamente, se si dispone di un percorso da 5 alla riga inferiore OPPURE il nero seleziona 0 o 1 in qualsiasi momento, rispondere selezionando quale di 0 o 1 è libero. Se il nero seleziona 9 o 13, selezionare 10 e quindi quello tra 14 o 15 è vacante. Se il nero non seleziona 9, 13 o 14, selezionare 9 e il successivo tra 13 o 14 vuoti. Se il nero seleziona 14, rispondere selezionando 15. Successivamente, selezionare 10 se è vuoto; se il nero seleziona 10, rispondi con 11. Se il nero seleziona 6, rispondi con 7 e il successivo tra 2 o 3 è vacante. Se il nero non seleziona 6, selezionalo, in modo da avere un percorso da 5 alla riga inferiore.

Ingresso e uscita

Il tuo input è una stringa di 16 caratteri WBE, che significa bianco, nero e vuoto. Rappresentano le tessere del tabellone, come elencato sopra. Puoi scegliere il metodo di input (che determina anche il tuo metodo di output) tra i seguenti:

1. Ingresso da STDIN, uscita a STDOUT.
2. Input come argomento della riga di comando, output su STDOUT.
3. Input come 16 argomenti a riga di comando a carattere singolo, output su STDOUT.
4. Input come argomento della funzione denominata, output come valore di ritorno.

L'output rappresenta il riquadro su cui posizionare il token successivo, poiché è il tuo turno di muoversi. Puoi scegliere tra i seguenti formati di output:

1. Un indice a base zero (come usato nella figura sopra).
2. Un indice basato su uno.
3. La stringa di input con una Esostituita da qualunque di Wo Bhai scelto per il tuo giocatore.

Regole

La tua strategia deve essere deterministica. Non è necessario gestire correttamente posizioni di gioco non raggiungibili dal tabellone vuoto usando la propria strategia o posizioni che stanno già vincendo per entrambi i giocatori e si può schiantarsi su di esse. Viceversa, nei board raggiungibili utilizzando la tua strategia, devi restituire una mossa legale.

Questo è code-golf, quindi vince il numero di byte più basso. Le scappatoie standard non sono ammesse.

analisi

Ho scritto un controller Python 3 per la convalida delle voci, poiché sarebbe estremamente noioso da fare a mano. Puoi trovarlo qui . Supporta i primi tre formati di input e le funzioni di Python 3 (le funzioni in altre lingue devono essere inserite nei programmi), tutti e tre i formati di output ed entrambi i lettori. Se una strategia non sta vincendo, produrrà una partita persa trovata, quindi puoi modificare il tuo programma.

Marbelous, 973b

Questa è un'implementazione ingenua della strategia suggerita nella domanda. Si aspetta che la scheda sia fornita come 16 parametri della riga di comando / scheda madre simili hex.mbl B W E E E W E E E B E E E E E Ee produrrà la posizione indicizzata zero della prossima mossa del bianco.

00 }1 }0
&G B? W!
&0 &G &G
!!
00 }0 }1
&H B? W!
&1 &H &H
!!
.. }D .. }9 }9 }D }E }A }D }9 }A .. }E }F }5
}9 B! }E E? W? E? .. E? B? B? W? .. E? .. E?
B! ?0 B! &M &N &O E? &I \\ .. &J .. &K E? &5
?0 ++ ?0 &9 .. &D &P &A &I /\ &J .. &E &L !!
++ .. ++ !! .. !! &E !! \/ &L /\ &K !! &F
\\ .. // .. .. .. !! .. .. \/ .. \/ .. !!
.. =3 \/
&M /\ &N
\/ &O /\ &P
}0 }1 }6 .. }6 .. }7 &7 }2 }3 }A }A }B }E }F
..
..
..
..
..
..
..
..
..
.. .. .. .. .. .. .. .. .. .. .. .. .. B? W!
.. .. .. .. .. .. .. .. .. .. .. .. .. &Q &Q
.. .. .. .. B? .. E? W? E? .. E? B? E? &F \/
.. .. .. &S /\ &T &S &T &U E? &A &R &R !!
.. .. .. &7 .. .. \/ .. &2 &V !! &B \/
.. .. .. !! .. .. &U /\ &V &3 .. !!
.. .. .. .. .. .. .. .. .. !!
.. .. ..
.. .. E?
E? .. &6
&X E? !!
!! &Y
.. !!
}4 }8 }C
\/ \/ \/
30 30 31 31 32 33 35 36 37 39 31 30 31 31 31 33 31 34 31 35
&0 &X &1 &Y &2 &3 &5 &6 &7 &9 &A &A &B &B &D &D &E &E &F &F
:W?
}0
^4
=1
{0
:B?
}0
^0
=0
{0
:E?
}0
^1
=0
{0
:W!
}0
^4
=0
{0
:B!
}0
^0
>0
{0

Penso che probabilmente potrò giocare a circa 200 caratteri con una migliore ramificazione ed eliminazione del riutilizzo del codice.

Python 3, 100b

b=input()
i=b.find('B')
if b[i]in'BW'and'E'in b:i-=1+(b[i-1]is'W')*4
print((b[:i]+'B'+b[i+1:])[:16])

• Giocatore: NERO
• Metodo: STDIN / STDOUT, MODIFIED_BOARD

La strategia è prima cercare un Balla lavagna. Se non ce ne sono, questo ritorna -1, che in Python è uguale a last index. Quindi su una tavola vuota sarà il mio primo indice index=-1, che è dove inizio a muovermi.

Se il campo alla mia sinistra ( index-1) è libero, la mia prossima mossa ci va. Se è preso, salgo a sinistra. Non devo mai salire: se lo faccio, perdo il tempo e perdo la partita.

Su una pensione completa (non Eda nessuna parte) non faccio una mossa.

All'inizio printsembra un po 'strano: devo costruire la nuova scheda (cosa che faccio tramite lo slicing) ma poi devo ritagliare 16 caratteri. Questo è un relitto dal momento che lavoro con indici negativi e b[i+1:]quindi restituirò la buca e il resto che mi aspetto, rendendo importante tagliare il resto. Un altro modo sarebbe stato quello di lavorare con indici positivi, ad esempio prendendo (b.find('B')+16)%16, ma (+16)%16è un byte in più di ()[:16].

Ungolfed:

board = input()
index = board.find('B')
if board[index] in 'BW' and 'E' in board:
    index -= 1 + (board[index-1] is 'W') * 4
print((board[:index] + 'B' + board[index+1:])[:16])

Test

Durante l'esecuzione della suite di test del controller esadecimale, ho riscontrato alcuni comportamenti strani:

OUT: EEEEEEEEEEEEEEEB
OUT: WEEEEEEEEEEEEEBB
OUT: WWEEEEEEEEEEEBBB
OUT: WWWEEEEEEEEEBBBB
OUT: WWWWEEEEEEEBBBBB
OUT: WWWWWEEEEEBBBBBB
OUT: WWWWWWEEEBBBBBBB
OUT: WWWWWWWEBBBBBBBB
OUT: WWWWWWWWBBBBBBBB

Incorrect response 'WWWWWWWWBBBBBBBB' to message 'WWWWWWWWBBBBBBBB'.

Penso che avrei dovuto vincere dopo il 4 ° turno o rispondere con la stessa scheda a una pensione completa dovrebbe essere una risposta corretta. Non sono sicuro di cosa ci sia che non va, non mi sono immerso molto più in profondità - volevo solo controllare se ho coperto tutti i casi "speciali". Ma dal momento che non devo nascondere le situazioni in cui qualcuno inizia nello spazio 4 o giù di lì, non importa comunque.

85b

Tuttavia, se mi permetto di non verificare la presenza di una pensione completa (ovvero tralasciando la 'E' in bpossibilità di semplificare ulteriormente il codice per utilizzare solo 85 byte:

b=input();i=b.find('B')
if i!=-1:i-=1+(b[i-1]is'W')*4
print((b[:i]+'B'+b[i+1:])[:16])

Ciò porterà a quanto segue:

Incorrect response 'WWWBWWWWBBBBBBBB' to message 'WWWWWWWWBBBBBBBB'.

Questo potrebbe essere o non essere conteggiato, e poiché ho scoperto che non era una mossa valida ho deciso di andare per la risposta più lunga ma più corretta.