Total Quality Logistics Software Engineer
Interview Guide

def fibonacci_series(n):
    """Return the first n Fibonacci numbers, starting 0, 1."""
    if n < 0:
        raise ValueError("n must be non-negative")
    series = []
    a, b = 0, 1  # a = F(i), b = F(i + 1)
    for _ in range(n):
        series.append(a)
        a, b = b, a + b
    return series


def fibonacci_stream():
    """Yield Fibonacci numbers forever; the caller decides when to stop."""
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

Scroll sideways to view long lines.

import heapq
from itertools import count


def shortest_path(graph, source, target):
    """Dijkstra's algorithm for non-negative edge weights.

    graph: {node: [(neighbor, weight), ...]}
    Returns (distance, path), or (inf, []) if target is unreachable.
    """
    # Check every edge first: the search can stop before it reaches one.
    if any(w < 0 for edges in graph.values() for _, w in edges):
        raise ValueError("Dijkstra requires non-negative weights")
    dist = {source: 0}
    prev = {}
    tie = count()  # tiebreaker so nodes never need to be comparable
    heap = [(0, next(tie), source)]
    while heap:
        d, _, node = heapq.heappop(heap)
        if node == target:
            break  # first pop of target is final
        if d > dist[node]:
            continue  # stale entry: a shorter route was already found
        for nbr, w in graph.get(node, []):
            nd = d + w
            if nd < dist.get(nbr, float("inf")):
                dist[nbr] = nd
                prev[nbr] = node
                heapq.heappush(heap, (nd, next(tie), nbr))
    if target not in dist:
        return float("inf"), []
    path = [target]
    while path[-1] != source:
        path.append(prev[path[-1]])
    return dist[target], path[::-1]

Scroll sideways to view long lines.

def binary_search(nums, target):
    """Return the index of target in sorted nums, or -1 if absent.

    With duplicates, returns the leftmost match.
    """
    lo, hi = 0, len(nums)  # search window is the half-open range [lo, hi)
    while lo < hi:
        mid = (lo + hi) // 2  # in C/Java write lo + (hi - lo) / 2
        if nums[mid] < target:
            lo = mid + 1  # everything up to mid is too small
        else:
            hi = mid  # mid could be the answer; keep it in range
    # lo is now the first index with nums[lo] >= target
    if lo < len(nums) and nums[lo] == target:
        return lo
    return -1

Scroll sideways to view long lines.