Contexte

Hex est un jeu de stratégie abstrait à deux joueurs joué sur un K×Klosange de tuiles hexagonales. Deux côtés opposés du losange sont de couleur blanche, et les deux autres noirs, et les deux joueurs, noir et blanc, se relaient en plaçant un jeton de leur couleur sur une tuile inoccupée. Le joueur qui réussit le premier à construire un chemin entre les côtés opposés de sa couleur est le gagnant. Il est connu que le jeu ne peut pas se terminer par un match nul et que le premier joueur a une stratégie gagnante quelle que soit la taille du plateau (voir la page Wikipedia pour plus de détails).

La tâche

Dans ce défi, nous fixons la taille de la carte à K = 4et représentons la carte comme la grille suivante. Les lignes épaisses indiquent les tuiles adjacentes.

Votre tâche consiste à produire une stratégie gagnante pour le premier joueur, que vous pouvez choisir d'être noire ou blanche. Cela signifie que quels que soient les mouvements légaux du joueur adverse, votre jeu doit aboutir à une victoire. Votre entrée est une position de jeu (l'arrangement des jetons sur le plateau) et votre sortie est un mouvement légal, dans le format spécifié ci-dessous. Si vous voulez trouver vous-même une stratégie gagnante, ne lisez pas ce spoiler:

Esquisse d'une stratégie gagnante possible, en supposant que le blanc passe en premier. Sélectionnez d'abord 5. Après cela, si vous avez un chemin de 5 à la ligne inférieure OU le noir sélectionne 0 ou 1 à tout moment, répondez en sélectionnant celui de 0 ou 1 qui est vacant. Si le noir sélectionne 9 ou 13, sélectionnez 10, puis celui de 14 ou 15 est vacant. Si le noir ne sélectionne pas 9, 13 ou 14, sélectionnez 9 et le suivant, le 13 ou le 14 étant vacant. Si le noir sélectionne 14, répondez en sélectionnant 15. Ensuite, sélectionnez 10 s'il est vacant; si le noir sélectionne 10, répondez par 11. Si le noir sélectionne alors 6, répondez par 7, et le suivant de 2 ou 3 est vacant. Si le noir ne sélectionne pas 6, sélectionnez-le, vous avez donc un chemin de 5 à la ligne du bas.

Entrée et sortie

Votre entrée est une chaîne de 16 caractères WBE, qui signifie blanc, noir et vide. Ils représentent les tuiles du plateau, comme énuméré ci-dessus. Vous pouvez choisir la méthode d'entrée (qui détermine également votre méthode de sortie) parmi les options suivantes:

1. Entrée depuis STDIN, sortie vers STDOUT.
2. Entrez comme un argument de ligne de commande, sortie vers STDOUT.
3. Entrer en tant que 16 arguments de ligne de commande à un caractère, sortir sur STDOUT.
4. Entrée comme argument de la fonction nommée, sortie comme valeur de retour.

Votre sortie représente la tuile sur laquelle vous placez votre prochain jeton, car c'est à votre tour de vous déplacer. Vous pouvez choisir parmi les formats de sortie suivants:

1. Un index basé sur zéro (comme utilisé dans l'image ci-dessus).
2. Un index à base unique.
3. La chaîne d'entrée avec une Eremplacée par celle Wou celle que Bvous avez choisie pour votre lecteur.

Règles

Votre stratégie doit être déterministe. Vous n'êtes pas obligé de gérer correctement les positions de jeu qui sont inaccessibles à partir du plateau vide en utilisant votre stratégie, ou les positions qui gagnent déjà pour l'un ou l'autre joueur, et vous pouvez planter dessus. À l'inverse, sur les tableaux accessibles à l'aide de votre stratégie, vous devez retourner un coup légal.

C'est le code-golf, donc le nombre d'octets le plus bas l'emporte. Les failles standard ne sont pas autorisées.

Essai

J'ai écrit un contrôleur Python 3 pour valider les entrées, car il serait extrêmement fastidieux de le faire à la main. Vous pouvez le trouver ici . Il prend en charge les trois premiers formats d'entrée et les fonctions Python 3 (les fonctions dans d'autres langues doivent être intégrées dans des programmes), les trois formats de sortie et les deux lecteurs. Si une stratégie ne gagne pas, elle produira une partie perdante trouvée, vous pouvez donc modifier votre programme.

Marbelous, 973b

Il s'agit d'une mise en œuvre naïve de la stratégie suggérée dans la question. Il s'attend à ce que la carte soit fournie en tant que 16 paramètres de ligne de commande / carte mère comme hex.mbl B W E E E W E E E B E E E E E Eet il affichera la position indexée zéro du prochain mouvement du blanc.

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

Je pense que je peux probablement jouer au golf à environ 200 caractères avec une meilleure ramification et l'élimination de la réutilisation du code.

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])

• Joueur: NOIR
• Méthode: STDIN / STDOUT, MODIFIED_BOARD

La stratégie consiste à rechercher d'abord un Bsur le tableau. S'il n'y en a pas, cela revient -1, ce qui en python est le même que last index. Ainsi, sur un plateau vide, mon premier index sera index=-1, c'est là que je commence à bouger.

Si le champ à ma gauche ( index-1) est libre, mon prochain mouvement y va. Si c'est pris, je monte à gauche. Je n'ai jamais à monter: si je le fais, je perds le rythme et je perdrai la partie.

En pension complète (nulle Epart), je ne bouge pas.

Le printsemble un peu bizarre au début: je dois construire le nouveau conseil d' administration (ce que je fais par découpage en tranches) , mais je dois couper 16 caractères. C'est une relique car je travaille avec des indices négatifs et b[i+1:]je vais donc retourner la planche de trous et le reste que j'attends, ce qui rend important de couper le reste. Une autre façon aurait été de travailler avec des indices positifs, par exemple en prenant (b.find('B')+16)%16, mais (+16)%16c'est un octet de plus que ()[:16].

Non golfé:

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])

Tester

Lors de l'exécution de la suite de tests du contrôleur hexadécimal, j'ai rencontré un comportement étrange:

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

Incorrect response 'WWWWWWWWBBBBBBBB' to message 'WWWWWWWWBBBBBBBB'.

Je pense que j'aurais dû gagner après le 4ème tour ou répondre avec la même planche à une pension complète devrait être une réponse correcte. Je ne sais pas ce qui ne va pas là-bas, je n'ai pas plongé beaucoup plus profondément - je voulais juste vérifier si j'avais couvert tous les cas "spéciaux". Mais comme je n'ai pas à dissimuler des situations où quelqu'un commence sur l'espace 4 ou plus, cela n'a pas d'importance de toute façon.

85b

Cependant, si je m'autorise à ne pas rechercher une carte complète (c'est-à-dire en laissant de côté le 'E' in bje peux simplifier davantage le code pour n'utiliser que 85 octets:

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])

Cela conduira cependant aux éléments suivants:

Incorrect response 'WWWBWWWWBBBBBBBB' to message 'WWWWWWWWBBBBBBBB'.

Cela pourrait ou non être compté, et puisque j'ai trouvé que ce n'était pas un mouvement valide, j'ai décidé d'aller chercher la réponse plus longue mais plus correcte.