xAI Software Engineer System Design Questions

1. Background: The 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.
2. Requirements:
1. The class should allow user logins and logouts.
2. Handle session timeouts after a specified duration.
3. Validate existing sessions.
4. Store session data securely.3. Class API:
- 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:
- Input: login('user123') → Output: session_id_abc
- Explanation: User user123 successfully logs in and receives a session ID.5. Constraints:
- Max 1000 active sessions.
- Session timeout duration: 30 minutes.
- Session IDs are unique.
- Thread-safe operations.

As xAI expands its machine learning capabilities, we need a robust API to manage model training, predictions, and evaluations. This API should handle requests efficiently and return results in a unified format.
Problem Statement: Design an API that allows users to submit training data, request model training, and retrieve predictions. The API should support the following operations: POST /train, GET /predict, and GET /status. Ensure to consider versioning and error handling in your design.
Example Operations:

• POST /train: Accepts a JSON payload with data and returns a 201 status with a task ID.


• GET /predict: Accepts a task ID and returns predictions based on trained data.


• GET /status: Checks the status of the training job based on task ID.

Constraints:

• Ensure the API can handle a minimum of 1000 concurrent requests with low latency.


• Should support flexible data formats (CSV, JSON).

To enhance performance for xAI's machine learning algorithms, we need a fast, in-memory caching system to store frequently accessed data. This system should allow for efficient data retrieval and support for automatic eviction of old data.
Problem Statement: Design a custom cache that supports the following operations: put(key: int, value: int): void and get(key: int): int. When the cache reaches its capacity, it should invalidate the least recently used (LRU) item.

• class LRUCache:


• def __init__(self, capacity: int): Initializes the cache with a positive size capacity.


• def get(self, key: int) -> int: Returns the value of the key if the key exists, otherwise returns -1.


• def put(self, key: int, value: int) -> None: Updates or adds the value if the key is not present. When the cache reaches its capacity, it should invalidate the least recently used item before adding the new item.

Example 1:
Input:
LRUCache cache = new LRUCache(2);
cache.put(1, 1);
cache.put(2, 2);
cache.get(1); // returns 1
cache.put(3, 3); // evicts key 2
cache.get(2); // returns -1 (not found)
Example 2:
Input:
LRUCache cache = new LRUCache(1);
cache.put(1, 1);
cache.get(1); // returns 1
cache.put(2, 2); // evicts key 1
cache.get(1); // returns -1 (not found)
Constraints:

• 1 <= capacity <= 3000


• 0 <= key <= 10000


• 0 <= value <= 10^9.

To accelerate response times from our AI models, xAI needs to implement a caching mechanism for the frequently accessed data.
Design and implement a simple LRU Cache class that supports the following operations:

• get(key: int) -> int: Retrieve the value of the key if the key exists in the cache, otherwise return -1.


• put(key: int, value: int) -> None: Update the value of the key if the key exists. If the key does not exist, add the key-value pair to the cache. If the cache reaches its capacity, it should invalidate the least recently used item before inserting a new item.

Example Method Signatures:

• def get(self, key: int) -> int


• def put(self, key: int, value: int) -> None

Example 1:
Input: cache = LRUCache(2), cache.put(1, 1), cache.put(2, 2), cache.get(1)
Output: 1 Example 2:
Input: cache.put(3, 3), cache.get(2)
Output: -1
Explanation: The least recently used key (2) was removed because the cache reached its capacity.Constraints:

• capacity is at most 3000.