Xai Software Engineer Onsite Coding Questions

## Problem Design a durable (persistent) cache that survives process restarts, combining in-memory speed with disk-backed durability. ## Likely LeetCode equivalent No confident LC match. ## Tags hash_table, design, xai, cache

## Problem Build a `DynamicBatcher` that collects incoming requests and flushes them as a batch either when the batch reaches `max_size` items or after `max_wait_ms` milliseconds since the first request in the batch arrived — whichever comes first. ```python class DynamicBatcher: def __init__(self, max_size: int, max_wait_ms: int, process_batch: Callable[[list], list]): ... def submit(self, request: dict) -> Future: """ Returns a Future that resolves when the batch containing this request has been processed. """ ``` **Example behavior:** ``` batcher = DynamicBatcher(max_size=10, max_wait_ms=50, process_batch=db_bulk_insert) f1 = batcher.submit({"id": 1, "data": "..."}) f2 = batcher.submit({"id": 2, "data": "..."}) # If 8 more arrive within 50ms -> all 10 flushed together # If timeout hits first -> flush whatever is pending ``` ## Follow-ups 1. How do you associate each request's Future with its position in the batch result list? 2. What threading model do you use — a background flusher thread, asyncio, or something else? 3. How do you handle partial batch failures where some items succeed and others fail? 4. If the process_batch function is slow and requests pile up, how do you add backpressure?

## Problem Design a real-time audio broadcasting system (similar to Twitter Spaces) handling large concurrent audiences. ## Likely LeetCode equivalent No LC equivalent; system design question. ## Tags system_design, xai, real_time, audio

## Problem: Implement Two Distributed Matrix Multiplication Strategies (DP and FSDP) Using a Communication Simulator You need to implement distributed matrix multiplication **C = A @ B** in a simulat

## Problem: Design a Restorable (Checkpointable) Iterator Design an iterator wrapper `RestorableIterator` that wraps an existing iterator (or an array/list). In addition to normal iteration via `next

## Token Limiter (Rate limiting / quota) Implement a **Token Limiter** component that limits token (quota) consumption for a subject (e.g., userId / apiKey / tenant) under a given rule set. > Note:

## Problem: Unflatten a Nested Template Structure Given a flat list of integers and a nested template structure, refill the template’s leaf integer positions in order to produce a new object with the

## Problem: Flatten a Nested Structure When working with hierarchical data, you may need to convert a nested structure into a flat list. ### Input Given a nested Python-like data structure `structur

Conduct research and machine learning coding

Find the kth largest element in a data stream. Implement stream processing to handle the kth largest element in each time window of a large data stream. Use a queue to manage the time window and bucke

Handwrite a parallelized sort algorithm. ### Sample Input ``` 32 12 45 78 23 56 2 98 65 ``` ### Sample Output ``` 2 12 23 32 45 56 65 78 98 ``` ### Test Cases **Case 1** Input: ``` 32 12 45 78 23

Design a rate limiter to control request flow. Limit the frequency of requests within a given time window. ### Sample Input ``` max_requests=10\ntime_window=60 ``` ### Sample Output ``` true\ntrue\n

Design a key-value store system. It should support basic add, delete, and find operations while considering performance. ### Sample Input ``` add key1 value1\nfind key1\ndelete key1\nfind key1\n ```

Given an integer array, sort it. You are required to use multithreading to complete the sorting. ### Sample Input ``` 8 4 10 3 6 9 ``` ### Sample Output ``` 3 4 6 8 9 10 ``` ### Test Cases **Case

Given a list of integers that represent the capacity of rice bags, design an algorithm to determine how to select bags such that their total capacity exceeds a given target. Output the sequence of sel

You need to build a Twitter Insight platform that extracts data from the Twitter API and provides insights. The task includes the following features: 1. Implement a feature that retrieves tweets rela

Given a document string and a list of integers nlist, for each n in nlist, compute the most frequent n-gram in the document. Implement a function `find_most_common_ngrams(doc: str, nlist: List[int])

## Problem Given the root of a binary tree, a node is "bad" if its value does not lie within the range `[min_val, max_val]` inherited from its ancestors (similar to BST validity). Remove all bad nodes and their subtrees. Return the modified root. ```python class TreeNode: def __init__(self, val=0, left=None, right=None): ... def remove_bad_nodes( root: TreeNode, min_val: int = float('-inf'), max_val: int = float('inf') ) -> TreeNode | None: pass ``` **Example:** ``` Tree: 5 / \ 1 8 / \ 0 3 Range enforced: left child must be < parent, right child must be > parent Node 8 is bad if 8 > 5 is allowed, but 0 < 1 left of 5... walk through your definition. Output: cleaned tree with only valid-range nodes remaining. ``` ## Follow-ups 1. How does the valid range narrow as you traverse left vs. right? 2. What is the time complexity? Can you do this iteratively? 3. If a bad node has valid children, should the children be re-attached? Why or why not? 4. How would you extend this to an N-ary tree where each child has a specific position constraint?

Implement an in-memory database task with multiple levels of features. The database supports records identified by string keys, each containing multiple string field-value pairs. ### Level 1 - Basic