Observer pattern in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding the Observer Pattern Roles

In the Observer pattern, which component is responsible for notifying all registered observers about a change?

A The Client

B The Observer

C The Concrete Observer

D The Subject

💡 Hint

Think about who holds the list of observers and triggers updates.

The Subject maintains a list of observers and notifies them when its state changes.

❓ Architecture

intermediate

Choosing the Right Data Structure for Observers

Which data structure is best suited for storing observers in the Subject to efficiently add, remove, and notify them?

A ArrayList (dynamic array)

B HashSet (unordered set)

C LinkedList

D Stack

💡 Hint

Consider the need to avoid duplicate observers and fast removal.

A HashSet prevents duplicates and allows fast add/remove operations, making it ideal for observer storage.

❓ scaling

advanced

Scaling Notifications in Observer Pattern

When the number of observers grows very large, what is a common technique to improve notification performance?

A Batch notifications and send asynchronously using a thread pool

B Use recursion to notify observers

C Remove half of the observers to reduce load

D Notify observers synchronously in a single thread

💡 Hint

Think about how to avoid blocking the Subject during notifications.

Batching notifications and sending them asynchronously with a thread pool improves scalability and responsiveness.

❓ tradeoff

advanced

Tradeoffs of Using Push vs Pull Model in Observer Pattern

What is a key tradeoff when choosing between the push and pull models for notifying observers?

A Push model sends all data, increasing bandwidth; pull model requires observers to query for data, increasing complexity

B Push model does not notify observers; pull model does

C Push model is slower; pull model is always faster

D Push model requires observers to query data; pull model sends all data automatically

💡 Hint

Consider who controls the data flow and how much data is sent.

Push sends data proactively, which can increase bandwidth usage. Pull requires observers to request data, adding complexity.

❓ component

expert

Identifying the Correct Sequence of Observer Notification

Given the following steps in the Observer pattern, what is the correct order of operations when the Subject's state changes?

A 1, 3, 2, 4

B 2, 1, 3, 4

C 1, 2, 3, 4

D 3, 1, 2, 4

💡 Hint

Think about what must happen before notifications and what observers do after receiving them.

The Subject first updates its state, then notifies observers, who then receive the notification and update themselves.

Practice

1.

What is the main purpose of the Observer pattern in system design?

easy

A. To create a strict hierarchy of classes

B. To allow objects to automatically update when another object changes

C. To store data in a database

D. To improve the speed of a single function

Solution

1. Step 1: Understand the Observer pattern role

   The Observer pattern is designed to let one object notify others about changes automatically.

2. Step 2: Match purpose with options

   To allow objects to automatically update when another object changes correctly describes automatic updates between objects without tight coupling.

3. Final Answer:

   To allow objects to automatically update when another object changes -> Option B

4. Quick Check:

   Observer pattern = automatic updates [OK]

Hint: Observer means automatic update on change [OK]

Common Mistakes:

• Confusing Observer with data storage
• Thinking it creates class hierarchies
• Assuming it improves function speed

2.

Which of the following is the correct way to register an observer in the Observer pattern?

subject = Subject()
observer = ConcreteObserver()
# What code registers the observer?

easy

A. subject.addObserver(observer)

B. observer.subscribe(subject)

C. observer.register(subject)

D. subject.attach(observer)

Solution

1. Step 1: Recall common Observer pattern method names

   Typically, the subject has a method named attach or addObserver to register observers.

2. Step 2: Identify the most standard method

   While addObserver is used in some languages, attach is the classic and widely accepted method name.

3. Final Answer:

   subject.attach(observer) -> Option D

4. Quick Check:

   Register observer = subject.attach(observer) [OK]

Hint: Subject.attach(observer) is classic registration [OK]

Common Mistakes:

• Calling register on observer instead of subject
• Using subscribe which is not standard here
• Confusing addObserver with observer methods

3.

Given this code snippet, what will be printed?

class Subject:
    def __init__(self):
        self.observers = []
        self.state = 0
    def attach(self, observer):
        self.observers.append(observer)
    def set_state(self, state):
        self.state = state
        for obs in self.observers:
            obs.update(state)

class Observer:
    def __init__(self, name):
        self.name = name
    def update(self, state):
        print(f"{self.name} received state {state}")

subject = Subject()
obs1 = Observer('A')
obs2 = Observer('B')
subject.attach(obs1)
subject.attach(obs2)
subject.set_state(5)

medium

A. A received state 5
B received state 5

B. A received state 0
B received state 0

C. No output

D. Error: update method missing

Solution

1. Step 1: Follow the attach and set_state calls

   Observers A and B are attached to the subject. When set_state(5) is called, it updates the state and calls update(5) on each observer.

2. Step 2: Understand the update method output

   Each observer prints its name and the new state, so both print lines with state 5.

3. Final Answer:

   A received state 5 B received state 5 -> Option A

4. Quick Check:

   Observers print updated state 5 [OK]

Hint: Observers print on update call with new state [OK]

Common Mistakes:

• Thinking observers print old state
• Assuming no output without explicit print
• Confusing method names causing errors

4.

Identify the bug in this Observer pattern implementation:

class Subject:
    def __init__(self):
        self.observers = set()
    def attach(self, observer):
        self.observers.add(observer)
    def notify(self):
        for obs in self.observers:
            obs.update()

class Observer:
    def update(self, state):
        print(f"State updated to {state}")

subject = Subject()
obs = Observer()
subject.attach(obs)
subject.notify()

medium

A. Observer.update requires a state argument but notify calls without it

B. Subject.observers should be a list, not a set

C. attach method should remove observers, not add

D. notify method should not call update

Solution

1. Step 1: Check method signatures and calls

   The Observer's update method expects a state argument, but notify calls update() without any argument.

2. Step 2: Identify mismatch causing error

   This mismatch will cause a runtime error due to missing required positional argument.

3. Final Answer:

   Observer.update requires a state argument but notify calls without it -> Option A

4. Quick Check:

   Method argument mismatch causes error [OK]

Hint: Check method parameters match calls exactly [OK]

Common Mistakes:

• Ignoring missing argument errors
• Thinking sets are invalid for observers
• Misunderstanding attach method purpose

5.

You are designing a stock price alert system using the Observer pattern. Multiple clients want updates only when the stock price changes by more than 5%. How should you modify the Observer pattern to handle this efficiently?

hard

A. Make observers poll the Subject periodically for changes

B. Notify all observers on every price change regardless of amount

C. Add a threshold check in the Subject before notifying observers

D. Remove the Observer pattern and use direct method calls

Solution

1. Step 1: Understand the requirement for selective updates

   Clients want updates only if price changes exceed 5%, so notifying on every change is inefficient.

2. Step 2: Implement threshold logic in Subject

   Adding a check in the Subject to compare new price with old and notify observers only if change > 5% reduces unnecessary notifications.

3. Final Answer:

   Add a threshold check in the Subject before notifying observers -> Option C

4. Quick Check:

   Efficient notify = threshold check in Subject [OK]

Hint: Filter notifications in Subject to reduce updates [OK]

Common Mistakes:

• Not filtering updates causing overload
• Using polling which wastes resources
• Removing Observer pattern loses decoupling benefits