Confluent Software Engineer Phone Screen Questions

The original poster (OP) interviewed with Confluent and reviewed interview experiences and questions from other users. They expressed gratitude and offered some information to help others. The coding

This post was last edited by leehen on 2025-10-09 15:04 Please give me points!!! It was a fellow countryman who interviewed me. He was very nice, explained things very clearly, was very patient, and e

Anyone had the phone screen at Confluent before? What sort of questions should I expect? Specifically for entry level SWE roles

Phone Screen: Implement a data structure to store key-value entries within a time-based interval. Slight variation to LRU Cache. Round 1: Implement a Word Search Engine, given a list of documents with text,...

Phone Screen - Modified LRU Cache - Implemented a working solution using map + pair data structure. Coding Round 1 [Hire] - Word Search in a List of Documents - Implemented a working...

Coding round 1 ---------------- you\'re given k v pairs funA: [\'int\',\'bool\'] funB: [\'int\',\'int\'] and queries like [\'int\',\'int\'] return all functions that match the description follow-up you\'re also given a flag is variadic funA: [\'int\',\'bool\'] , isVariadic: true funC: [\'int\',\'int\']...

exp - 5.5yrs current company - product based MNC college - Tier 3 Screening Round- Design a cache with time based eviction policy \t Expectation Implement get(), put(), getAverage() methods Onsite : Round 1 :...

## Round 1 - Coding ## Problem Design and implement a food ordering system for a single restaurant. Your system must support: 1. A `Menu` that holds `Item(name, price, category, available)`. Items can be enabled/disabled. 2. A `Cart` per user: `add_item`, `remove_item`, `update_quantity`, `get_total`. 3. An `Order` created from a cart: transitions through states `PLACED -> PREPARING -> OUT_FOR_DELIVERY -> DELIVERED`. Cancellation only allowed before `PREPARING`. ```python class Item: def __init__(self, name: str, price: float, category: str): ... class Cart: def add_item(self, item: Item, qty: int) -> None: ... def remove_item(self, item_name: str) -> None: ... def get_total(self) -> float: ... class Order: def advance_state(self) -> None: ... def cancel(self) -> bool: ... def get_receipt(self) -> str: ... ``` ``` Item("Burger", 9.99, "Mains") cart.add_item(burger, 2) cart.get_total() -> 19.98 order = Order(cart) order.advance_state() # PREPARING order.cancel() -> False (too late) ``` ## Follow-ups 1. How would you apply a discount code that takes 10% off orders above $30? 2. Support multiple restaurants — how does your design change? 3. Where would you add tax calculation, and should it live in `Cart` or `Order`? 4. How do you handle an item becoming unavailable after it's already in a customer's cart?

## Problem You are given a list of function definitions, each with a name and a typed parameter list. You are also given a list of call expressions, each with a function name and argument types. Implement a matcher that returns, for each call, the best matching definition — or `"NO_MATCH"` if none apply. Matching rules (in priority order): 1. Exact type match on all positional arguments. 2. A parameter typed `"any"` matches any argument type. 3. If multiple definitions match, prefer the one with fewer `"any"` parameters. ```python def match_function( definitions: list[dict], # [{"name": str, "params": [str]}] calls: list[dict] # [{"name": str, "args": [str]}] ) -> list[str]: # definition id or "NO_MATCH" per call ... ``` ``` Definitions: {"id": "f1", "name": "foo", "params": ["int", "str"]} {"id": "f2", "name": "foo", "params": ["any", "str"]} Calls: {"name": "foo", "args": ["int", "str"]} -> "f1" (exact beats any) {"name": "foo", "args": ["float", "str"]}-> "f2" (any matches float) {"name": "foo", "args": ["int", "int"]} -> "NO_MATCH" ``` ## Follow-ups 1. Add support for variadic parameters (`*args`) that match zero or more trailing arguments. 2. How do you handle ambiguous matches where two definitions tie on specificity? 3. Support subtype relationships: `int` is a subtype of `number`. How does this change your matching logic? 4. What data structure would you precompute to make repeated matching fast?

## Round 1 - Coding (Frontend/JS) ## Problem Implement a `memo` function that wraps any pure function and caches its results. The cache key should be derived from the serialized arguments. Support an optional `maxSize` to limit cache entries (evict least-recently-used when full). ```javascript function memo(fn, { maxSize = Infinity } = {}) { // Your implementation } // Usage const expensiveAdd = memo((a, b) => { console.log('computing'); return a + b; }, { maxSize: 3 }); ``` ``` expensiveAdd(1, 2) -> 3 // logs "computing" expensiveAdd(1, 2) -> 3 // cache hit, no log expensiveAdd(2, 3) -> 5 // logs "computing" expensiveAdd(1, 2) -> 3 // still cached // With maxSize=2: memo(fn, {maxSize:2}) fn(1) fn(2) fn(3) // fn(1) evicted; fn(3) miss -> recomputes ``` ## Follow-ups 1. Your key serialization uses `JSON.stringify`. What breaks for functions, circular refs, or `undefined` args? How do you fix it? 2. Add a `maxAge` option (in ms) after which a cache entry is considered stale. 3. How would you make this work for async functions that return Promises, avoiding thundering-herd on concurrent calls with the same args? 4. Where in a React component tree would you apply memoization, and how does `useMemo` differ from this implementation?

## Problem You have a list of monsters, each with `(health, attack)`. Two monsters fight: each round, both deal their attack value to the other simultaneously. A monster dies when its health reaches 0 or below. Given your monster and a list of opponents, return how many you can defeat. For a follow-up variant: you can choose the fight order. You keep your current health between fights. Determine the maximum number of monsters you can defeat before dying. ```python def fights_won( my_health: int, my_attack: int, opponents: list[tuple[int, int]] # (health, attack) ) -> int: ... ``` ``` Input: my_health=10, my_attack=3, opponents=[(6,2),(15,1),(4,4)] Vs (6,2): I deal 3/round -> 2 rounds to kill. I take 2*2=4 dmg. Survive (6 HP left). Vs (15,1): 5 rounds. I take 5 dmg. Survive (1 HP left). Vs (4,4): 2 rounds. I take 8 dmg. Die. Order: fight in order given -> 2 wins. Optimal order might differ. ``` ## Follow-ups 1. Prove or disprove: greedy (fight lowest-attack opponents first) always maximizes wins. 2. What if you have a one-time shield that blocks all damage in one round — when should you use it? 3. Extend to a tournament bracket: monsters fight each other, not you. Who wins? 4. How would this change if attack values can vary randomly each round (dice roll)?

## Problem Resolve service startup order respecting dependency constraints, a topological sort on a directed acyclic graph. ## Tags graph, sorting

## Problem Implement wildcard pattern matching where '?' matches any single character and '*' matches any sequence. ## Likely LeetCode equivalent LC 44 - wildcard-matching ## Tags dynamic_programming, strings

## Problem Maintain a sliding window map tracking key-value pairs within a moving time or index window. ## Tags sliding_window, hash_table