Sofi Software Engineer Interview Questions

This post was last edited by juliaxx on 2025-09-25 12:10. Given a list of string wordset containing anagrams, and a list of strings containing sentences. You can replace words in sentences with anagra

The following content requires a score higher than 220. You can already view it. The first round only allowed Java; no other languages were permitted. The interviewer added other languages, which migh

LeetCode #347: Top K Frequent Elements. Difficulty: Medium. Topics: Array, Hash Table, Divide and Conquer, Sorting, Heap (Priority Queue), Bucket Sort, Counting, Quickselect. Asked at SoFi in the last 6 months.

LeetCode #380: Insert Delete GetRandom O(1). Difficulty: Medium. Topics: Array, Hash Table, Math, Design, Randomized. Asked at SoFi in the last 6 months.

## Problem Find all starting indices of anagrams of a pattern in a given string. ## Likely LeetCode equivalent Directly matches Find All Anagrams in a String (LC 438). ## Tags strings, sliding_window, hash_table, sofi

## Problem Simulate asteroid collisions in a row: same direction pass through, opposite directions collide with larger surviving. ## Likely LeetCode equivalent Directly matches Asteroid Collision (LC 735). ## Tags stack, arrays, sofi

## Problem Return the top-rated TV shows within each genre from a dataset, likely using grouped sorting or heaps. ## Likely LeetCode equivalent No confident single LC match. ## Tags heap, hash_table, sorting, sofi

## Problem Implement or operate on a Binary Search Tree with operations like insert, delete, search, or validate BST property. ## Likely LeetCode equivalent Similar to Validate BST (LC 98) or operations on BST nodes. ## Tags binary_tree, binary_search, sofi

## Problem You are given a list of blocked words and a document string. Return the document with every blocked word replaced by asterisks (`*`) of equal length. Matching is case-insensitive; non-alpha characters act as word boundaries. ```python def block_words(blocked: list[str], document: str) -> str: pass ``` **Example:** ``` blocked = ["bad", "spam"] document = "This is a Bad example with spam content." output -> "This is a *** example with **** content." ``` ## Follow-ups 1. How would you handle partial matches, e.g., blocking "bad" should not match "badminton"? 2. If `blocked` contains 100,000 entries, how do you reduce lookup time? (Trie vs. hash set trade-offs.) 3. The document is a 10 GB log stream arriving in chunks. How do you process it without loading it all in memory? 4. Extend the solution to support wildcard patterns like `sp*m`.

## Problem Find the minimum number of character changes required to make two strings anagrams of each other. ## Likely LeetCode equivalent Similar to Minimum Number of Steps to Make Two Strings Anagram (LC 1347). ## Tags strings, hash_table, sofi

## Problem Given an integer array `nums`, find the length of the longest contiguous subarray that contains no duplicate values. ```python def clean_subarray(nums: list[int]) -> int: pass ``` **Example:** ``` nums = [2, 1, 3, 1, 4, 3, 5] output -> 4 # subarray [1, 4, 3, 5] or [3, 1, 4, 3] -- wait, [1,4,3,5] is the answer nums = [1, 1, 1] output -> 1 ``` ## Approach Sliding window with a hash set. Expand `right`; when a duplicate is found, shrink from `left` until the duplicate is evicted. O(n) time, O(k) space where k is the window size. ## Follow-ups 1. Return the actual subarray, not just its length. 2. What if "clean" means at most k distinct elements instead of zero duplicates? 3. How does your solution behave on a sorted vs. random array -- any optimization possible? 4. Extend to a 2D matrix: find the largest rectangular sub-matrix with no repeated value in any row.

## Problem Given a list of `n` integer arrays, return all elements that appear in every array. The result should be sorted in ascending order and contain no duplicates. ```python def common_elements(arrays: list[list[int]]) -> list[int]: pass ``` **Example:** ``` arrays = [[3, 1, 2, 4], [1, 2, 5], [2, 1, 6]] output -> [1, 2] arrays = [[1, 2], [3, 4]] output -> [] ``` ## Approach Convert the first array to a set, then intersect with each subsequent array. Final result sorted. O(n * m) time where m is average array length. ## Follow-ups 1. What if `n` is 10,000 and each array has up to 1 million elements? Discuss memory trade-offs. 2. How do you handle duplicates within a single array -- does an element need to appear multiple times per array to be counted multiple times in the output? 3. Implement without using Python's built-in `set.intersection`. 4. Given the arrays arrive as a stream one at a time, maintain the running intersection incrementally.

## Problem Design a `CreditScoreSystem` that manages user credit scores. Starting score is 700 for every new user. Implement the following operations: - `add_user(user_id)` -- register a new user. - `record_payment(user_id, on_time: bool)` -- on-time payment adds 10 points; missed payment subtracts 40 points. Score is clamped to [300, 850]. - `get_score(user_id) -> int` -- return current score. - `top_k(k: int) -> list[str]` -- return the k users with the highest scores (ties broken by `user_id` lexicographically). ```python class CreditScoreSystem: def add_user(self, user_id: str) -> None: ... def record_payment(self, user_id: str, on_time: bool) -> None: ... def get_score(self, user_id: str) -> int: ... def top_k(self, k: int) -> list[str]: ... ``` **Example:** ``` sys.add_user("alice"); sys.add_user("bob") sys.record_payment("alice", True) # alice -> 710 sys.record_payment("bob", False) # bob -> 660 sys.top_k(1) -> ["alice"] ``` ## Follow-ups 1. How would you make `top_k` efficient if there are 50 million users? 2. Add a `history(user_id) -> list[int]` method returning all score snapshots. What is the storage impact? 3. How do you handle concurrent `record_payment` calls for the same user in a multithreaded context?

