Coinbase Medium Interview Questions

Background: In the world of cryptocurrency, understanding the quickest way to transfer assets across different wallets is critical for maintaining low transaction fees and efficient trading. This problem relates to optimizing transfers in Coinbase's wallet services.Problem statement: Given a directed graph where nodes represent wallets and edges represent direct transactions between them, you need to find the shortest path (in terms of transaction hops) from a starting wallet startNode to a destination wallet endNode. Each edge is equivalent to a transaction that can either be successful or failed. If no such path exists, return None.Function/class signature:

• def shortest_path(graph: Dict[str, List[str]], startNode: str, endNode: str) -> Optional[List[str]]:

Example 1:
Input:
graph = { 'A': ['B', 'C'], 'B': ['D'], 'C': ['D'], 'D': [] }
startNode = 'A'
endNode = 'D'
Output:
['A', 'B', 'D']
Explanation: The shortest path from A to D is through B.Example 2:
Input:
graph = { 'A': ['B', 'C'], 'B': [], 'C': ['D'], 'D': [] }
startNode = 'A'
endNode = 'D'
Output:
None
Explanation: There is no path from A to D.Constraints:

• Node names are alphanumeric strings with max length 50.


• Graph can have up to 10^5 nodes.


• Transactions (edges) can be up to 2 * 10^5 in the worst case.

Background: As a cryptocurrency exchange, Coinbase needs to efficiently manage and filter transaction data to ensure compliance and enhance user security. This system should enable the detection of suspicious transactions and provide insights for further investigation.Problem statement: You are tasked with building a TransactionFilter class that filters a list of transactions based on specific criteria. Each transaction is represented as a dictionary containing amount, currency, timestamp, and status. The class should have a method filter_transactions(transactions: List[Dict[str, Union[str, float]]], min_amount: float, currency_filter: str) -> List[Dict[str, Union[str, float]]] that returns all transactions where the amount is greater than or equal to min_amount and matches the given currency_filter. Function/class signature:

• class TransactionFilter:


• def filter_transactions(transactions: List[Dict[str, Union[str, float]]], min_amount: float, currency_filter: str) -> List[Dict[str, Union[str, float]]]:

Example 1:

• Input: transactions = [{'amount': 100.0, 'currency': 'USD', 'timestamp': '2023-10-01', 'status': 'completed'}, {'amount': 50.5, 'currency': 'EUR', 'timestamp': '2023-10-02', 'status': 'pending'}, {'amount': 150.0, 'currency': 'USD', 'timestamp': '2023-10-03', 'status': 'completed'}], min_amount = 100.0, currency_filter = 'USD'


• Output: [{'amount': 100.0, 'currency': 'USD', 'timestamp': '2023-10-01', 'status': 'completed'}, {'amount': 150.0, 'currency': 'USD', 'timestamp': '2023-10-03', 'status': 'completed'}]


• Explanation: Both transactions exceed the min_amount of 100.0 and are in USD.

Example 2:

• Input: transactions = [{'amount': 200.0, 'currency': 'USD', 'timestamp': '2023-09-01', 'status': 'completed'}, {'amount': 60.0, 'currency': 'EUR', 'timestamp': '2023-09-02', 'status': 'failed'}, {'amount': 150.0, 'currency': 'EUR', 'timestamp': '2023-09-03', 'status': 'completed'}], min_amount = 70.0, currency_filter = 'EUR'


• Output: [{'amount': 150.0, 'currency': 'EUR', 'timestamp': '2023-09-03', 'status': 'completed'}]


• Explanation: Only the last transaction meets the criteria of being greater than or equal to 70.0 and in EUR.

Constraints:

• All amounts are positive floats,


• Currency strings are limited to three uppercase letters,


• List of transactions has at most 10^4 entries.

Background: Coinbase seeks to optimize user trading strategies to enhance profit margins during market fluctuations. A well-structured algorithm can help calculate the best times to buy and sell currencies based on historical data.
Problem statement: Given an array of integers representing the prices of a cryptocurrency over a series of days, implement a function to determine the maximum profit that could be made by buying on one day and selling on another. You may only complete one transaction (i.e., buy one and sell one share of the cryptocurrency). The function should return 0 if no profit can be made.
Function Signature: def max_profit(prices: List[int]) -> int:
Example 1:

• Input: [7, 1, 5, 3, 6, 4]


• Output: 5


• Explanation: Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6 - 1 = 5.

Example 2:

• Input: [7, 6, 4, 3, 1]


• Output: 0


