Combien y a-t-il de positions différentes au morpion ?

P1 = 1
P2 = -1
EMPTY = 0

class Position:
    def __init__(self, pos_vec):
        self.pos_vec = pos_vec

    def allowed_moves(self):
        if self.is_endgame():
            return []
        else:
            return [i for i in range(len(self.pos_vec)) if self.pos_vec[i] == EMPTY]

    def current_player(self):
        if len([p for p in self.pos_vec if p == EMPTY]) % 2 == 0:
            return P2
        else:
            return P1

    def next_player(self):
        if self.current_player() == P1:
            return P2
        else:
            return P1

    def play(self, player, move):
        new_pos_vec = [p for p in self.pos_vec]
        new_pos_vec[move] = player
        return Position(new_pos_vec)

    def is_endgame(self):
        p = self.current_player()
        if ((self.pos_vec[0] == p and self.pos_vec[1] == p and self.pos_vec[2] == p)
           or (self.pos_vec[3] == p and self.pos_vec[4] == p and self.pos_vec[5] == p)
           or (self.pos_vec[6] == p and self.pos_vec[7] == p and self.pos_vec[8] == p)
           or (self.pos_vec[0] == p and self.pos_vec[3] == p and self.pos_vec[6] == p)
           or (self.pos_vec[1] == p and self.pos_vec[4] == p and self.pos_vec[7] == p)
           or (self.pos_vec[2] == p and self.pos_vec[5] == p and self.pos_vec[8] == p)
           or (self.pos_vec[0] == p and self.pos_vec[4] == p and self.pos_vec[8] == p)
           or (self.pos_vec[2] == p and self.pos_vec[4] == p and self.pos_vec[6] == p)
          ):
           return True
        elif [p for p in self.pos_vec if p == EMPTY] == []:
           return True
        else:
            return False

    def __hash__(self):
        return self.pos_vec[4]

    def __eq__(self, other):
        def reorder(order):
            return [self.pos_vec[i] for i in order]
        d1 = reorder([0, 1, 2, 3, 4, 5, 6, 7, 8])  # OK
        d2 = reorder([6, 3, 0, 7, 4, 1, 8, 5, 2])  # OK
        d3 = reorder([8, 7, 6, 5, 4, 3, 2, 1, 0])  # OK
        d4 = reorder([2, 5, 8, 1, 4, 7, 0, 3, 6])  # OK
        i1 = reorder([2, 1, 0, 5, 4, 3, 8, 7, 6])  # OK
        i2 = reorder([6, 7, 8, 3, 4, 5, 0, 1, 2])  # OK
        i3 = reorder([8, 5, 2, 7, 4, 1, 6, 3, 0])  # OK
        i4 = reorder([0, 3, 6, 1, 4, 7, 2, 5, 8])  # OK
        return (d1 == other.pos_vec or d2 == other.pos_vec or d3 == other.pos_vec or d4 == other.pos_vec
                or i1 == other.pos_vec or i2 == other.pos_vec or i3 == other.pos_vec or i4 == other.pos_vec)

    def size(self):
        return len([c for c in self.pos_vec if c == P1 or c == P2])
        

def generate_next_positions(current_position):
    allowed_moves = current_position.allowed_moves()
    player = current_position.next_player()
    next_positions = []
    for move in allowed_moves:
        np = current_position.play(player, move)
        next_positions.append(np)
    return next_positions


def generate_positions():
    empty_board = Position([EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY])
    all_positions = {empty_board}
    def gp(current_position):
        nps = generate_next_positions(current_position)
        for p in nps:
            if p not in all_positions:
                all_positions.add(p)
                gp(p)
    gp(empty_board)
    return all_positions

def count_positions():
    all_positions = generate_positions()
    return len(all_positions)


def count_positions(n=None):
    all_positions = generate_positions()
    if n is None:
        return len(all_positions)
    else:
        return len([p for p in all_positions if p.size() == n])

p = count_positions()
print(p)
print("---")
for i in range(10):
    print(count_positions(i))