xAI software engineer interviews cover algorithms, data structures, system design, and coding problems drawn from real interview rounds.
n environmental sensors labeled 0 to n - 1. Each sensor is either functioning correctly or corrupted, but you do...Input: Listnums, return the maximum sum of non-adjacent elements. Specifically, if you choose an element, you cannot choose the elements immediately before or after it. def max_sum_non_adjacent(nums: List[int]) -> int: nums = [2, 4, 6, 2, 5] 13 nums = [1, 2, 3, 1] 4 1 <= len(nums) <= 100 0 <= nums[i] <= 400 Tokenizer class that allows you to add words and tokenize sentences into a list of words. The tokenizer should be able to handle spaces and punctuation correctly. The key methods should utilize a trie data structure, which enables efficient storage and retrieval of words. class Tokenizer: def add_word(self, word: str) -> None: def tokenize(self, sentence: str) -> List[str]: tokenizer = Tokenizer() tokenizer.add_word("hello") tokenizer.add_word("world") output = tokenizer.tokenize("hello world!") ['hello', 'world'] tokenizer.tokenize("xAI is amazing.") ['xAI', 'is', 'amazing'] KthLargest that keeps track of the kth largest element in a dynamically updating stream of integers. The class should support the method add(int val), which adds an integer to the stream and returns the current kth largest element.class KthLargest:def __init__(self, k: int, nums: List[int]) -> None:def add(self, val: int) -> int: k = 3, nums = [4, 5, 8, 2] KthLargest kthLargest = KthLargest(k, nums) kthLargest.add(3) 4 3, the third largest number is 4. Example 2: kthLargest.add(5) 5 5. Constraints: 1 <= k <= 104 0 <= nums.length <= 104 -104 <= nums[i] <= 104 -104 <= val <= 104 104 calls will be made to add. None) in an input list of integers. The function should return the indices of the None values in ascending order.def find_missing_indices(data: List[Optional[int]]) -> List[int]: find_missing_indices([1, None, 3, None, 5]) [1, 3] find_missing_indices([None, None, 2, 4]) [0, 1] data will have at most 10^4 elements. None. def shortest_path(graph: List[List[int]], start: int, end: int) -> int:graph = [[1, 2], [0, 2, 3], [0, 1], [1]], start = 0, end = 3 2 graph = [[1], [0, 2], [1, 3], [2]], start = 0, end = 3 3 1 <= graph.length <= 1000 0 <= start, end < graph.length 0 <= graph[i].length <= 1000now_ms. Before performing that operation, remove every request whose expiration time is at most now_ms. Expiration is arrival_ms + ttl_ms. Time is nondecreasing across calls, and expiration takes precedence over selection or cancellation.submit returns false if its ID is already pending after expiration cleanup; otherwise it appends the request and returns true. Duplicate submissions must not update the existing request. An ID may be reused after its request expires, is canceled, or is dispatched.max_tokens; its pending request count is at least max_requests; or its oldest pending request has waited at least max_wait_ms. Among ready models, choose the model whose oldest pending request was inserted earliest. Insertion order, not model-name order, breaks equal-arrival-time ties.next_batch removes and returns exactly one batch for the selected model. Take the longest nonempty prefix of that model's insertion-ordered queue that fits both limits. Stop at the first request that would exceed a limit: do not skip it to fit smaller requests behind it. If no model is ready, return an empty list. A readiness threshold is based on the entire model queue, even when only a short prefix fits.GrokRequestBatcher(max_tokens: int, max_requests: int, max_wait_ms: int) — construct an empty batcher with fixed limits.submit(request_id: str, model: str, tokens: int, now_ms: int, ttl_ms: int) -> bool — clean up expired requests, then attempt to enqueue a request.cancel(request_id: str, now_ms: int) -> bool — clean up expired requests, then remove the specified pending request; return whether it existed.next_batch(now_ms: int) -> list[str] — clean up expired requests, select one ready model, and return dispatched IDs in that model's queue order.pending(now_ms: int) -> list[str] — clean up expired requests and return all remaining IDs in global insertion order.text:{
"config": {"max_tokens": 10, "max_requests": 3, "max_wait_ms": 50},
"calls": [
["submit", "a", "text", 6, 0, 100],
["submit", "b", "text", 5, 1, 100],
["submit", "c", "text", 4, 2, 100],
["next_batch", 2],
["next_batch", 3],
["next_batch", 51],
["pending", 51]
]
}[true, true, true, ["a"], [], ["b", "c"], []]
text is ready because its total reservation is 6 + 5 + 4 = 15 >= 10 and its count is 3. The batch contains only a: adding b would use 11 tokens, and skipping b to include c is forbidden. At time 3, the remaining total is 9 and the oldest request has waited only 2 ms. At time 51, b has waited exactly 50 ms, so b and c dispatch together.Example 2:{
"config": {"max_tokens": 8, "max_requests": 2, "max_wait_ms": 20},
"calls": [
["submit", "x", "text", 3, 0, 10],
["submit", "y", "vision", 4, 1, 100],
["submit", "z", "vision", 4, 2, 100],
["next_batch", 2],
["submit", "w", "text", 5, 3, 100],
["cancel", "w", 4],
["pending", 10],
["cancel", "x", 10],
["submit", "x", "text", 8, 10, 5],
["submit", "x", "text", 1, 10, 100],
["next_batch", 10]
]
}[true, true, true, ["y", "z"], true, true, [], false, true, false, ["x"]]
vision is ready: its two requests reserve 4 + 4 = 8 tokens. The older text request does not block it. Request w is canceled, and the original x expires exactly at time 10. Its ID can then be reused. The second submission of the new x is rejected without changing its 8-token reservation, so it dispatches immediately.Constraints1 <= max_tokens <= 1,000,000, 1 <= max_requests <= 1,000, and 0 <= max_wait_ms <= 1,000,000.1 <= tokens <= max_tokens; 1 <= ttl_ms <= 1,000,000.UserSessionManager class is critical for xAI to handle user sessions securely and efficiently. It requires proper management of user logins, session timeouts, and session validation to ensure a consistent user experience across devices.login(user_id: str) -> str: Logs in a user and returns the session ID.logout(session_id: str) -> None: Logs out a user by invalidating their session ID.is_valid_session(session_id: str) -> bool: Checks if the session ID is valid.get_session_data(session_id: str) -> dict: Retrieves the session data associated with a session ID.4. Example 1:login('user123') → Output: session_id_abcuser123 successfully logs in and receives a session ID.5. Constraints:Sign up for free to access walkthroughs, AI-generated questions, and more.
Get Started Free