MongoDB Software Engineer Interview Questions

LeetCode #208: Implement Trie (Prefix Tree). Difficulty: Medium. Topics: Hash Table, String, Design, Trie. Asked at MongoDB in the last 6 months.

LeetCode #1146: Snapshot Array. Difficulty: Medium. Topics: Array, Hash Table, Binary Search, Design. Asked at MongoDB in the last 6 months.

LeetCode #146: LRU Cache. Difficulty: Medium. Topics: Hash Table, Linked List, Design, Doubly-Linked List. Asked at MongoDB in the last 6 months.

LeetCode #139: Word Break. Difficulty: Medium. Topics: Array, Hash Table, String, Dynamic Programming, Trie, Memoization. Asked at MongoDB in the last 6 months.

LeetCode #349: Intersection of Two Arrays. Difficulty: Easy. Topics: Array, Hash Table, Two Pointers, Binary Search, Sorting. Asked at MongoDB in the last 6 months.

LeetCode #23: Merge k Sorted Lists. Difficulty: Hard. Topics: Linked List, Divide and Conquer, Heap (Priority Queue), Merge Sort. Asked at MongoDB in the last 6 months.

## Round 1 - Coding ## Problem Design a billing system that creates invoices, adds line items, applies discounts, and computes totals with tax. ```python class LineItem: def __init__(self, description: str, quantity: int, unit_price: float): ... class Invoice: def __init__(self, invoice_id: str, customer: str, tax_rate: float): ... def add_item(self, item: LineItem) -> None: ... def apply_discount(self, percent: float) -> None: # on subtotal ... def subtotal(self) -> float: ... def total(self) -> float: # after discount and tax ... def summary(self) -> str: ... ``` ## Example ``` inv = Invoice("INV-001", "Acme Corp", tax_rate=0.08) inv.add_item(LineItem("Widget", 5, 10.00)) inv.add_item(LineItem("Gadget", 2, 25.00)) inv.subtotal() -> 100.0 # 5*10 + 2*25 inv.apply_discount(10) # 10% off inv.total() -> 97.20 # 90 * 1.08 ``` ## Follow-ups 1. How do you handle discounts that apply only to specific line items versus the entire invoice? 2. How would you represent recurring invoices that auto-generate monthly? 3. What happens if `apply_discount` is called multiple times — do they stack or replace? 4. How do you serialize an invoice to JSON for API responses?

## Problem Decode a binary-encoded string or number back to its original form, likely involving bit manipulation or base conversion. ## Likely LeetCode equivalent No unambiguous single LC equivalent. ## Tags binary,math,strings,swe

## Round 1 - Coding ## Problem Given a social network as a list of friendships, recommend potential friends for a user. Recommendations are users who are not already friends with the target user but share the most mutual friends. Exclude the user themselves. ```python def recommend_friends(friendships: list[tuple[str,str]], user: str, top_k: int) -> list[str]: # returns top_k recommended users sorted by mutual friend count desc, # ties broken alphabetically ... ``` ## Example ``` friendships = [ ("Alice","Bob"),("Alice","Carol"),("Bob","David"), ("Carol","David"),("David","Eve"),("Alice","Eve") ] recommend_friends(friendships, "Alice", top_k=2) # Alice's friends: {Bob, Carol, Eve} # David: shares Bob, Carol, Eve -> 2 mutuals (Bob,Carol) [Eve shares but Alice-Eve exists] # Actually David shares Bob and Carol with Alice -> 2 mutuals # -> ["David", ...] ``` ## Follow-ups 1. What is the time complexity of your approach? Can you reduce it using adjacency sets? 2. How would you handle a directed graph (follow vs. friend) instead of an undirected one? 3. How would you extend recommendations to include second-degree connections with lower weight? 4. At scale (100M users), how do you compute mutual friend counts efficiently?

## Problem Implement a hash map from scratch, covering put, get, and remove operations with collision handling. ## Likely LeetCode equivalent LeetCode 706 - Design HashMap. ## Tags hash_table,design,swe

## Problem Design and implement a hash table with efficient insert, lookup, and delete operations, likely discussing collision resolution strategies. ## Likely LeetCode equivalent LeetCode 706 - Design HashMap. ## Tags hash_table,design,swe

## Problem Given an array of integers, return the array of their squares sorted in non-decreasing order. ## Likely LeetCode equivalent LeetCode 977 - Squares of a Sorted Array. ## Tags sorting,two_pointers,arrays,swe

## Problem Process a sliding window of integers, likely computing a running statistic (max, sum, or average) over a fixed-size window. ## Likely LeetCode equivalent LeetCode 239 - Sliding Window Maximum. ## Tags sliding_window,heap,arrays,swe

## Problem Find the intersection of two arrays or sets, returning elements that appear in both. ## Likely LeetCode equivalent LeetCode 349 - Intersection of Two Arrays. ## Tags arrays,hash_table,two_pointers,swe

## Round 1 - Coding ## Problem Build an inverted index over a collection of documents. Support adding documents, querying for documents containing a single word, and AND queries returning documents that contain all given words. ```python class InvertedIndex: def add_document(self, doc_id: int, text: str) -> None: ... def search(self, word: str) -> set[int]: # returns set of doc_ids containing word (case-insensitive) ... def search_all(self, words: list[str]) -> set[int]: # AND query: doc must contain every word ... def search_any(self, words: list[str]) -> set[int]: # OR query: doc must contain at least one word ... ``` ## Example ``` idx = InvertedIndex() idx.add_document(1, "the quick brown fox") idx.add_document(2, "the fox jumped over") idx.add_document(3, "a quick brown dog") idx.search("fox") -> {1, 2} idx.search_all(["quick","brown"]) -> {1, 3} idx.search_any(["fox","dog"]) -> {1, 2, 3} ``` ## Follow-ups 1. How do you handle common stop words like "the" or "a"? Should they be indexed? 2. How would you extend the index to store word positions so you can support phrase queries like `"quick brown"`? 3. How do you rank results by relevance (e.g., TF-IDF) instead of returning an unordered set? 4. How would you handle document updates — what must be re-indexed when a document's text changes?

## Problem Implement a custom iterator or iterator combinator (e.g., peeking iterator, zip, or flatten), requiring understanding of the iterator design pattern. ## Likely LeetCode equivalent LeetCode 284 - Peeking Iterator. ## Tags design,iterator,ood,swe

## Problem Merge K sorted lists or arrays into a single sorted output using a min-heap for efficiency. ## Likely LeetCode equivalent LeetCode 23 - Merge k Sorted Lists. ## Tags heap,linked_list,sorting,swe

## Problem Implement a linked hash map that maintains insertion order while supporting O(1) get/put operations, similar to Java's LinkedHashMap. ## Likely LeetCode equivalent LeetCode 146 - LRU Cache (uses same doubly-linked-list + hash map structure). ## Tags hash_table,linked_list,design,swe

## Problem Find the lowest common ancestor of two nodes in a binary tree or binary search tree. ## Likely LeetCode equivalent LeetCode 236 - Lowest Common Ancestor of a Binary Tree. ## Tags binary_tree,recursion,dfs,swe

## Problem Design and implement a Least Recently Used (LRU) cache supporting O(1) get and put operations using a hash map and doubly linked list. ## Likely LeetCode equivalent LeetCode 146 - LRU Cache. ## Tags hash_table,linked_list,design,swe