Verkada Software Engineer Interview Questions

The interview started with technical questions; the cam and microphone weren't working, wasting 5 minutes. Then the Indian interviewer said he'd give 15-20 minutes for the two coding questions and 30

Let's jump straight to the problem. The following content requires a score higher than 188. You can already view it. It's a variation of the "camera group" problem from the forum. We have a string "or

SDE2 directly passed LeetCode Hard 588 similar. I felt carried during the interview because they kept giving me hints, but I failed immediately.

LeetCode #986: Interval List Intersections. Difficulty: Medium. Topics: Array, Two Pointers, Sweep Line. Asked at Verkada in the last 6 months.

LeetCode #1235: Maximum Profit in Job Scheduling. Difficulty: Hard. Topics: Array, Binary Search, Dynamic Programming, Sorting. Asked at Verkada in the last 6 months.

LeetCode #12: Integer to Roman. Difficulty: Medium. Topics: Hash Table, Math, String. Asked at Verkada in the last 6 months.

LeetCode #1233: Remove Sub-Folders from the Filesystem. Difficulty: Medium. Topics: Array, String, Depth-First Search, Trie. Asked at Verkada in the last 6 months.

LeetCode #981: Time Based Key-Value Store. Difficulty: Medium. Topics: Hash Table, String, Binary Search, Design. Asked at Verkada in the last 6 months.

LeetCode #435: Non-overlapping Intervals. Difficulty: Medium. Topics: Array, Dynamic Programming, Greedy, Sorting. Asked at Verkada in the last 6 months.

LeetCode #56: Merge Intervals. Difficulty: Medium. Topics: Array, Sorting. Asked at Verkada in the last 6 months.

LeetCode #1146: Snapshot Array. Difficulty: Medium. Topics: Array, Hash Table, Binary Search, Design. Asked at Verkada in the last 6 months.

## Problem Design an object-oriented API for controlling a multi-camera system. The API must support switching active cameras, adjusting settings (resolution, framerate, exposure), and streaming frames to registered consumers. ```python from abc import ABC, abstractmethod class Camera(ABC): @abstractmethod def start(self) -> None: ... @abstractmethod def stop(self) -> None: ... @abstractmethod def capture_frame(self) -> bytes: ... @abstractmethod def set_resolution(self, width: int, height: int) -> None: ... class CameraManager: def register(self, cam_id: str, camera: Camera) -> None: ... def activate(self, cam_id: str) -> None: ... def stream(self, cam_id: str, consumer: callable, fps: int) -> None: ... def switch(self, from_id: str, to_id: str, seamless: bool = False) -> None: ... ``` **Scenario:** A security system has 8 cameras. Design how you would allow a client to request a seamless switch with no dropped frames. ## Follow-ups 1. How does the abstract base class enforce the contract across camera hardware types? 2. How would you implement frame buffering to guarantee no frames are dropped during a switch? 3. What design pattern would you use to notify multiple consumers when a new frame is ready? 4. How would you add authentication so only authorized clients can call `switch`?

## Problem Given a grayscale image as a 2D array of pixel intensities (0-255), compute the mean, median, and histogram of intensities. Then implement a function that adjusts contrast by stretching the intensity range to fill [0, 255]. ```python import numpy as np from typing import Tuple def intensity_stats(image: list[list[int]]) -> dict: # returns: {"mean": float, "median": float, "histogram": list[int] of length 256} pass def stretch_contrast(image: list[list[int]]) -> list[list[int]]: # Linearly maps [min_intensity, max_intensity] -> [0, 255] pass ``` **Example:** ``` image = [[0, 128], [64, 192]] stretch_contrast([[10, 110], [60, 160]]) # min=10, max=160 -> new = (old-10) * 255/150 -> [[0, 170], [85, 255]] ``` ## Follow-ups 1. When is linear contrast stretching inadequate, and how does histogram equalization improve it? 2. How would you apply this operation in real time to a 30 fps camera stream? 3. How do you extend intensity stretching to a 3-channel (RGB) image without distorting colors? 4. What happens when min_intensity == max_intensity (uniform image)?

## Problem Design and implement an API for querying and storing camera logs, handling pagination or filtering. ## Likely LeetCode equivalent No direct LC match; API and data-access design problem. ## Tags system_design, API, logs

