Bird
Raised Fist0
LLDsystem_design~10 mins

Search functionality design in LLD - Interactive Code Practice

Choose your learning style10 modes available

Start learning this pattern below

Jump into concepts and practice - no test required

or
Recommended
Test this pattern10 questions across easy, medium, and hard to know if this pattern is strong
Practice - 5 Tasks
Answer the questions below
1fill in blank
easy

Complete the code to define the main component responsible for handling search queries.

LLD
class [1] {
    public void handleSearch(String query) {
        // Implementation
    }
}
Drag options to blanks, or click blank then click option'
ASearchHandler
BQueryProcessor
CSearchEngine
DResultFetcher
Attempts:
3 left
💡 Hint
Common Mistakes
Choosing a class name that implies fetching results instead of handling queries.
Using a generic name that does not clearly indicate its role.
2fill in blank
medium

Complete the code to add a method that indexes documents for search.

LLD
public class Indexer {
    public void [1](Document doc) {
        // Indexing logic
    }
}
Drag options to blanks, or click blank then click option'
AindexDocument
Bsearch
CfetchResults
DprocessQuery
Attempts:
3 left
💡 Hint
Common Mistakes
Using method names related to searching instead of indexing.
Choosing vague method names that do not describe the action.
3fill in blank
hard

Fix the error in the code that processes search queries asynchronously.

LLD
public class AsyncSearchProcessor {
    public Future<List<Result>> processQuery(String query) {
        return executorService.[1](() -> {
            // Search logic
            return search(query);
        });
    }
}
Drag options to blanks, or click blank then click option'
Ainvoke
Bexecute
Crun
Dsubmit
Attempts:
3 left
💡 Hint
Common Mistakes
Using execute which returns void, causing a type mismatch.
Using run or invoke which are not methods of executorService.
4fill in blank
hard

Fill both blanks to complete the code for filtering search results by relevance and date.

LLD
List<Result> filteredResults = results.stream()
    .filter(r -> r.getRelevance() [1] 0.8)
    .filter(r -> r.getDate() [2] LocalDate.now().minusDays(30))
    .collect(Collectors.toList());
Drag options to blanks, or click blank then click option'
A>=
B<=
C>
D<
Attempts:
3 left
💡 Hint
Common Mistakes
Using wrong comparison operators that exclude desired results.
Mixing up greater than and less than for date filtering.
5fill in blank
hard

Fill all three blanks to complete the code that builds a search query with filters and sorting.

LLD
SearchQuery query = new SearchQuery.Builder()
    .setKeyword([1])
    .addFilter([2], [3])
    .setSortOrder(SortOrder.RELEVANCE)
    .build();
Drag options to blanks, or click blank then click option'
A"machine learning"
B"date"
C"last_30_days"
D"popularity"
Attempts:
3 left
💡 Hint
Common Mistakes
Using unrelated filter fields or values.
Setting keyword to a filter value instead of a search phrase.

Practice

(1/5)
1. What is the main purpose of building an index in a search functionality system?
easy
A. To compress data for storage
B. To store user passwords securely
C. To display images faster on the screen
D. To quickly find data entries matching search keywords

Solution

  1. Step 1: Understand the role of an index in search

    An index maps keywords to data entries, enabling fast lookup instead of scanning all data.
  2. Step 2: Identify the correct purpose

    Since search needs to find matching data quickly, the index helps achieve this by direct access.
  3. Final Answer:

    To quickly find data entries matching search keywords -> Option D
  4. Quick Check:

    Index = Fast keyword lookup [OK]
Hint: Index means fast lookup, not storage or compression [OK]
Common Mistakes:
  • Confusing index with data compression
  • Thinking index stores passwords
  • Assuming index speeds up image display
2. Which data structure is commonly used to implement a search index for keyword lookup?
easy
A. Hash map
B. Linked list
C. Stack
D. Queue

Solution

  1. Step 1: Recall common data structures for fast lookup

    Hash maps provide average O(1) time for key-based access, ideal for mapping keywords to data.
  2. Step 2: Eliminate other options

    Linked lists, stacks, and queues do not provide efficient direct lookup by key.
  3. Final Answer:

    Hash map -> Option A
  4. Quick Check:

    Hash map = Fast key lookup [OK]
Hint: Hash maps give fast key-based access, perfect for indexes [OK]
Common Mistakes:
  • Choosing linked list which is slow for lookup
  • Confusing stack or queue with key-value storage
  • Ignoring average O(1) lookup time of hash maps
3. Consider a search system where the index maps keywords to document IDs. If the keyword 'apple' maps to [1, 3, 5] and 'banana' maps to [2, 3], what is the result of searching for documents containing both 'apple' and 'banana'?
medium
A. [1, 2, 3, 5]
B. [3]
C. [1, 5]
D. [2, 3, 5]

Solution

  1. Step 1: Identify documents for each keyword

    'apple' maps to documents [1, 3, 5], 'banana' maps to [2, 3].
  2. Step 2: Find intersection of document lists

    Documents containing both keywords are in both lists. Intersection of [1, 3, 5] and [2, 3] is [3].
  3. Final Answer:

    [3] -> Option B
  4. Quick Check:

    Intersection = [3] [OK]
Hint: Search AND means intersection of document lists [OK]
Common Mistakes:
  • Merging lists instead of intersecting
  • Confusing union with intersection
  • Ignoring common documents
4. A search system uses a hash map to store keyword to document ID mappings. The code snippet below has a bug:
index = {}
keywords = ['apple', 'banana', 'apple']
docs = [1, 2, 3]
for i in range(len(keywords)):
    index[keywords[i]] = docs[i]
print(index)
What is the bug in this code?
medium
A. It overwrites previous document IDs for duplicate keywords
B. It uses a list instead of a dictionary
C. It does not initialize the index
D. It uses wrong loop range

Solution

  1. Step 1: Analyze how index is updated

    The loop assigns index[keyword] = doc, so duplicate keywords overwrite previous values.
  2. Step 2: Identify the bug

    For 'apple', first doc 1 is stored, then overwritten by doc 3, losing doc 1.
  3. Final Answer:

    It overwrites previous document IDs for duplicate keywords -> Option A
  4. Quick Check:

    Duplicate keys overwrite values in hash map [OK]
Hint: Duplicate keys overwrite values unless stored as list [OK]
Common Mistakes:
  • Thinking loop range is wrong
  • Assuming index is not initialized
  • Confusing data structure type
5. You are designing a search system for a large online store with millions of products. To support fast search by keywords and handle high user traffic, which combination of design choices is best?
hard
A. Use a simple list of products and filter by keywords on the client side
B. Store all product data in a single SQL table and scan it for each search
C. Use an inverted index stored in a distributed NoSQL database with caching layers
D. Build an index only for the top 10 products and search others sequentially

Solution

  1. Step 1: Consider scalability and speed needs

    Millions of products and high traffic require fast, scalable search with distributed storage and caching.
  2. Step 2: Evaluate options

    Use an inverted index stored in a distributed NoSQL database with caching layers uses inverted index (fast keyword lookup), distributed NoSQL (scalable), and caching (speed). Others are slow or incomplete.
  3. Final Answer:

    Use an inverted index stored in a distributed NoSQL database with caching layers -> Option C
  4. Quick Check:

    Inverted index + distributed storage + cache = scalable fast search [OK]
Hint: Combine inverted index, distributed DB, and cache for scale [OK]
Common Mistakes:
  • Choosing full table scan for large data
  • Filtering on client side for millions of items
  • Indexing only a small subset of data