Verkada Software Engineer Phone Screen 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.

## 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 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 Transpose a given matrix by swapping rows and columns. ## Likely LeetCode equivalent LC 867 (Transpose Matrix) is the direct match. ## Tags matrix, arrays

## Problem Merge two sorted arrays into one sorted array in-place or into a new array. ## Likely LeetCode equivalent LC 88 (Merge Sorted Array) is the direct match. ## Tags arrays, two_pointers, sorting

## Problem Design a C API for reading sensor data from an embedded device. The API must support registering multiple sensor types, polling or interrupt-driven data collection, and buffering readings for batch retrieval by the host application. ```c typedef enum { SENSOR_TEMP, SENSOR_HUMIDITY, SENSOR_PRESSURE } SensorType; typedef struct { SensorType type; float value; uint32_t timestamp_ms; } SensorReading; // Register a sensor; returns handle or -1 on error int sensor_register(SensorType type, uint32_t poll_interval_ms); // Read buffered data since last call; returns count written int sensor_read_batch(int handle, SensorReading* out, int max_count); // Enable interrupt-driven mode; callback fires on new data int sensor_set_irq(int handle, void (*callback)(SensorReading)); void sensor_deregister(int handle); ``` ## Follow-ups 1. How do you make the ring buffer for readings interrupt-safe without disabling global interrupts? 2. What happens if the host is too slow to drain the buffer and it overflows? How do you signal this? 3. How would you expose this C API via a Python ctypes wrapper for testing on a host machine? 4. How do you design the timestamp to remain monotonic across CPU clock rollovers?

## Problem Find the shortest path between two nodes in a graph, using BFS for unweighted or Dijkstra for weighted graphs. ## Likely LeetCode equivalent LC 743 (Network Delay Time) or LC 1091 (Shortest Path in Binary Matrix). ## Tags graph, BFS, shortest-path

## Problem Implement a causal moving-average filter that smooths a noisy 1D signal. Given an input array and a window size W, replace each sample with the mean of the W most recent samples (including the current one). Handle the boundary at the start of the signal. ```python def moving_average(signal: list[float], window: int) -> list[float]: # Causal: output[i] = mean(signal[max(0,i-window+1) : i+1]) pass def moving_average_fast(signal: list[float], window: int) -> list[float]: # O(n) using a running sum; no recomputation per window pass ``` **Example:** ``` moving_average([1,3,5,7,9], window=3) -> [1.0, 2.0, 3.0, 5.0, 7.0] # Index 0: mean([1])=1, Index 1: mean([1,3])=2, Index 2: mean([1,3,5])=3 ... ``` ## Follow-ups 1. What is the time complexity of the naive vs. running-sum approach? 2. How does a Gaussian filter differ from a box (moving-average) filter in the frequency domain? 3. How would you implement an exponential moving average (EMA) for real-time streaming data? 4. How would you extend this to a 2D image smoothing filter?

## Problem Given a text string T and a pattern string P, find all starting indices where P occurs in T. First implement naive O(n*m) search, then implement KMP for O(n+m). ```python def find_pattern_naive(text: str, pattern: str) -> list[int]: pass def build_kmp_table(pattern: str) -> list[int]: # Failure function: kmp_table[i] = length of longest proper prefix # of pattern[0..i] that is also a suffix pass def find_pattern_kmp(text: str, pattern: str) -> list[int]: pass ``` **Example:** ``` find_pattern_kmp("ababcabab", "abab") -> [0, 5] build_kmp_table("abab") -> [0, 0, 1, 2] ``` ## Follow-ups 1. Walk through the KMP failure function construction for pattern "aabaa". 2. How does Rabin-Karp differ from KMP, and when would you prefer it? 3. How would you extend your solution to search for multiple patterns simultaneously? (Aho-Corasick) 4. How would you handle Unicode multi-byte characters in the pattern and text?

