Central Intelligence Agency Software Engineer
Interview Guide

from typing import List, Optional


class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next


def reverse_list(head: Optional[ListNode]) -> Optional[ListNode]:
    """Reverse a singly linked list in place; return the new head."""
    prev, curr = None, head
    while curr:
        nxt = curr.next   # save the rest before overwriting the pointer
        curr.next = prev  # flip this node to point backwards
        prev, curr = curr, nxt
    return prev           # the old tail is the new head


def reverse_list_recursive(head: Optional[ListNode]) -> Optional[ListNode]:
    """Same result, but uses O(n) call stack: fine only for short lists."""
    if head is None or head.next is None:
        return head
    new_head = reverse_list_recursive(head.next)
    head.next.next = head  # the node after head now points back to it
    head.next = None       # old head becomes the tail
    return new_head


def from_list(values: List[int]) -> Optional[ListNode]:
    head = None
    for v in reversed(values):
        head = ListNode(v, head)
    return head


def to_list(head: Optional[ListNode]) -> List[int]:
    out = []
    while head:
        out.append(head.val)
        head = head.next
    return out

Scroll sideways to view long lines.

from typing import Sequence


def lower_bound(a: Sequence[int], target: int) -> int:
    """First index i with a[i] >= target, or len(a) if none. a must be sorted."""
    lo, hi = 0, len(a)             # half-open window [lo, hi)
    while lo < hi:
        mid = lo + (hi - lo) // 2  # overflow-safe form for fixed-width ints
        if a[mid] < target:
            lo = mid + 1           # answer lies strictly right of mid
        else:
            hi = mid               # mid itself may be the answer
    return lo


def upper_bound(a: Sequence[int], target: int) -> int:
    """First index i with a[i] > target, or len(a) if none."""
    lo, hi = 0, len(a)
    while lo < hi:
        mid = lo + (hi - lo) // 2
        if a[mid] <= target:
            lo = mid + 1
        else:
            hi = mid
    return lo


def binary_search(a: Sequence[int], target: int) -> int:
    """Index of the first occurrence of target, or -1 if absent."""
    i = lower_bound(a, target)
    return i if i < len(a) and a[i] == target else -1


def count_occurrences(a: Sequence[int], target: int) -> int:
    return upper_bound(a, target) - lower_bound(a, target)

Scroll sideways to view long lines.

import heapq
from collections import defaultdict
from itertools import count


def shortest_path(edges, source, target, directed=True):
    """Dijkstra for non-negative weights.

    edges: iterable of (u, v, weight). Returns (distance, path) or (inf, None).
    """
    graph = defaultdict(list)
    for u, v, w in edges:
        if w < 0:
            raise ValueError("Dijkstra requires non-negative edge weights")
        graph[u].append((v, w))
        if not directed:
            graph[v].append((u, w))

    dist = {source: 0}
    prev = {}
    tie = count()  # tie-breaker so the heap never compares node objects
    heap = [(0, next(tie), source)]
    while heap:
        d, _, u = heapq.heappop(heap)
        if d > dist[u]:
            continue           # stale entry: u was already settled cheaper
        if u == target:
            break              # popped target, so its distance is final
        for v, w in graph[u]:
            nd = d + w
            if nd < dist.get(v, float("inf")):
                dist[v] = nd   # relax the edge and remember how we got here
                prev[v] = u
                heapq.heappush(heap, (nd, next(tie), v))

    if target not in dist:
        return float("inf"), None
    path = [target]
    while path[-1] != source:
        path.append(prev[path[-1]])
    return dist[target], path[::-1]

Scroll sideways to view long lines.