Stripe Software Engineer Coding Questions

Background: In Stripe's payment processing system, understanding transaction flows is crucial for identifying bottlenecks and optimizing performance. This problem is related to ensuring that transaction paths are efficient.Problem statement: You are given a directed graph where each node represents a transaction, and an edge from A to B indicates that transaction A directly leads to transaction B. Write a function that finds the shortest path from a given start transaction to an end transaction. Return the path as a list of transactions. If there is no path, return an empty list.Function/class signature:

• def find_shortest_transaction_path(transactions: List[Tuple[str, str]], start: str, end: str) -> List[str]:

Example 1:

• Input: transactions = [("A", "B"), ("B", "C"), ("A", "C")], start = "A", end = "C"


• Output: ['A', 'C']


• Explanation: The direct path from A to C has the shortest length.

Example 2:

• Input: transactions = [("A", "B"), ("B", "C"), ("C", "A")], start = "A", end = "D"


• Output: []


• Explanation: There is no transaction D present.

Constraints:

• The number of transactions will not exceed 1000.


• Each transaction is represented as a unique string.

Background: Stripe processes millions of transactions daily. Occasionally, payments may not be fully completed due to various issues (e.g., network failures, user cancellations). Identifying unprocessed payments quickly can help improve user experience and operational efficiency.
Problem statement: You are given a list of payment IDs. Some payments are successfully processed, while others remain unprocessed, indicated by their accompanying status (either processed or unprocessed). Create a function that returns all payment IDs that are unprocessed.
Function/class signature:

• def find_unprocessed_payments(payment_list: List[Tuple[str, str]]) -> List[str]:

Example 1:
Input: payment_list = [('abc123', 'processed'), ('xyz789', 'unprocessed'), ('qwe456', 'processed')]
Output: ['xyz789']
Explanation: Only the payment with ID xyz789 is unprocessed.Example 2:
Input: payment_list = [('p1', 'unprocessed'), ('p2', 'unprocessed'), ('p3', 'processed')]
Output: ['p1', 'p2']
Explanation: Both payments p1 and p2 are classified as unprocessed.Constraints:

• The length of payment_list can be between 1 and 10^5.


• Each payment ID is a string of up to 100 characters.


• Each status is guaranteed to be either processed or unprocessed.

To improve user experience, Stripe needs a data structure to represent users' transaction histories in a way that allows for efficient retrieval and management.
Problem statement: Design a transaction history structure where each transaction has an int transactionId, double amount, string date, and nested transactions. Implement methods to add a transaction and to retrieve the transaction with the highest amount.

• addTransaction(transactionId: int, amount: double, date: string): void: Add a transaction to the history.


• getMaxTransaction(): (int, double, string): Returns the ID, amount, and date of the transaction with the highest amount.

Example 1:
Input: addTransaction(1, 100.50, '2023-03-01')
Output: NoneExample 2:
Input: addTransaction(2, 200.75, '2023-03-02')
Output: NoneInput: getMaxTransaction()
Output: (2, 200.75, '2023-03-02')
Constraints:

• 1 <= transactionId <= 10^6


• 0 <= amount <= 10^6


• date follows the format 'YYYY-MM-DD'.

In order to protect our APIs from abuse and to ensure fair usage, Stripe requires a sliding window rate limiter that tracks the number of requests for each API key over a given time period.
Problem statement: You need to implement a rate limiter that allows a specified number of requests per minute (e.g., 100 requests) for each unique string apiKey. Ensure that the rate limiter has a method to track requests and should return a boolean indicating whether the request is allowed.

• trackRequest(apiKey: string): boolean: Returns true if the request is allowed, false otherwise.

Example 1:
Input: trackRequest('key1')
Output: true
Explanation: The request is allowed.Example 2:
Input: trackRequest('key1') (100 times)
Output: true (first 100 calls)
Output: false (101st call)
Constraints:

• 1 <= apiKey.length <= 100


• Rate limit can be bursty but should not exceed specified limits.


• Simulate up to 10^6 requests.