Bloomberg·Software Engineer·Technical Phone Screen·Intermediate

IntermediatePrefer not to say

Apr 2026

Summary

Bloomberg SWE coding round, one problem the whole session. The question looked like a straightforward filtering task but the O(n) constraint is what made it actually interesting, and I didn't nail that part until pretty late.

Questions Asked (1)

Given a time-sorted list of transaction strings in the format name/time/amount/city, return all invalid transactions. A transaction is invalid if the amount exceeds 1000, or if the same person made another transaction in a different city within 60 minutes of it.

Algorithms & Data StructuresTechnical Trade-offs

Author's notes

I got the basic logic pretty fast: parse each record, flag anything over 1000, then check for same-name transactions within 60 minutes in a different city.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Clarify the input format and constraints, then design an algorithm that parses each transaction and checks both invalidity conditions. For the time-window condition, group transactions by person and compare each transaction with others within 60 minutes, using a sliding window or hash map to optimize. Finally, collect and return all invalid transactions, ensuring no duplicates.

Pro tip: Mention that since the list is time-sorted, you can use a sliding window per person to avoid O(n^2) comparisons, and discuss the trade-off between time and space complexity.

1. Clarify and Parse

Ask clarifying questions about input format, time units, and output order. Parse each transaction string into name, time, amount, and city.

2. Check Amount Condition

Immediately mark any transaction with amount > 1000 as invalid.

3. Check Time-Window Condition

Group transactions by person. For each person, use a sliding window (since list is time-sorted) to compare transactions within 60 minutes and flag those with different cities.

4. Collect and Deduplicate

Collect all invalid transactions, ensuring each transaction is added only once even if it violates both conditions.

5. Analyze Complexity and Trade-offs

Discuss time and space complexity of your approach, and consider alternative strategies like hash maps for unsorted input.

Key Points to Mention

Parsing the transaction string correctly, handling potential edge cases like negative amounts or malformed input.
Using a sliding window or two-pointer technique per person to efficiently check the 60-minute window.
Handling duplicate invalid transactions to avoid returning the same transaction multiple times.
Considering the time-sorted property to optimize the algorithm, and discussing the trade-off if the list were not sorted.
Analyzing time complexity: O(n) with sliding window vs O(n^2) naive approach.
Discussing space complexity and potential memory optimizations for large datasets.

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.