Databricks Hard Interview Questions

1. Background: In the Databricks ecosystem for financial services, managing stock orders efficiently and accurately is crucial. This problem relates to the order handling system for a stock broker, which must process orders in a transactional, reliable manner.
2. Problem Statement: You are tasked with developing a system that handles stock orders for a broker. The order system should process BUY and SELL orders and ensure no expired orders are processed. Each order has a unique ID, a stock symbol, a quantity, and a timestamp indicating when it was placed. Expired orders should be automatically removed from processing. Implement the method void processOrder(Order order) and return a list of confirmed orders.
3. Function/class signature:
- class Order:
- def __init__(self, order_id: int, stock_symbol: str, quantity: int, timestamp: int):
- def processOrder(self, order: Order) -> List[Order]:
4. Example 1:
- Input: Order(1, "AAPL", 10, 100)
- Output: Confirmed Order: Order(1, "AAPL", 10, 100)
- Explanation: A valid buy order is placed and confirmed.
5. Example 2:
- Input: Order(2, "GOOG", 5, 50) (expired order is not processed)
- Output: []
- Explanation: The order has expired and is not confirmed.
6. Constraints:
- 0 < order_id <= 10^6
- 0 < quantity <= 1000
- timestamp is a positive integer designating the order time.

Background: In Databricks, efficient data processing often involves navigating complex dependency graphs for job scheduling. Understanding how to find the shortest path in a directed graph can optimize such workflows.
Problem statement: Given a directed graph represented as an adjacency list, implement a function to find the shortest path from a starting node to a destination node. Each edge has a weight that represents the time taken to travel along that edge. If there is no path, return -1.
Function/class signature:

• def shortest_path(graph: Dict[int, List[Tuple[int, int]]], start: int, destination: int) -> Union[int, List[int]]:

Example 1:
Input: graph = {0: [(1, 4), (2, 2)], 1: [(3, 1)], 2: [(1, 1), (3, 5)], 3: []}, start = 0, destination = 3
Output: 5
Explanation: The shortest path is 0 -> 2 -> 1 -> 3, which has a total weight of 5.Example 2:
Input: graph = {0: [(1, 4), (2, 1)], 1: [(3, 1)], 2: [(1, 2), (3, 5)], 3: []}, start = 0, destination = 1
Output: 4 Constraints:

• The number of nodes in the graph will be 1 <= len(graph) <= 100.


• Each edge's weight is a positive integer not exceeding 10^3.


• No cycles will be present in the graph.