## Problem Build a browser-based time-lapse viewer. Given an ordered array of image URLs, render a player that lets the user scrub through frames via a range slider, auto-play at a configurable FPS, and jump to the first/last frame. ```js // Vanilla JS / Web Components class TimeLapseViewer extends HTMLElement { constructor() { super(); } // Attributes: data-fps (default 10), data-frames (JSON array of URLs) connectedCallback() { ... } play() { ... } // starts auto-advance at current FPS pause() { ... } seek(frameIndex) { ... } // jump to specific frame } ``` **Requirements:** Preload the next 5 frames ahead of the current position. Show current frame index and timestamp overlay. Slider updates in real time as frames advance. ## Follow-ups 1. How do you prevent memory leaks when preloaded Image objects are no longer needed? 2. How would you synchronize the slider position with auto-play without causing jank? 3. If frame URLs expire (signed S3 URLs), how would you refresh them without interrupting playback? 4. How would you test the seek function in a headless browser environment?

## Problem Implement a module that requests camera access via the browser's MediaDevices API, handles permission denial gracefully, streams video to a `<video>` element, and cleanly releases the camera when no longer needed. ```js class CameraAccessManager { constructor(videoElement) { this.video = videoElement; this.stream = null; } async requestAccess(constraints = { video: true }) { ... } async switchCamera(deviceId) { ... } release() { ... } // stops all tracks captureFrame() { ... } // returns ImageData from current frame } ``` **Requirement:** If the user denies permission, show a clear error message. If multiple cameras exist, expose a list and allow switching. ## Follow-ups 1. What is the difference between `getUserMedia` constraints `facingMode: 'environment'` and specifying a `deviceId`? 2. How do you enumerate available cameras before requesting access, and what limitation applies? 3. What cleanup is required to ensure the browser's camera indicator light turns off? 4. How would you handle the case where the user revokes camera permission while the stream is active?

## Problem Build a reusable dashboard widget component that displays a metric with a title, current value, and sparkline trend chart. The widget polls a data endpoint at a configurable interval and updates in place without full re-render. ```tsx // React / TypeScript interface WidgetProps { title: string; endpoint: string; // URL returning {value: number, history: number[]} refreshIntervalMs: number; unit?: string; // e.g. "ms", "%", "req/s" alertThreshold?: number; // highlight red if value > threshold } export function Widget({ title, endpoint, refreshIntervalMs, unit, alertThreshold }: WidgetProps) { // ... } ``` **Requirements:** Show loading and error states. History sparkline updates smoothly. Widget cleans up its interval on unmount. ## Follow-ups 1. How do you prevent a state update on an unmounted component after a fetch resolves? 2. If 20 widgets all poll the same endpoint, how would you deduplicate the network requests? 3. How would you animate the sparkline when new data points are appended? 4. How would you make the widget accessible (screen reader support for live value updates)?

## Problem Implement the core logic for a Wordle-style word game. Given a 5-letter secret word and a 5-letter guess, return a per-letter result: GREEN (correct position), YELLOW (letter in word but wrong position), GRAY (letter not in word). Handle duplicate letters correctly. ```python from enum import Enum class Result(Enum): GREEN = 'G' YELLOW = 'Y' GRAY = '_' def score_guess(secret: str, guess: str) -> list[Result]: # Both strings are exactly 5 uppercase letters pass def is_valid_guess(word: str, word_list: set[str]) -> bool: pass ``` **Example:** ``` score_guess("CRANE", "CARES") -> [G, Y, Y, _, Y] # C: correct position; A: in word wrong pos; R: in word wrong pos; # E: not present; S: in word wrong pos (wait -- check duplicate rules) ``` ## Follow-ups 1. Explain how you handle duplicate letters: e.g., secret="HELLO", guess="LLAMA". 2. How would you implement a solver that picks the guess minimizing expected remaining candidates? 3. How would you extend this to support 6-letter words or hard mode (must use confirmed letters)? 4. How would you store and query the word list to validate guesses in O(1)?