Implémenter le traitement de l'inversion à l'aide de BitBoard

Implémentez la réversité avec BitBoard. Cette fois, nous allons implémenter le traitement d'inversion. (Par souci de simplicité, nous utiliserons un exemple 4x4, mais l'implémentation est 8x8. W: Shiraishi, B: Kuroishi, x: Pas de pierre.)

xxxx
xWBx
xBWx
xxxx

Ce plateau est arrangé avec des pierres noires dans BitBoard

0000
0010
0100
0000

Et l'arrangement de Shiraishi

0000
0100
0010
0000

Il est représenté par deux chaînes de bits de.

Début du virage noir move:

0000
0000
0001
0000

Contrairement au placement de la pierre retournée «retourné»:

0000
0000
0010
0000

Lorsque vous demandez, le processus d'inversion des nombres blancs est ʻopponent_board ^ = flipped`.

0000   0000   0000
0100 ^ 0000 = 0100
0010   0010   0000
0000   0000   0000

Aussi, la disposition des pierres noiresself_board ^= flipped | moveOuself_board |= flippled | moveObtenu à partir de.

0000   0000   0000
0010 ^ 0000 = 0010
0100   0011   0111
0000   0000   0000

A partir de maintenant, nous nous concentrerons sur la recherche du Shiraishi inversé «retourné». Le Shiraishi retourné est toujours dans l'une des huit directions en diagonale vers le haut, le bas, la gauche et la droite du mouvement de départ. Tout d'abord, commençons par la recherche à gauche. L'inversion vers la gauche correspond à l'un des deux modèles suivants.

BWo
BWWo

(W: Shiraishi, B: Kuroishi, o: Début du tour noir, respectivement.)

Déplacez le début move vers la gauche pour obtenir le placement des nombres blancs et le produit. Vous obtenez «retourné» en déplaçant le résultat plus à gauche et en prenant le produit avec le placement du nombre blanc. (Pour 8x8, un total de 6 décalages vous donnera `` retourné ''.) Cependant, vous devez vous assurer qu'il y a une pierre blanche qui peut être retournée vers la gauche avant le calcul. C'est la même chose que Comment trouver une main légale.

class Board:
    BLACK, WHITE = True, False

    def __init__(self, black=0x000008100000, white=0x000010080000):
        self.board = {Board.BLACK: black, Board.WHITE: white}

    def flipped(self, player, move):
        """ returns flipped stones """
        flipped = 0b0
        player_board = self.board[player]
        opponent_board = self.board[not player]
        blank_board = ~(player_board | opponent_board)

        masked_opponent_board = opponent_board & 0x7e7e7e7e7e7e7e7e

        #Assurez-vous qu'il y a une pierre blanche qui peut être retournée vers la gauche
        temp = player_board << 1 & masked_opponent_board
        temp |= temp << 1 & masked_opponent_board
        temp |= temp << 1 & masked_opponent_board
        temp |= temp << 1 & masked_opponent_board
        temp |= temp << 1 & masked_opponent_board
        temp |= temp << 1 & masked_opponent_board
        legal_moves = temp << 1 & blank_board

        # move & legal_les mouvements seront move ou 0b0
        temp = (move & legal_moves) >> 1 & opponent_board
        temp |= temp >> 1 & opponent_board
        temp |= temp >> 1 & opponent_board
        temp |= temp >> 1 & opponent_board
        temp |= temp >> 1 & opponent_board
        temp |= temp >> 1 & opponent_board
        flipped |= temp

        return flipped

Recommended Posts

Implémenter le traitement de l'inversion à l'aide de BitBoard
Implémenter le traitement de l'inversion à l'aide de BitBoard
Traitement de type dictionnaire à l'aide d'éléments ()
Utilisation du mode Python dans le traitement
Implémenter le traitement du classement avec des liens en Python à l'aide de Redis Sorted Set
[Linux] Accélérez le traitement de la compression avec pigz
100 traitement du langage knock-76 (en utilisant scicit-learn): étiquetage
Grattage écologique grâce au traitement d'image
100 traitement du langage knock-31 (en utilisant des pandas): verbe
Traitement de lignes horizontales à l'aide de la transformation de morphologie OpenCV
Traitement de l'analyse japonaise à l'aide de Janome part1
100 traitement du langage knock-73 (en utilisant scikit-learn): apprentissage
100 traitement du langage knock-74 (en utilisant scicit-learn): prédiction
J'ai essayé le traitement asynchrone en utilisant asyncio
100 traitement du langage knock-38 (en utilisant des pandas): histogramme