Plaid Software Engineer Phone Screen Questions

## Problem A bank has undergone several mergers. Each merger maps old account IDs to new ones. Given a list of mergers `[(old_id, new_id)]` applied in sequence and a query account ID, return the final canonical ID it resolves to. Mergers may chain: if A -> B and B -> C, then A ultimately resolves to C. ```python def resolve_bank_id( mergers: List[Tuple[str, str]], query_id: str ) -> str: ... def resolve_all( mergers: List[Tuple[str, str]], queries: List[str] ) -> List[str]: ... ``` **Example:** ``` mergers = [("ACC001", "ACC002"), ("ACC002", "ACC999"), ("ACC050", "ACC999")] resolve_bank_id(mergers, "ACC001") -> "ACC999" resolve_bank_id(mergers, "ACC050") -> "ACC999" resolve_bank_id(mergers, "ACC999") -> "ACC999" # no further mapping ``` ## Approach Model as a Union-Find (Disjoint Set Union) structure. Each `merge(old, new)` is a union operation with path compression. ## Follow-ups 1. How does path compression in Union-Find achieve near-O(1) amortized `find`? 2. What if a merger maps one new ID to multiple old IDs simultaneously? 3. How would you detect and handle circular mergers (A -> B -> A)? 4. How would you audit which original IDs all map to the same canonical ID?

## Problem Design a coupon application system for an e-commerce checkout. Coupons have types: `percent_off`, `fixed_off`, `buy_x_get_y_free`, and `category_discount`. Rules: - At most 2 coupons can be applied per order. - Coupons cannot reduce the price below $0. - Some coupons are exclusive (cannot stack with others). Implement: - `apply_coupons(order, coupon_codes) -> CheckoutResult` ```python class CouponSystem: def apply_coupons( self, order: dict, # {"items": [{"id", "category", "price", "qty"}]} coupon_codes: List[str] ) -> dict: # {"original": float, "discount": float, "final": float, "applied": List[str]} ... ``` **Example:** ``` order = {"items": [{"id":"i1","category":"electronics","price":200,"qty":1}]} coupons = ["SAVE10PCT", "TECH20"] # SAVE10PCT: 10% off entire order # TECH20: $20 off electronics category apply_coupons(order, coupons) -> {"original": 200, "discount": 40.0, "final": 160.0, "applied": ["SAVE10PCT","TECH20"]} ``` ## Follow-ups 1. How do you determine the optimal order to apply coupons to maximize the discount? 2. How do you enforce the exclusivity constraint when 3+ coupons are submitted? 3. How would you validate coupon expiry and single-use restrictions? 4. How do you handle a `buy_x_get_y_free` coupon across multiple cart items?

## Problem Group financial transactions by merchant, category, or date and compute aggregates for each group. ## Likely LeetCode equivalent No direct unambiguous LC equivalent. ## Tags hash_table, arrays, design

## Problem Given a loan principal `P`, annual interest rate `r` (as a decimal), and term in months `n`, compute the full amortization schedule - the breakdown of each monthly payment into principal and interest portions. ```python def amortization_schedule( principal: float, annual_rate: float, months: int ) -> List[dict]: # Returns list of {month, payment, principal_paid, interest_paid, remaining_balance} ... ``` **Example:** ``` P=10000, annual_rate=0.06, months=12 Monthly rate = 0.06/12 = 0.005 Monthly payment = P * r / (1 - (1+r)^-n) = 10000 * 0.005 / (1 - 1.005^-12) = 860.66 Month 1: interest = 10000 * 0.005 = 50.00 principal = 860.66 - 50.00 = 810.66 balance = 10000 - 810.66 = 9189.34 ... Month 12: balance rounds to 0.00 ``` ## Follow-ups 1. How do you handle rounding errors so the final balance is exactly $0.00? 2. Extend to support extra monthly payments that reduce the remaining principal. 3. How would you compute the total interest paid and the effective APR if fees are included? 4. Model a variable-rate loan where the interest rate changes every 12 months.

## Problem Settle debts or transactions among a group with minimum number of transfers, a classic graph debt-reduction problem. ## Likely LeetCode equivalent LC 465 - Optimal Account Balancing (>80% confident) ## Tags graph, backtracking, greedy