Algorithmic Problem Solving Questions

def max_subarray_sum_k(arr, k):
    """
    Return max sum of any contiguous subarray of size exactly k.
    Raises ValueError if k <= 0 or k > len(arr).
    """
    n = len(arr)
    if k <= 0:
        raise ValueError("k must be positive")
    if k > n:
        raise ValueError("k cannot be larger than array length")
    
    # initial window sum
    window_sum = sum(arr[:k])
    max_sum = window_sum
    
    # slide the window
    for i in range(k, n):
        window_sum += arr[i] - arr[i - k]
        if window_sum > max_sum:
            max_sum = window_sum
    return max_sum

class Node:
    def __init__(self, k, v):
        self.k, self.v = k, v
        self.prev = self.next = None

class LRUCache:
    def __init__(self, capacity):
        self.cap = capacity
        self.map = {}             # key -> Node
        # dummy head/tail to simplify ops
        self.head = Node(None, None)
        self.tail = Node(None, None)
        self.head.next = self.tail
        self.tail.prev = self.head

    def _remove(self, node):
        p, n = node.prev, node.next
        p.next, n.prev = n, p

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

    def get(self, key):
        node = self.map.get(key)
        if not node:
            return -1
        self._remove(node)
        self._add_to_head(node)
        return node.v

    def put(self, key, value):
        node = self.map.get(key)
        if node:
            node.v = value
            self._remove(node)
            self._add_to_head(node)
            return
        if len(self.map) >= self.cap:
            # evict LRU (tail.prev)
            lru = self.tail.prev
            self._remove(lru)
            del self.map[lru.k]
        newn = Node(key, value)
        self.map[key] = newn
        self._add_to_head(newn)

def is_power_of_two_32bit(n: int) -> bool:
    """
    Return True if n is a power of two for a 32-bit signed integer.
    Uses only bit operations (no loops or logs).
    """
    # check 32-bit signed range if required
    if n <= 0:
        return False
    if n > 0x7FFFFFFF:  # 2^31 - 1
        return False
    # power-of-two bit trick
    return (n & (n - 1)) == 0

# Examples
# is_power_of_two_32bit(1) -> True
# is_power_of_two_32bit(16) -> True
# is_power_of_two_32bit(0) -> False
# is_power_of_two_32bit(-2) -> False