## Problem You are given a list of pipeline events. Each event is a tuple `(file_id, stage, status, timestamp)` where `status` is either `"start"` or `"end"`. Compute the total processing time for each file and the per-stage breakdown. ```python def file_processing_time( events: list[tuple[str, str, str, int]] ) -> dict[str, dict[str, int]]: # Returns {file_id: {stage: duration, "total": total_duration}} pass ``` **Example:** ``` events = [ ("f1", "parse", "start", 0), ("f1", "parse", "end", 5), ("f1", "compile", "start", 5), ("f1", "compile", "end", 12), ] output -> {"f1": {"parse": 5, "compile": 7, "total": 12}} ``` ## Follow-ups 1. What if events for different files are interleaved? Does your solution still work? 2. Handle missing `"end"` events -- mark those stages as `"incomplete"`. 3. Stages can overlap (parallel execution). How do you compute wall-clock total vs. CPU-sum total? 4. The events arrive out of timestamp order from distributed workers. How do you handle sorting efficiently?

## Problem Find the top-K most frequently used tags from a collection of posts or items. ## Likely LeetCode equivalent Similar to Top K Frequent Words (LC 692) or Top K Frequent Elements (LC 347). ## Tags heap, hash_table, sofi

## Problem Identify users or accounts with abnormally high transaction frequency within a time window. ## Likely LeetCode equivalent No confident single LC match. ## Tags hash_table, sliding_window, sofi, finance

## Problem You have a sorted list of GIF objects `[{"id": str, "trending_score": int}]`. Implement a `paginate` function that returns a page of results given `offset` and `limit`. If the caller passes `cursor` (the last-seen id) instead of `offset`, resolve the offset from the cursor first. ```python def paginate( gifs: list[dict], offset: int = 0, limit: int = 10, cursor: str | None = None ) -> dict: # Returns {"data": [...], "next_cursor": str | None} pass ``` **Example:** ``` gifs = [{"id": "a", ...}, {"id": "b", ...}, {"id": "c", ...}] paginate(gifs, offset=1, limit=2) -> {"data": [{"id": "b"}, {"id": "c"}], "next_cursor": None} ``` ## Follow-ups 1. Offset-based vs. cursor-based pagination -- when does each break down at scale? 2. What happens if a new GIF is inserted before the cursor position between two page fetches? How do you maintain consistency? 3. Trending score changes frequently. How do you prevent items from appearing twice or being skipped across pages? 4. Implement server-side caching so repeated identical page requests don't re-sort the list.

## Problem You have `n` gold bars with given weights and `k` players. Distribute all bars among the players such that the difference between the heaviest and lightest player's total is minimized. Each bar goes to exactly one player. ```python def goldbar_sharing(weights: list[int], k: int) -> int: # Returns the minimum possible (max_total - min_total) pass ``` **Example:** ``` weights = [3, 1, 4, 2, 5], k = 2 # One split: [3,2,1]=6 vs [4,5]=9 -> diff 3 # Better: [5,1]=6 vs [4,2]=6 -- wait: [5,1]=6, [3,2]=5, [4]=4 for k=3 # For k=2: [5,2]=7 vs [4,3,1]=8 -> diff 1 output -> 1 ``` ## Follow-ups 1. Is this problem NP-hard in general? What constraints make it tractable (e.g., small n, small k)? 2. How would you approach this with dynamic programming if `n <= 20`? 3. Discuss a greedy approximation: assign each bar to the player with the current lowest total. When does it fail? 4. If players have capacity limits on the total weight they can carry, how does that change the solution?

## Round 1 - Frontend ## Problem Build a Kanban board component in React with three columns: **To Do**, **In Progress**, **Done**. Each task card shows a title and priority badge. Users can drag cards between columns; the drop target column highlights on hover. ```tsx type Task = { id: string; title: string; priority: "low" | "medium" | "high" }; type Column = { id: string; label: string; tasks: Task[] }; function KanbanBoard({ initialColumns }: { initialColumns: Column[] }) { // implement } ``` **Requirements:** - Use only the HTML5 Drag and Drop API (no external library). - State is managed locally; no backend calls needed. - Dragging a card out of a column removes it there and inserts it at the drop position in the target. ## Follow-ups 1. How would you persist board state across page refreshes without a backend? 2. Two users edit the board simultaneously. What conflict resolution strategy would you use? 3. The board may grow to 500 tasks per column. How do you avoid rendering performance issues? 4. Add keyboard accessibility so cards can be moved without a mouse.

## Problem Parse log files to extract and aggregate metrics such as error rates, latency percentiles, or request counts. ## Likely LeetCode equivalent No confident single LC match. ## Tags hash_table, strings, sofi, log_parsing