• Explanation: In this case, no transactions are done and the max profit = 0.

Constraints:

• 1 <= prices.length <= 10^5


• 0 <= prices[i] <= 10^4

Background: In the context of cryptocurrency transactions, identifying duplicate transactions is crucial for maintaining the integrity of financial records. This problem relates to ensuring that no transaction is processed more than once on the Coinbase platform.
Problem statement: Given an array of n + 1 integers where each integer is in the range [1, n], write a function to find the duplicate number. You must solve it without modifying the array and using O(1) extra space. Your solution should have a time complexity better than O(n^2).
Function/class signature:

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

Example 1:
Input: [3, 1, 3, 4, 2]
Output: 3
Explanation: The number 3 appears twice.
Example 2:
Input: [1, 2, 3, 4, 4]
Output: 4
Explanation: The number 4 appears twice.
Constraints:

• 2 <= n <= 10^5


• The integers in the array are in the range [1, n] and there is at least one duplicate.

Background: Coinbase deals with numerous cryptocurrency transactions that form a network. Calculating the shortest path between two transactions can help optimize network routes for better performance and reduced costs.Problem statement: Given a directed graph where each node represents a cryptocurrency transaction and each directed edge represents a possible transaction path with an associated cost, implement a function to find the shortest path from a starting transaction src to a destination transaction dest. The graph is given as an adjacency list, and each edge has a non-negative cost.Function/class signature:

• def shortest_path(graph: Dict[str, List[Tuple[str, int]]], src: str, dest: str) -> Tuple[List[str], int]:

Example 1:
Input:
graph = {"A": [("B", 1), ("C", 4)], "B": [("C", 2), ("D", 5)], "C": [("D", 1)], "D": []}
src = "A", dest = "D"
Output: (['A', 'B', 'C', 'D'], 4)
Explanation: The shortest path is A -> B -> C -> D with a total cost of 4.Example 2:
Input:
graph = {"X": [("Y", 2)], "Y": [("Z", 3)], "Z": []}
src = "X", dest = "Z"
Output: (['X', 'Y', 'Z'], 5)
Explanation: The shortest path is X -> Y -> Z with a total cost of 5.Constraints:

• 1 <= len(graph) <= 1000


• 0 <= cost <= 1000


• All transaction identifiers are unique strings.

Background: In a financial app like Coinbase, ensuring the integrity of user data is critical. Identifying duplicates efficiently within a user's transaction history can help prevent fraud and maintain accurate records.
Problem statement: Given an array of n + 1 integers where each integer is in the range [1, n], find the duplicate number. You must solve it without modifying the array and using O(1) extra space. The solution should be optimized to have a better time complexity than O(n^2).
Function/class signature:

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

Example 1:

• Input: [3, 1, 3, 4, 2]


• Output: 3


• Explanation: The number 3 is repeated in the array.

Example 2:

• Input: [1, 3, 4, 2, 2]


• Output: 2


• Explanation: The number 2 is repeated in the array.

Constraints:

• 1 <= n <= 10^5


• The integer values are in the range [1, n] and there's guaranteed to be one duplicate.

Background: Coinbase needs to efficiently analyze flight data for potential integration with a cryptocurrency travel service. Understanding flight layovers can help users plan better travel routes using digital currencies.
Problem statement: Given a table flights with columns flight_id, departure_airport, arrival_airport, and departure_time, you are required to return the flight_ids that have more than one layover. A layover is defined as having multiple connections in the journey from the departure to the final arrival airport. You should calculate the number of layovers by comparing the departure and arrival times of consecutive flights.
Function/class signature:

• def find_flights_with_layovers(flights: List[Tuple[int, str, str, str]]) -> List[int]:

Example 1:
Input: flights = [(1, 'A', 'B', '2023-01-02 08:00'), (2, 'B', 'C', '2023-01-02 10:00'), (3, 'C', 'D', '2023-01-02 12:00'), (4, 'A', 'D', '2023-01-02 09:00')]
Output: [1]
Explanation: Flight 1 has two layovers via B and C to reach D.
Example 2:
Input: flights = [(5, 'X', 'Y', '2023-01-03 07:00'), (6, 'Y', 'Z', '2023-01-03 09:00'), (7, 'Y', 'X', '2023-01-03 10:30')]
Output: []
Constraints:

• 1 <= len(flights) <= 10^4


• Each flight_id is unique.


• Time format is guaranteed to be ‘YYYY-MM-DD HH:MM’.


• departure_airport and arrival_airport are strings representing airport codes.