Samsara Software Engineer Interview Questions

## Problem Generate all permutations of axis values or coordinates using backtracking, covering all possible orderings. ## Likely LeetCode equivalent LeetCode 46 - Permutations. ## Tags backtracking,recursion,arrays,swe

## Round 1 - Coding / OOD ## Problem Design a command parser that reads a command string from the user, parses it into a command name and arguments, and dispatches it to a registered handler. Support flags (e.g., `--verbose`) and named arguments (e.g., `--output=file.txt`). ```python class CommandParser: def register(self, name: str, handler: callable, description: str = "") -> None: ... def parse(self, input_str: str) -> dict: # returns {"command": str, "args": list, "flags": set, "kwargs": dict} ... def execute(self, input_str: str) -> any: ... def help(self) -> str: ... ``` ## Example ``` parser = CommandParser() parser.register("greet", lambda args, **kw: f"Hello, {args[0]}!") parser.register("add", lambda args, **kw: sum(int(a) for a in args)) parser.execute("greet Alice --verbose") # parse -> {"command":"greet","args":["Alice"],"flags":{"verbose"},"kwargs":{}} # -> "Hello, Alice!" parser.execute("add 1 2 3 --output=result.txt") # -> 6, and kwargs has output="result.txt" parser.execute("unknown") # -> raises UnknownCommandError ``` ## Follow-ups 1. How do you handle quoted arguments with spaces, like `greet "Alice Smith"`? 2. How would you add argument type coercion so a handler can declare it expects integers? 3. How would you add tab-completion support for registered command names? 4. How does your design change if you need to support chaining commands with pipes, like `list | filter --active`?

## Problem Find the maximum number of concurrent meetings or minimum rooms required given a list of meeting time intervals. ## Likely LeetCode equivalent LeetCode 253 - Meeting Rooms II. ## Tags sorting,heap,intervals,swe

## Round 1 - Coding / OOD ## Problem Model a vehicle engine's lifecycle using a finite state machine. The engine has states: `OFF`, `STARTING`, `RUNNING`, `IDLE`, `ERROR`. Design the transition logic and make illegal transitions raise an error. ```python class EngineStateMachine: TRANSITIONS = { "OFF": {"start": "STARTING"}, "STARTING": {"started": "RUNNING", "fail": "ERROR"}, "RUNNING": {"idle": "IDLE", "stop": "OFF"}, "IDLE": {"revive": "RUNNING", "stop": "OFF"}, "ERROR": {"reset": "OFF"}, } def __init__(self): self.state = "OFF" def trigger(self, event: str) -> str: # returns new state or raises InvalidTransitionError ... def current_state(self) -> str: ... ``` ## Example ``` engine = EngineStateMachine() engine.trigger("start") -> "STARTING" engine.trigger("started") -> "RUNNING" engine.trigger("idle") -> "IDLE" engine.trigger("stop") -> "OFF" engine.trigger("started") -> raises InvalidTransitionError ``` ## Follow-ups 1. How would you add entry/exit callbacks for each state (e.g., log when entering ERROR)? 2. How do you serialize and restore the FSM's current state from persistent storage? 3. How would you extend this to a hierarchical FSM where RUNNING has sub-states like `ACCELERATING` and `CRUISING`? 4. How would you unit-test that all invalid transitions correctly raise errors?

## Round 1 - Coding ## Problem You have a pool of processing engines. Each engine receives tasks over time. Given a log of `(engine_id, task_id, start_time, end_time)`, compute each engine's utilization percentage over a specified observation window, and identify idle periods longer than a threshold. ```python def engine_utilization( logs: list[tuple[str, str, int, int]], window_start: int, window_end: int ) -> dict[str, float]: # returns {engine_id: utilization_percent} for the window ... def find_idle_periods( logs: list[tuple[str, str, int, int]], engine_id: str, min_idle: int ) -> list[tuple[int, int]]: # returns list of (start, end) idle intervals >= min_idle ... ``` ## Example ``` logs = [ ("E1", "T1", 0, 30), ("E1", "T2", 50, 80), ("E2", "T3", 10, 90), ] engine_utilization(logs, 0, 100) # E1: 30+30=60 busy out of 100 -> 60.0% # E2: 80 busy out of 100 -> 80.0% # -> {"E1": 60.0, "E2": 80.0} find_idle_periods(logs, "E1", min_idle=15) # -> [(30,50)] gap of 20 units >= 15 ``` ## Follow-ups 1. What if task intervals overlap for the same engine — how do you merge them before computing utilization? 2. How would you detect which engine is the bottleneck (highest utilization) in a pipeline? 3. How would you visualize utilization as a Gantt chart in ASCII output? 4. How does your solution scale when logs contain millions of records?

## Problem Given a collection of intervals, merge all overlapping intervals and return the merged result. ## Likely LeetCode equivalent LeetCode 56 - Merge Intervals. ## Tags sorting,arrays,intervals,swe

## Round 1 - Coding ## Problem Implement a markup processor that converts a simplified markdown string to HTML. Support: headers (`#`, `##`, `###`), bold (`**text**`), italic (`*text*`), and unordered lists (`- item`). ```python def markdown_to_html(md: str) -> str: ... ``` ## Example ``` md = """# Title ## Subtitle Hello **world** and *everyone*. - Item one - Item two """ markdown_to_html(md) # -> # <h1>Title</h1> # <h2>Subtitle</h2> # <p>Hello <strong>world</strong> and <em>everyone</em>.</p> # <ul><li>Item one</li><li>Item two</li></ul> ``` ## Follow-ups 1. How do you handle inline formatting (`**bold**`) that spans across what looks like a word boundary? 2. How would you support nested lists (indented ` - subitem`)? 3. What happens with malformed input like unclosed `**bold` — how do you handle that gracefully? 4. How would you extend the processor to support hyperlinks in the format `[text](url)`?

