如何散列整数的环形缓冲区?

我正在使用Python。我有一些包含整数的列表,但它们实际上是环形缓冲区。

以下是示例规则:

• 我们不添加新元素或修改任何元素。这些环是不可变的。

• 环中没有重复元素。

• 如果两个列表的长度不同,则它们不是同一个环。

• 在两个相同长度的列表之间,如果是一个列表,则在 环形移位 或 逆转 ,可以与另一个相同,两个环相等。例如 [1, 7, 9, 2, 5] 和 [7, 9, 2, 5, 1] (环移位)相等, [1,7,9,2,5] 和 [1, 5, 2, 9, 7] (环移位和反转)相等,但是 [1,7,9,2,5] 和 [7, 1, 9, 2, 5] 不平等。

我想快速确定两个环是否相等。

一种方法是比较它们的元素,另一种方法则是找到一种好的哈希方法。我试着将两个列表切换到它们的正常状态,并比较它们的元素是否相同(或者反转后是否相同),但速度太慢了。

我认为哈希是一个更好的选择。那么,对于这种环形缓冲区,什么哈希方法是好的呢?

以下是我目前拥有的:

import random
from time import perf_counter
from typing import List, Tuple

class Ring:
    def __init__(self, ids:List[int]) -> None:
        self.ids = ids

    def get_shifted(self, n:int) -> 'Ring':
        result_list = self.ids.copy()
        for i in range(n):
            head = result_list[0]
            result_list.remove(head)
            result_list.append(head)
        return Ring(result_list)
    
    def get_normalized(self) -> 'Ring':
        min_i = self.ids.index(min(self.ids))
        shifted = self.get_shifted(min_i)
        return shifted
    
    def get_reversed(self) -> 'Ring':
        result_list = self.ids.copy()
        result_list.reverse()
        return Ring(result_list)

    def __eq__(self, other: 'Ring') -> bool:
        if len(self.ids) != len(other.ids):
            return False
        normalized1 = tuple(self.get_normalized().ids)
        normalized2 = tuple(self.get_reversed().get_normalized().ids)
        normalized_other = tuple(other.get_normalized().ids)
        return normalized1 == normalized_other or normalized2 == normalized_other
    
    @staticmethod
    def Random() -> 'Ring':
        unduplicated = set()
        while len(unduplicated) < ring_capacity:
            unduplicated.add(random.randint(0, 20))
        return Ring(list(unduplicated))
    

if __name__ == '__main__':
    random.seed(1)
    ring_capacity = 5
    num_rings = 2000

    ring_set = []
    random_rings = [Ring.Random() for _ in range(num_rings)]

    start = perf_counter()
    for ring in random_rings:
        if ring not in ring_set:
            ring_set.append(ring)
    end = perf_counter()

    print(end - start)
    print(f'{len(ring_set)} out of {num_rings} unduplicated rings')