背景

Hex是在K×K六角形菱形菱形上玩的两人抽象策略游戏。菱形的两个相对的边都被涂成白色，另外两个被涂成黑色，两个玩家（黑与白）轮流将其颜色的标记放置在一个空置的瓷砖上。首先设法在其颜色的相对两侧之间建立路径的玩家是获胜者。众所周知，游戏无法以平局告终，并且不管棋盘大小如何，第一位玩家都有获胜的策略（有关详细信息，请参阅Wikipedia页面）。

任务

在此挑战中，我们将板子尺寸固定为K = 4，并将板子表示为以下网格。粗线表示相邻的图块。

您的任务是为第一个玩家制定一个获胜策略，您可以选择是黑人还是白人。这意味着无论对方球员采取何种合法行动，您的比赛都必须取得胜利。您的输入是一个游戏位置（板上的代币排列），而您的输出是合法移动，采用以下指定的格式。如果您想自己找到一个成功的策略，请不要阅读以下内容：

假设白人先行，则可能的制胜策略概述。 首先选择5。之后，如果您有从5到最底行的路径，或者黑色在任何时候都选择0或1，请选择0或1中的任何一个作为响应。如果黑色选择9或13，则选择10，然后选择14或15中的任何一个。如果黑色未选择9、13或14，则选择9，然后选择13或14中的任一个。如果黑色选择14，则通过选择15进行响应。接下来，如果空白则选择10；否则，选择10。如果黑色选择10，则响应为11。如果黑色选择6，则响应7，然后选择2或3中的任一个。如果黑色未选择6，请选择它，因此您具有从5到最底行的路径。

输入输出

您输入的字符串是16个字符WBE，代表白色，黑色和空白。它们代表了上面所列举的板块。您可以从以下选项中选择输入法（这也决定了您的输出法）：

1. 从STDIN输入，输出到STDOUT。
2. 输入作为一个命令行参数，输出到STDOUT。
3. 输入为16个单字符命令行参数，输出到STDOUT。
4. 输入作为命名函数的参数，输出作为返回值。

您的输出代表您放置下一个标记的磁贴，因为该旋转了。您可以从以下输出格式中选择：

1. 从零开始的索引（如上图所示）。
2. 一个基于索引的索引。
3. 输入字符串与一个E由两者的替代W或B您选择您的播放器。

规则

您的策略必须是确定性的。您不需要使用您的策略来正确处理空局无法到达的游戏位置，或已经为任一位玩家赢得的位置，您可能会因此而崩溃。相反，在使用您的策略可以到达的板上，您必须返回合法举动。

这是代码高尔夫球，因此最低的字节数为准。不允许出现标准漏洞。

测试中

我已经编写了一个Python 3控制器来验证条目，因为手工操作非常繁琐。你可以在这里找到它。它支持前三种输入格式和Python 3函数（必须将其他语言的函数包装到程序中），所有三种输出格式以及这两种播放器。如果某策略没有获胜，它将输出发现的失败游戏，因此您可以调整程序。

Marbelous，973b

这是问题中暗示策略的幼稚实现。它期望该板将像16个命令行/主板参数一样提供hex.mbl B W E E E W E E E B E E E E E E，并且它将输出白色下一步的零索引位置。

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

我想我可以通过更好的分支和消除代码重用而从中获取大约200个字符。

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

• 球员：黑色
• 方法：STDIN / STDOUT，MODIFIED_BOARD

该策略是首先B在板上寻找一个。如果没有返回-1，则在python中与相同last index。因此，在空的木板上，我的第一个索引将是index=-1，这是我开始移动的地方。

如果我左边的（index-1）字段是自由的，那么我的下一步就是去那里。如果采取的话，我向左走。我再也不必动起来：如果我这样做，我会失去节奏，会输掉比赛。

如果全盘（任何E地方都没有），我不会采取任何行动。

一开始print似乎有点不可思议：我必须构建新板（我通过切片来完成），但是随后我需要切出16个字符。因为我使用负索引，b[i+1:]所以这是遗物，因此将返回孔板和我期望的其余部分，因此切下其余部分非常重要。另一种方法是使用正索引，例如通过(b.find('B')+16)%16，但(+16)%16比增大一个字节()[:16]。

取消高尔夫：

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

测试

在运行十六进制控制器测试套件时，我遇到了一些奇怪的行为：

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

Incorrect response 'WWWWWWWWBBBBBBBB' to message 'WWWWWWWWBBBBBBBB'.

我认为我应该是在第四轮之后赢了，或者在同一局中答对了一个全局应该是正确的回答。不知道那里出了什么问题，没有深入探讨-我只是想检查是否涵盖了所有“特殊”情况。但是由于我不必掩盖有人从太空4左右开始的情况，所以无论如何都没关系。

85b

但是，如果我不允许自己检查整个电路板（即省略了'E' in bI，则可以进一步简化代码以仅使用85个字节）：

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

但是，这将导致以下情况：

Incorrect response 'WWWBWWWWBBBBBBBB' to message 'WWWWWWWWBBBBBBBB'.

这可能会或可能不会被计算在内，并且由于我发现这不是一个有效的举动，所以我决定寻求更长但更正确的答案。