# Calculate all 6 pairwise distances
distances = []
for i in range(4):
    for j in range(i + 1, 4):
        distances.append(distSq(points[i], points[j]))

# Count frequency of distances
counts = collections.Counter(distances)

# A square must have 4 equal side lengths and 2 equal diagonal lengths.
# The side length squared should be non-zero.
if len(counts) == 2 and 0 not in counts:
    sides = min(counts.keys())
    diagonals = max(counts.keys())
    if counts[sides] == 4 and counts[diagonals] == 2:
        return True
return False</code></pre

for r in range(rows):
    for c in range(cols):
        if grid[r][c] == '1':
            count += 1
            dfs(r, c)
return count</code></pre

def __init__(self, capacity: int):
    self.cache = {} # map key to node
    self.capacity = capacity
    self.head = self.Node(0,0) # dummy head
    self.tail = self.Node(0,0) # dummy tail
    self.head.next = self.tail
    self.tail.prev = self.head

def _remove_node(self, node):
    node.prev.next = node.next
    node.next.prev = node.prev

def _add_to_front(self, node):
    node.next = self.head.next
    node.prev = self.head
    self.head.next.prev = node
    self.head.next = node

def get(self, key: int) -> int:
    if key in self.cache:
        node = self.cache[key]
        self._remove_node(node)
        self._add_to_front(node)
        return node.val
    return -1

def put(self, key: int, value: int) -> None:
    if key in self.cache:
        self._remove_node(self.cache[key])
    new_node = self.Node(key, value)
    self.cache[key] = new_node
    self._add_to_front(new_node)

    if len(self.cache) > self.capacity:
        lru_node = self.tail.prev
        self._remove_node(lru_node)
        del self.cache[lru_node.key]</code></pre

backtrack([], list(s))
return res</code></pre

curr = head
# 2. Assign random pointers for new nodes
while curr:
    if curr.random:
        curr.next.random = curr.random.next
    curr = curr.next.next

curr = head
new_head = head.next
# 3. Separate original and new lists
while curr:
    copy = curr.next
    curr.next = copy.next
    if copy.next:
        copy.next = copy.next.next
    curr = curr.next
return new_head</code></pre

half_len = (m + n + 1) // 2
low, high = 0, m

while low <= high:
    i = (low + high) // 2 # Partition point for A
    j = half_len - i     # Partition point for B

    if i < m and B[j-1] > A[i]:
        low = i + 1
    elif i > 0 and A[i-1] > B[j]:
        high = i - 1
    else: # Partition found
        max_left = 0
        if i == 0: max_left = B[j-1]
        elif j == 0: max_left = A[i-1]
        else: max_left = max(A[i-1], B[j-1])

        if (m + n) % 2 == 1:
            return float(max_left)
        
        min_right = 0
        if i == m: min_right = B[j]
        elif j == n: min_right = A[i]
        else: min_right = min(A[i], B[j])
        
        return (max_left + min_right) / 2.0</code></pre

q = collections.deque([(0, 0, 1)]) # (r, c, dist)
grid[0][0] = 1 # Mark as visited

directions = [
    (1, 0), (-1, 0), (0, 1), (0, -1),
    (1, 1), (1, -1), (-1, 1), (-1, -1)
]

while q:
    r, c, dist = q.popleft()
    if r == n - 1 and c == n - 1:
        return dist
    
    for dr, dc in directions:
        nr, nc = r + dr, c + dc
        if 0 <= nr < n and 0 <= nc < n and grid[nr][nc] == 0:
            grid[nr][nc] = 1 # Mark as visited
            q.append((nr, nc, dist + 1))

return -1</code></pre

private boolean isValidBST(TreeNode node, long minVal, long maxVal) {
    if (node == null) return true;
    if (node.val <= minVal || node.val >= maxVal) return false;
    return isValidBST(node.left, minVal, node.val) && isValidBST(node.right, node.val, maxVal);
}

def insert(self, word: str) -> None:
    node = self.root
    for char in word:
        if char not in node.children:
            node.children[char] = TrieNode()
        node = node.children[char]
        node.words.append(word) # Store word at each node for easy retrieval
    node.is_end_of_word = True

def search_prefix(self, prefix: str) -> list[str]:
    node = self.root
    for char in prefix:
        if char not in node.children:
            return []
        node = node.children[char]
    return node.words # All words passing through this prefix node</code></pre