转换UCI-移动到位盘，国际象棋

Question

我想转换一个UCI-移动到位板。

例如a2a3 -> 32768,8388608

我需要将7，6，.，0分配给A，B，.，h，以便对每个字母都有指定的编号(N)来计算2^n

然后，我可以通过uci1或uci3. *8中的值进行移位，这取决于启动或终止字段。

这是我的方法，它看起来不太好和多余。

def ucitoBit(uci):
    if uci[0] == 'a':
        mask1 = 2 ** 7
    if uci[0] == 'b':
        mask1 = 2 ** 6
    if uci[0] == 'c':
        mask1 = 2 ** 5
    if uci[0] == 'd':
        mask1 = 2 ** 4
    if uci[0] == 'e':
        mask1 = 2 ** 3
    if uci[0] == 'f':
        mask1 = 2 ** 2
    if uci[0] == 'g':
        mask1 = 2 ** 1
    if uci[0] == 'h':
        mask1 = 2 ** 0
    mask1 = mask1 << 8 * (int(uci[1]) - 1)

    if uci[2] == 'a':
        mask2 = 2 ** 7
    if uci[2] == 'b':
        mask2 = 2 ** 6
    if uci[2] == 'c':
        mask2 = 2 ** 5
    if uci[2] == 'd':
        mask2 = 2 ** 4
    if uci[2] == 'e':
        mask2 = 2 ** 3
    if uci[2] == 'f':
        mask2 = 2 ** 2
    if uci[2] == 'g':
        mask2 = 2 ** 1
    if uci[2] == 'h':
        mask2 = 2 ** 0
    mask2 = mask2 << 8 * (int(uci[3]) - 1)
    bitstring = [np.uint64(mask1), np.uint64(mask2)]
    return bitstring

Answer 1

选项1:

我能提出的最基本的建议是，如果您有一个从一个事物到另一个事物的映射，如果这个映射是固定的，那么您应该使用一个映射数据类型。

python中的映射数据类型是dict，它可以按照如下方式以行方式编写：

uci_bit = {
    'a': 2**7, 'b': 2**6, 'c': 2**5, 'd': 2**4,
    'e': 2**3, 'f': 2**2, 'g': 2**1, 'h': 2**0,
}

或者，dict()函数返回一个字典，并接受关键字参数：

uci_bit = dict(a=2**7, b=2**6, c=2**5, d=2**4, 
               e=2**3, f=2**2, g=2**1, h=2**0)

两种结果都一样。然后，您可以使用标准的方括号表示法访问dict：

ch = uci[0]
mask1 = uci_bit[ch]

或者作为一个单一的表达：

mask1 = uci_bit[uci[0]]

备选方案2:

然而，还有另一种方法具有一定的潜力。在字典里查东西是有代价的。从技术上讲是O(n)，但里面可能有一两个常数。所以..。

因为uci位置的两个组件是固定宽度('a‘和'2')，所以您可以使用str.index方法在字符串中查找它们并获得更好的性能。

注:我写了“可能是”。确定的方法是编写两段代码，并对备选方案进行计时测试。在标准发行版中查找timeit模块。

类似于：

UCI_CHARS = 'hgfedcba'

mask1 = 2 ** UCI_CHARS.index(uci[0])
mask2 = 2 ** UCI_CHARS.index(uci[2])

您还可能希望检查在uci解码的个位数部分上使用dict与str.index与int()函数的结果。

选项3:

还不清楚您正在执行的这些操作中有多少次。如果你在玩一个游戏，而且可能会有20多个uci来操作，那么这可能并不重要。但是如果你同时玩很多游戏的话，你应该生成一个包含所有UCI字母/数字组合的字典，并将查找作为一个单独的操作来完成。类似于：

for ch in 'abcdefgh':
    for digit in '12345678':
        uci = ch + digit
        bit = # whatever computation
        uci_bit[uci] = bit

这将允许您在一个步骤中解码'a2‘->位，而代价是前端循环。

其他考虑事项

我问鸭子有关比特板，并立即提出了一个事实，即没有单一的标准表示。相反，对于不同的用途和不同的CPU架构，有不同的表示形式。

这样做的结果是，您肯定应该在类或函数中执行此操作，并且一定要给要计算的位板类型指定一个“名称”，这样读者就可以了解您所选择的几种选项中的哪一种。秩-专业和文件的主要和大-对小对端表示都是有效的，所以请确保将此信息包括在类或函数名称，或在评注中。

def uci_to_bitboard_lsf(uci: str) -> int:
    """ Convert UCI notation to bitboard(LSF, little-endian) """

    ...

此外，我怀疑使用*可能是一个bug，您应该使用+。(它确实应该是按位的，或者，|操作符，但是+会工作的。)