## Problem Find the maximum area of a connected region in a 2D grid, likely a variant of island area or histogram area problems. ## Likely LeetCode equivalent LeetCode 695 - Max Area of Island. ## Tags matrix,graph,dfs,swe

## Round 1 - Coding / OOD ## Problem In the card game Set, each card has 4 attributes: number (1/2/3), color (red/green/purple), shading (solid/striped/open), and shape (diamond/squiggle/oval). Three cards form a valid Set if for each attribute, the values across the three cards are either all the same or all different. ```python from dataclasses import dataclass @dataclass class Card: number: int # 1, 2, or 3 color: str shading: str shape: str def is_valid_set(c1: Card, c2: Card, c3: Card) -> bool: ... def find_all_sets(cards: list[Card]) -> list[tuple[Card, Card, Card]]: ... ``` ## Example ``` c1 = Card(1, "red", "solid", "diamond") c2 = Card(2, "green", "striped", "squiggle") c3 = Card(3, "purple", "open", "oval") is_valid_set(c1, c2, c3) -> True # all different on every attribute c4 = Card(1, "red", "solid", "oval") c5 = Card(2, "green", "striped", "oval") c6 = Card(3, "red", "open", "oval") # color: red/green/red -> invalid is_valid_set(c4, c5, c6) -> False ``` ## Follow-ups 1. What is the time complexity of `find_all_sets` for a board of `N` cards? Can you do better than O(N^3)? 2. How do you generate all 81 unique cards in the standard deck? 3. How would you detect when no valid Set exists on the current board (signaling the need to deal more cards)? 4. How would you design a solver that finds a Set in the minimum number of steps for a given board state?

## Problem Analyze a stream of temperature readings to detect anomalies or compute rolling statistics over a window. ## Likely LeetCode equivalent LeetCode 739 - Daily Temperatures. ## Tags stack,sliding_window,arrays,swe

## Round 1 - Coding / OOD ## Problem Design a `Trailer` data structure — a fixed-capacity circular buffer that keeps only the last `N` items added. Support adding items, iterating in insertion order, and querying the current count. ```python class Trailer: def __init__(self, capacity: int): ... def add(self, item) -> None: # oldest item is evicted when capacity is exceeded ... def __iter__(self): # yields items oldest to newest ... def __len__(self) -> int: ... def latest(self) -> any: # returns the most recently added item ... ``` ## Example ``` t = Trailer(3) t.add("a"); t.add("b"); t.add("c") list(t) -> ["a", "b", "c"] t.add("d") list(t) -> ["b", "c", "d"] # "a" evicted len(t) -> 3 t.latest() -> "d" ``` ## Follow-ups 1. What is the time complexity of `add` and iteration in your implementation? 2. How would you make this thread-safe for concurrent producers and consumers? 3. How would you extend this to support a `window_sum()` or `window_average()` that operates on numeric items in O(1)? 4. How does this differ from Python's `collections.deque(maxlen=N)` — what does `deque` give you for free?

## Round 1 - Coding / OOD ## Problem Design a valuable asset management system. Assets have an ID, name, category, current value, and acquisition date. Support adding assets, depreciating values over time, querying the highest-value assets per category, and computing total portfolio value. ```python class Asset: def __init__(self, asset_id: str, name: str, category: str, value: float, acquired: str): ... def depreciate(self, rate: float) -> None: # reduce value by rate percent ... class AssetManager: def add_asset(self, asset: Asset) -> None: ... def depreciate_all(self, category: str, rate: float) -> None: ... def top_assets(self, category: str, k: int) -> list[Asset]: ... def portfolio_value(self) -> float: ... ``` ## Example ``` mgr = AssetManager() mgr.add_asset(Asset("A1", "Laptop", "Electronics", 1200.0, "2023-01")) mgr.add_asset(Asset("A2", "Desk", "Furniture", 400.0, "2022-06")) mgr.add_asset(Asset("A3", "Projector","Electronics", 800.0, "2023-03")) mgr.depreciate_all("Electronics", 10) # 10% reduction mgr.portfolio_value() -> 1080+720+400 = 2200.0 mgr.top_assets("Electronics", 1) -> [Asset A1 at 1080.0] ``` ## Follow-ups 1. How do you keep `top_assets` efficient as the number of assets grows into the thousands? 2. How would you record a full depreciation history per asset? 3. How would you support bulk import of assets from a CSV file? 4. How do you handle assets transferred between categories?

## Round 1 - Coding ## Problem Implement a command processor for an autonomous vehicle. The vehicle has a position `(x, y)` and a heading direction (N/E/S/W). Process a sequence of commands: `F` (forward), `B` (backward), `L` (turn left 90 deg), `R` (turn right 90 deg). Return the final position and heading. ```python def process_commands(start_x: int, start_y: int, heading: str, commands: str) -> tuple[int, int, str]: # returns (x, y, heading) ... ``` ## Example ``` process_commands(0, 0, "N", "FFRFF") # F -> (0,1,N), F -> (0,2,N), R -> (0,2,E), F -> (1,2,E), F -> (2,2,E) # -> (2, 2, "E") process_commands(0, 0, "E", "FLF") # F -> (1,0,E), L -> (1,0,N), F -> (1,1,N) # -> (1, 1, "N") ``` ## Follow-ups 1. How would you add obstacles? The vehicle should stop before hitting one and report which command failed. 2. How do you handle commands to move by variable distances, like `F3` meaning move forward 3 units? 3. Extend to support a circular grid that wraps around at the edges. 4. How would you represent and process compound maneuvers like parallel parking as a named subroutine?