C3 AI Software Engineer Phone Screen Questions

There were two questions in total. (Question practice website: 1146) (Question practice website: 437) fail

## Problem Given a grid with multiple people, find the point that minimizes the total travel distance for all to meet. ## Likely LeetCode equivalent LC 296 - Best Meeting Point (>80% confident) ## Tags matrix, math, sorting

## Problem Return the values of nodes visible from the right side of a binary tree, one per level. ## Likely LeetCode equivalent LC 199 - Binary Tree Right Side View (>80% confident) ## Tags binary_tree, bfs, dfs

## Problem Design a browser history data structure supporting visit, back, and forward operations. ## Likely LeetCode equivalent LC 1472 - Design Browser History (>80% confident) ## Tags design, stack, arrays

## Problem You are building an equity management tool. Given a list of share issuances and transfers, compute each stakeholder's current share count and ownership percentage. Operations: - `issue(to, shares)` - issue new shares to a stakeholder. - `transfer(from, to, shares)` - transfer shares between stakeholders. - `ownership() -> dict` - return `{stakeholder: (shares, pct)}` for all holders. ```python class CapTable: def issue(self, to: str, shares: int): ... def transfer(self, frm: str, to: str, shares: int): ... def ownership(self) -> dict: ... def total_shares(self) -> int: ... ``` **Example:** ``` cap = CapTable() cap.issue("Alice", 1000) cap.issue("Bob", 500) cap.transfer("Alice", "Carol", 200) cap.ownership() -> { "Alice": (800, 53.33%), "Bob": (500, 33.33%), "Carol": (200, 13.33%) } ``` ## Follow-ups 1. What happens if a transfer exceeds the sender's current holdings - raise or clamp? 2. How would you model vesting schedules (shares unlock monthly over 4 years)? 3. Add a dilution event: a new funding round issues shares and all existing percentages shrink. 4. How would you audit the full history of ownership at any past date?

## Problem Group an array of strings so that anagrams appear together, using a hash map keyed on sorted characters. ## Likely LeetCode equivalent LC 49 - Group Anagrams (>80% confident) ## Tags hash_table, strings, sorting

## Problem Given a list of daily temperature readings and a window size `k`, return the highest temperature recorded in each consecutive window of `k` days. ```python def highest_temperatures(temps: List[float], k: int) -> List[float]: ... ``` **Example:** ``` Input: temps=[3.1, 1.2, 4.5, 2.7, 6.0, 1.9, 3.3], k=3 Output: [4.5, 4.5, 6.0, 6.0, 6.0] # Windows: [3.1,1.2,4.5]->[4.5], [1.2,4.5,2.7]->[4.5], # [4.5,2.7,6.0]->[6.0], [2.7,6.0,1.9]->[6.0], [6.0,1.9,3.3]->[6.0] ``` ## Approach Use a monotonic deque. Maintain indices of temperatures in decreasing order. For each new element, pop the back of the deque while it holds smaller values. Pop the front if it slides out of the window. The front always holds the current max. Time: O(n). Space: O(k). ## Follow-ups 1. How does the deque approach work - walk through the invariant being maintained. 2. Extend to also return the minimum in each window simultaneously. 3. How would you handle missing readings (NaN) in the temperature series? 4. If readings arrive as a stream, how do you maintain the rolling max in O(1) amortized per element?

## Problem Design an iterator that interleaves elements from multiple input iterators in round-robin or alternating order. ## Likely LeetCode equivalent No direct unambiguous LC equivalent. ## Tags design, queue, iterator

