How to Check if Two Lists are Circularly Identical in Python

A     = [1, 2, 3]
A + A = [1, 2, 3, 1, 2, 3]

All rotations are visible:
  [1, 2, 3] - original (position 0)
  [2, 3, 1] - rotation (position 1)  
  [3, 1, 2] - rotation (position 2)

def is_circularly_identical(list_a: list, list_b: list) -> bool:
    """Check if list_b is a rotation of list_a."""
    if len(list_a) != len(list_b):
        return False

    if not list_a:
        return True

    doubled = list_a + list_a
    n = len(list_b)

    for i in range(len(list_a)):
        if doubled[i:i + n] == list_b:
            return True

    return False


a = [1, 2, 3, 4]
b = [3, 4, 1, 2]
c = [2, 1, 3, 4]

print(is_circularly_identical(a, b))  # True (rotated by 2)
print(is_circularly_identical(a, c))  # False (not a rotation)

from collections import deque


def is_circularly_identical_deque(list_a: list, list_b: list) -> bool:
    """Check circular identity by rotating a deque."""
    if len(list_a) != len(list_b):
        return False

    if not list_a:
        return True

    d_a = deque(list_a)
    d_b = deque(list_b)

    for _ in range(len(list_a)):
        if d_a == d_b:
            return True
        d_a.rotate(1)

    return False


a = [1, 2, 3, 4]
b = [4, 1, 2, 3]

print(is_circularly_identical_deque(a, b))  # True

from collections import deque


def find_rotation_offset(list_a: list, list_b: list) -> int | None:
    """Find the rotation offset, or None if not circularly identical."""
    if len(list_a) != len(list_b):
        return None

    if not list_a:
        return 0

    d_a = deque(list_a)
    d_b = deque(list_b)

    for offset in range(len(list_a)):
        if d_a == d_b:
            return offset
        d_a.rotate(1)

    return None


a = [1, 2, 3, 4]
b = [3, 4, 1, 2]

offset = find_rotation_offset(a, b)
print(f"Rotation offset: {offset}")  # Rotation offset: 2

def is_circularly_identical_optimized(list_a: list, list_b: list) -> bool:
    """Optimized check by finding potential starting points."""
    if len(list_a) != len(list_b):
        return False

    if not list_a:
        return True

    n = len(list_a)
    first_elem = list_b[0]

    for start in range(n):
        if list_a[start] == first_elem:
            match = True
            for j in range(n):
                if list_a[(start + j) % n] != list_b[j]:
                    match = False
                    break
            if match:
                return True

    return False

def is_circular_string(s1: str, s2: str) -> bool:
    """Check if s2 is a rotation of s1."""
    if len(s1) != len(s2):
        return False
    return s2 in s1 + s1


print(is_circular_string("hello", "llohe"))  # True
print(is_circular_string("hello", "lohel"))  # True
print(is_circular_string("hello", "world"))  # False

def get_all_rotations(lst: list) -> list:
    """Return all circular rotations of a list."""
    if not lst:
        return [[]]

    rotations = []
    for i in range(len(lst)):
        rotation = lst[i:] + lst[:i]
        rotations.append(rotation)

    return rotations


rotations = get_all_rotations([1, 2, 3])
for r in rotations:
    print(r)

[1, 2, 3]
[2, 3, 1]
[3, 1, 2]

def canonical_rotation(lst: list) -> tuple:
    """Return the lexicographically smallest rotation as a tuple."""
    if not lst:
        return tuple()

    n = len(lst)
    rotations = [tuple(lst[i:] + lst[:i]) for i in range(n)]
    return min(rotations)


lists = [
    [3, 1, 2],
    [1, 2, 3],
    [2, 3, 1],
    [4, 5, 6]
]

groups = {}
for lst in lists:
    key = canonical_rotation(lst)
    if key not in groups:
        groups[key] = []
    groups[key].append(lst)

for canonical, members in groups.items():
    print(f"{canonical}: {members}")

(1, 2, 3): [[3, 1, 2], [1, 2, 3], [2, 3, 1]]
(4, 5, 6): [[4, 5, 6]]