Citadel Medium Interview Questions

Background: Citadel operates in the finance sector, where a high-performance order book is crucial for trading. Properly managing orders in a concurrent environment without losing data integrity is essential.
Problem statement: Implement a thread-safe in-memory order book that can handle incoming orders and allow retrieval of current orders. You need to ensure that multiple threads can add, remove, and view orders without data corruption. Use a data structure for storing orders, ensuring that concurrent modifications don't lead to inconsistent views of the orders.
Function/class signature:

• class OrderBook:


• def add_order(order_id: str, price: float, quantity: int) -> None: Adds an order to the order book.


• def remove_order(order_id: str) -> bool: Removes an order from the order book by order ID.


• def get_current_orders() -> List[Dict[str, Union[str, float, int]]]: Returns a list of current orders.

Example 1:
Input: add_order("123", 100.0, 5)
Output: None
Explanation: Adds an order with ID "123", price 100.0, and quantity 5.
Example 2:
Input: remove_order("123")
Output: True
Explanation: Removes the order with ID "123" successfully.
Constraints:

• Order ID is a unique string.


• Price is a positive float.


• Quantity is a positive integer.


• The maximum number of orders is 1,000,000.


• The solution must be thread-safe.

Background: Citadel deals with a vast amount of data and needs to identify patterns quickly for data analysis and decision-making. Finding the longest consecutive sequence in a dataset could play a vital role in financial modeling and forecasting.
Problem statement: You are given an unsorted array of integers. Your task is to find the length of the longest consecutive elements sequence. The consecutive elements can be from any range of numbers. You need to return the length of this sequence.
Function/class signature:

• def longest_consecutive(nums: List[int]) -> int:

Example 1:

• Input: nums = [100, 4, 200, 1, 3, 2]


• Output: 4


• Explanation: The longest consecutive sequence is [1, 2, 3, 4], which has a length of 4.

Example 2:

• Input: nums = [0, 3, 7, 2, 5, 8, 4, 6, 1]


• Output: 9


• Explanation: The longest consecutive sequence is [0, 1, 2, 3, 4, 5, 6, 7, 8], which has a length of 9.

Constraints:

• 0 <= nums.length <= 10^4


• -10^9 <= nums[i] <= 10^9

Background: In financial modeling and algorithmic trading, Citadel needs to navigate data structures efficiently for optimal decision-making. This problem relates to traversing market data represented in a graph.
Problem statement: Given a directed graph represented as an adjacency list, find the minimum number of edges required to reach from a start node to a target node. Consider each edge represents a possible market movements. The goal is to help traders optimize their strategies by determining the quickest route through the data structure.
Function/class signature:

• def min_steps(graph: List[List[int]], start: int, target: int) -> int:

Example 1:
Input: graph = [[1,2],[2],[3],[4],[]], start=0, target=4
Output: 3
Explanation: 0 -> 1 -> 2 -> 4 requires 3 steps.
Example 2:
Input: graph = [[1],[2],[3],[4],[5],[]], start=0, target=5
Output: 5
Constraints:

• The graph will have at most 100 nodes.


• Each node will have at most 10 outgoing edges.


• 0 <= start, target < 100


• The input graph is zero-based indexed.