## Problem Implement the following JavaScript utility functions without using the built-in equivalents: **Part 1:** Implement `myReduce(arr, fn, initialValue)` matching the behavior of `Array.prototype.reduce`. **Part 2:** Implement `myPromiseAll(promises)` matching `Promise.all` - resolves when all resolve, rejects on first rejection. **Part 3:** Implement `myFlatten(arr, depth)` matching `Array.prototype.flat(depth)`. ```js // Part 1 myReduce([1,2,3,4], (acc, x) => acc + x, 0) // -> 10 // Part 2 myPromiseAll([Promise.resolve(1), Promise.resolve(2)]).then(vs => console.log(vs)) // -> [1, 2] // Part 3 myFlatten([1,[2,[3,[4]]]],2) // -> [1, 2, 3, [4]] ``` ## Follow-ups 1. How would you implement `myPromiseAllSettled` that never rejects? 2. What happens in your `myReduce` if no `initialValue` is provided? 3. Implement `myPromiseRace` - resolves or rejects with the first settled promise. 4. How would you implement lazy evaluation using generators instead of `reduce`?

## Problem Find the contiguous subarray with the largest sum using Kadane's algorithm. ## Likely LeetCode equivalent LC 53 - Maximum Subarray (>80% confident) ## Tags arrays, dynamic_programming

## Problem Build a product listing table component. Given an array of product objects, render a table with: - Columns: Name, Category, Price, Stock. - Clicking a column header toggles sort ascending/descending on that column. - A text input filters products by name (case-insensitive, debounced 300ms). - A category dropdown filters to a single category (or "All"). - Show "No results" when the filtered list is empty. ```jsx // Data shape // {id, name, category, price, stock} function ProductTable({ products }) { // ... } ``` **Expected behavior:** ``` User clicks "Price" header -> sorted ascending by price User clicks "Price" again -> sorted descending User types "lap" in search -> shows only products with "lap" in name User selects "Electronics" in dropdown -> combined with active sort ``` ## Follow-ups 1. How do you compose sort and filter without re-deriving state on every keystroke? 2. How would you virtualize the list if there are 10,000 products? 3. Describe how to persist the sort/filter state in the URL query string. 4. How would you make the table accessible for screen readers?

## Problem Count the number of contiguous subarrays that sum to a target value k using prefix sums and a hash map. ## Likely LeetCode equivalent LC 560 - Subarray Sum Equals K (>80% confident) ## Tags arrays, hash_table, prefix_sum

## Problem Implement a `TimerQueue` class that schedules callbacks to run after a specified delay. It must support cancellation. ```python import time import threading class TimerQueue: def schedule(self, delay_ms: int, callback: callable) -> int: # Returns a timer_id ... def cancel(self, timer_id: int) -> bool: # Returns True if successfully canceled, False if already fired ... def shutdown(self): # Cancel all pending timers and release resources ... ``` **Expected behavior:** ``` tq = TimerQueue() id1 = tq.schedule(500, lambda: print("A")) # fires after 500ms id2 = tq.schedule(200, lambda: print("B")) # fires after 200ms tq.cancel(id1) # After 200ms: prints "B" # "A" never fires ``` ## Follow-ups 1. How do you implement this using a min-heap to efficiently find the next timer to fire? 2. What is the risk of a race condition between `schedule` and `cancel` and how do you prevent it? 3. How would you implement `reschedule(timer_id, new_delay_ms)`? 4. How does this compare to the JavaScript event loop's `setTimeout`/`clearTimeout` internals?

## Problem Given the root of a binary tree and a target integer `k`, return all root-to-leaf paths where the sum of node values equals `k`. Each path is a list of node values from root to leaf. ```python class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right def path_sum(root: TreeNode, k: int) -> List[List[int]]: ... ``` **Example:** ``` Tree: 5 / \ 4 8 / / \ 11 13 4 / \ \ 7 2 1 path_sum(root, 22) -> [[5,4,11,2], [5,8,4,5]] # Wait - no "5" child; path_sum(root, 22) -> [[5,4,11,2]] ``` ## Follow-ups 1. Modify to return the maximum sum path (not necessarily root-to-leaf - any path allowed). 2. How does the solution change for an N-ary tree? 3. How would you count the number of paths (not just root-to-leaf) summing to `k`? What data structure helps? 4. Handle negative node values - does your current solution still work?