## Problem A hardware camera has the following states: IDLE, INITIALIZING, PREVIEWING, CAPTURING, ERROR. Implement a state machine that enforces valid transitions and raises descriptive errors on invalid ones. ```python from enum import Enum, auto class CameraState(Enum): IDLE = auto() INITIALIZING = auto() PREVIEWING = auto() CAPTURING = auto() ERROR = auto() class Camera: def initialize(self) -> None: ... def start_preview(self) -> None: ... def capture(self) -> bytes: ... def stop(self) -> None: ... def reset(self) -> None: ... @property def state(self) -> CameraState: ... ``` **Valid transitions:** ``` IDLE -> INITIALIZING -> PREVIEWING -> CAPTURING -> PREVIEWING Any state -> ERROR -> IDLE (via reset) ``` ## Follow-ups 1. How would you represent the transition table as data (dict of dicts) rather than nested if-statements? 2. How do you ensure thread safety when two threads call `capture` and `stop` simultaneously? 3. How would you log every state transition for post-mortem debugging of a camera crash? 4. How would you test the ERROR -> IDLE recovery path in a unit test without real hardware?

## Problem The classic coupon collector problem: there are N distinct types of coupons. Each draw gives a uniformly random coupon. Compute the expected number of draws to collect at least one of each type. Also write a simulation to verify the analytical result. ```python def expected_draws(n: int) -> float: # Analytical formula using harmonic numbers # E[T] = N * H(N) where H(N) = sum(1/k for k in 1..N) pass def simulate_draws(n: int, trials: int = 100_000) -> float: # Monte Carlo simulation; returns mean draws per trial pass ``` **Example:** ``` expected_draws(6) -> 14.7 simulate_draws(6) -> ~14.7 (within 1% for 100k trials) ``` ## Follow-ups 1. Derive the expected_draws formula from first principles using the geometric distribution. 2. What is the variance of the number of draws? How do you derive it? 3. If some coupons are twice as likely as others, how does the expected value change? 4. How would you compute the probability of finishing in exactly K draws?

## Problem Restore valid IP addresses from a string of digits by inserting dots in all possible positions. ## Likely LeetCode equivalent LC 93 (Restore IP Addresses) is the direct match. ## Tags strings, backtracking, recursion

## Problem You are building an alert pipeline for a monitoring system. Raw alerts arrive in a stream. Design a filter that: deduplicates alerts with the same (source, type) within a time window W; suppresses alerts below a minimum severity threshold; and rate-limits any single source to at most K alerts per minute. ```python from dataclasses import dataclass from typing import Optional @dataclass class Alert: id: str source: str alert_type: str severity: int # 1 (low) to 5 (critical) timestamp: float class AlertFilter: def __init__(self, min_severity: int, dedup_window_s: float, rate_limit_k: int): ... def process(self, alert: Alert) -> Optional[Alert]: # Returns alert if it passes all filters, else None ... ``` **Example:** Two identical alerts within 60 s -> second is suppressed. An alert with severity 1 when min_severity=3 -> suppressed. ## Follow-ups 1. What data structure efficiently tracks the dedup window without growing unboundedly? 2. How would you implement the rate limiter using a sliding window vs. token bucket? 3. How do you handle clock skew if alerts arrive out of order? 4. How would you persist filter state across a service restart?

## Problem Given the text of a Python source file, extract all class definitions including their names, base classes, and line numbers. Return a tree representing the inheritance hierarchy among the classes found. ```python from dataclasses import dataclass @dataclass class ClassDef: name: str bases: list[str] line: int def find_classes(source: str) -> list[ClassDef]: # Parse source and return all class definitions pass def build_hierarchy(classes: list[ClassDef]) -> dict[str, list[str]]: # Returns {parent: [child, ...]} for classes defined in the file pass ``` **Example:** ```python source = """ class Animal: pass class Dog(Animal): pass class Poodle(Dog): pass """ find_classes(source) -> [ClassDef("Animal", [], 2), ClassDef("Dog", ["Animal"], 4), ...] build_hierarchy(...) -> {"Animal": ["Dog"], "Dog": ["Poodle"]} ``` ## Follow-ups 1. Should you use regex or `ast.parse`? What are the trade-offs? 2. How do you handle classes with multiple inheritance? 3. How would you extend this to detect diamond inheritance patterns? 4. How would you scale this to analyze an entire repository of 10,000 files?

## Problem Transpose a given matrix by swapping rows and columns. ## Likely LeetCode equivalent LC 867 (Transpose Matrix) is the direct match. ## Tags matrix, arrays