answer:class Spreadsheet: def __init__(self): self.cells = {} def set_cell(self, cell_name: str, content: str): self.cells[cell_name] = content def get_value(self, cell_name: str): content = self.cells.get(cell_name, "") if content.isdigit() or (content.replace('.', '', 1).isdigit() if '.' in content else False): return float(content) try: # Replace cell references with their actual values in the formula formula = content for ref in self.cells: if ref in formula: formula = formula.replace(ref, str(self.get_value(ref))) result = eval(formula) return float(result) except Exception as e: raise ValueError(f"Error evaluating cell '{cell_name}': {e}")

answer:class CustomLinkedList: class Node: def __init__(self, value=0, next=None): self.value = value self.next = next def __init__(self): self.head = None self.size = 0 def add_at_head(self, value: int) -> None: new_node = self.Node(value, self.head) self.head = new_node self.size += 1 def add_at_tail(self, value: int) -> None: new_node = self.Node(value) if not self.head: self.head = new_node else: current = self.head while current.next: current = current.next current.next = new_node self.size += 1 def delete_value(self, value: int) -> bool: current = self.head previous = None while current: if current.value == value: if previous: previous.next = current.next else: self.head = current.next self.size -= 1 return True previous = current current = current.next return False def find_middle(self) -> int: if not self.head: return -1 slow = self.head fast = self.head while fast and fast.next: slow = slow.next fast = fast.next.next return slow.value

answer:from collections import deque def shortest_path(grid, start, end): Find the shortest path from start to end in a 2D grid using BFS. If no path exists, return -1. rows, cols = len(grid), len(grid[0]) directions = [(-1, 0), (1, 0), (0, -1), (0, 1)] # Up, Down, Left, Right queue = deque([(start[0], start[1], 0)]) # (row, col, distance) visited = set() visited.add(start) while queue: r, c, dist = queue.popleft() if (r, c) == end: return dist for dr, dc in directions: rr, cc = r + dr, c + dc if 0 <= rr < rows and 0 <= cc < cols and grid[rr][cc] == 0 and (rr, cc) not in visited: queue.append((rr, cc, dist + 1)) visited.add((rr, cc)) return -1

answer:from typing import List def sum_excluding_elements(arr: List[int], exclude: List[int]) -> int: Returns the sum of all elements in `arr` excluding those present in `exclude`. Parameters: - arr (List[int]): The list of elements to sum. - exclude (List[int]): The list of elements to exclude from the sum. Returns: int: The sum of elements in `arr` excluding those in `exclude`. exclude_set = set(exclude) # Convert exclude list to set for O(1) lookups return sum(x for x in arr if x not in exclude_set)