Common Camera Motion Intervals
Reported by candidates from Verkada's online assessment. Pattern, common pitfall, and the honest play if you blank under the timer.
The edge case that kills most first attempts at Verkada's Common Camera Motion Intervals, reported in September 2026, is treating a gap in timestamps as if it were continuous motion. Your OA invite is sitting there, so here's the shape. Each camera gives you sparse timestamps with intensities. You build maximal runs where intensity is at least the threshold, then intersect the interval lists across every camera. It's interval merging plus a two-pointer sweep. It looks like a data problem and it's really a bookkeeping problem. If you blank mid-assessment, StealthCoder runs invisibly as a safety net.
The problem
Each camera provides strictly increasing integer timestamps and a motion intensity for every timestamp. For one camera, a motion period is a maximal consecutive run of samples whose intensity is at least threshold; its inclusive interval runs from the first qualifying timestamp through the last. Return the sorted inclusive intervals during which every camera is simultaneously in one of its motion periods. Function commonMotionIntervals(timestamps: int[][], intensities: double[][], threshold: double) → int[][] Examples Example 1 timestamps = [[1,2,3,4,5]] intensities = [[0.1,0.7,0.8,0.2,0.9]] threshold = 0.6 return = [[2,3],[5,5]] The qualifying samples form two maximal runs. Example 2 timestamps = [[1,2,3,4,5],[0,2,3,5,6]] intensities = [[0.8,0.8,0.2,0.9,0.9],[0.1,0.7,0.7,0.7,0.2]] threshold = 0.7 return = [[2,2],[4,5]] Intersecting [1,2] and [4,5] with the second camera's [2,5] gives two common periods. Constraints 1 <= timestamps.length == intensities.length <= 100 1 <= timestamps[c].length == intensities[c].length The total sample count is at most 200000. Each timestamp row is strictly increasing and values fit in signed 32-bit integers. 0.0 <= intensities[c][i], threshold <= 1.0
Reported by candidates. Source: FastPrep
Pattern and pitfall
The trick is two stages. First, per camera, scan once and build inclusive intervals from the first qualifying timestamp to the last in each consecutive run of qualifying samples. Consecutive means adjacent in that camera's sample list, not adjacent integers. Example 2 shows it: camera two has 0,2,3,5,6 and the run 2,3,5 becomes [2,5] even though 4 is missing. Second, intersect the interval lists. Fold across cameras, keeping a running result and intersecting it with each next list using two pointers: lo = max of starts, hi = min of ends, emit if lo <= hi, then advance whichever ends first. Pitfalls: using strict greater-than on the threshold, emitting single-point intervals wrongly like [5,5], and exiting early on an empty list. With 200000 samples and up to 100 cameras, the whole thing is linear in total samples times a small factor. If the pointer logic slips under pressure, StealthCoder is the hedge for the live OA.
If you see this problem in your OA tomorrow, the play is to recognize the pattern in 30 seconds. StealthCoder buys you that recognition.
You can drill Common Camera Motion Intervals cold, or you can hedge it. StealthCoder runs invisibly during screen share and surfaces a working solution in under 2 seconds. The proctor sees the IDE. They don't see what's behind it. Built by an Amazon engineer who passed his OA cold and still thinks the filter is broken.
Get StealthCoderRelated leaked OAs
You've seen the question.
Make sure you actually pass Verkada's OA.
Verkada reuses patterns across OAs. Built by an Amazon engineer who passed his OA cold and still thinks the filter is broken. Works on HackerRank, CodeSignal, CoderPad, and Karat.
Common Camera Motion Intervals FAQ
What's the core trick in Common Camera Motion Intervals?+
Split it into two passes. Build each camera's inclusive motion intervals from runs of samples at or above the threshold, then intersect the interval lists with a two-pointer sweep. Don't try to merge all timestamps into one giant timeline. That gets messy fast.
Do missing timestamps break a motion run?+
No. A run is consecutive in that camera's own sample list. If samples at 2, 3 and 5 all qualify and 4 doesn't exist, the interval is [2,5]. The problem's second example relies on exactly this, so don't check for integer adjacency.
How do I intersect interval lists across many cameras?+
Keep a running result list. For each next camera, walk both lists with two pointers. Take max of starts and min of ends, emit if start is at most end, then advance the pointer whose interval ends first. Repeat for all cameras. Stop early if the result goes empty.
What edge cases should I test before submitting?+
Test a single-sample run like [5,5], intensity exactly equal to the threshold, a camera with no qualifying samples, and intervals that touch at one point. Also test one camera only, where the answer is just its own intervals.
How do I prepare for this in 48 hours?+
Practice interval intersection with two pointers until you can write it from memory. Then write the run-building scan. Both pieces are short. Verkada's September 2026 report suggests the difficulty is in the details, so trace both examples by hand.