When to use which behavioral pattern in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Choosing the Right Behavioral Pattern for Communication

You have a system where multiple objects need to communicate without tight coupling. Which behavioral pattern is best suited to facilitate this communication?

A Observer pattern to notify objects about state changes.

B Strategy pattern to select algorithms at runtime.

C Command pattern to encapsulate requests as objects.

D Iterator pattern to traverse elements sequentially.

💡 Hint

Think about a pattern that helps objects stay updated about changes in others without direct dependencies.

The Observer pattern allows objects to subscribe and get notified about changes, enabling loose coupling in communication.

❓ Architecture

intermediate

Selecting a Behavioral Pattern for Undo Functionality

You are designing a text editor that supports undo and redo operations. Which behavioral pattern should you use to encapsulate user actions?

A State pattern to manage object states.

B Mediator pattern to coordinate actions between components.

C Command pattern to encapsulate requests as objects.

D Visitor pattern to separate algorithms from objects.

💡 Hint

Consider a pattern that allows storing and executing actions as objects, enabling undo and redo.

The Command pattern encapsulates actions as objects, making it easy to implement undo and redo by storing command history.

❓ scaling

advanced

Scaling Event Handling in a Large System

In a large distributed system, you want to handle events efficiently without tight coupling between event producers and consumers. Which behavioral pattern helps scale event handling?

A Observer pattern to notify subscribers of events.

B Chain of Responsibility pattern to pass requests along a chain.

C Template Method pattern to define skeleton of an algorithm.

D Memento pattern to capture and restore object state.

💡 Hint

Focus on a pattern that supports multiple subscribers reacting to events independently.

The Observer pattern supports multiple subscribers listening to events, enabling scalable and decoupled event handling.

❓ tradeoff

advanced

Tradeoffs Between State and Strategy Patterns

You need to design a system where an object changes its behavior based on its internal state. You consider using either the State or Strategy pattern. What is a key tradeoff between these two patterns?

A Strategy pattern tightly couples states; State pattern decouples them.

B Strategy pattern changes object state automatically; State pattern does not.

C State pattern is used only for UI components; Strategy is for algorithms.

D State pattern manages state transitions internally; Strategy requires external management.

💡 Hint

Think about who controls the switching of behaviors in each pattern.

The State pattern encapsulates state transitions inside the object, while Strategy requires the client to manage which strategy to use.

❓ estimation

expert

Estimating Capacity for Command Pattern in High-Load System

You implement the Command pattern to queue user requests in a high-load system. If each command object averages 1KB and you expect 10,000 commands per second with a retention time of 5 minutes, estimate the memory needed to store commands in the queue.

A Approximately 600 MB of memory.

B Approximately 3 GB of memory.

C Approximately 1 GB of memory.

D Approximately 500 MB of memory.

💡 Hint

Calculate total commands stored = commands per second * retention time in seconds, then multiply by size per command.

10,000 commands/sec * 300 sec = 3,000,000 commands * 1 KB = 3,000,000 KB ≈ 2.86 GB, which is approximately 3 GB.

Practice

1. Which behavioral pattern is best suited when you want multiple objects to be notified automatically when one object changes its state?

easy

A. Observer pattern

B. Strategy pattern

C. Command pattern

D. Chain of Responsibility pattern

Solution

1. Step 1: Understand the need for automatic notifications

   The problem requires multiple objects to be updated when one object changes state, which means a one-to-many dependency.

2. Step 2: Match the pattern to the problem

   The Observer pattern is designed exactly for this: it lets observers subscribe to an object and get notified on changes.

3. Final Answer:

   Observer pattern -> Option A

4. Quick Check:

   Change notification = Observer [OK]

Hint: Notifications to many? Use Observer pattern [OK]

Common Mistakes:

• Confusing Strategy with Observer
• Using Command for notifications
• Choosing Chain of Responsibility for updates

2. Which pattern allows you to change an object's behavior at runtime by switching between different algorithms or strategies?

easy

A. Observer pattern

B. Strategy pattern

C. Command pattern

D. Chain of Responsibility pattern

Solution

1. Step 1: Identify the need for interchangeable behaviors

   The question asks about changing behavior dynamically, which means selecting algorithms or methods at runtime.

2. Step 2: Select the pattern that supports behavior switching

   The Strategy pattern encapsulates algorithms and lets you swap them easily without changing the client code.

3. Final Answer:

   Strategy pattern -> Option B

4. Quick Check:

   Change behavior dynamically = Strategy [OK]

Hint: Switch algorithms easily? Use Strategy pattern [OK]

Common Mistakes:

• Mixing Strategy with Observer
• Using Command for behavior changes
• Choosing Chain of Responsibility incorrectly

3. Consider this scenario: You have a request that can be handled by multiple objects in a chain. Each object decides if it can handle the request or passes it on. Which pattern fits this design?
Request -> Handler1 -> Handler2 -> Handler3

medium

A. Command pattern

B. Strategy pattern

C. Observer pattern

D. Chain of Responsibility pattern

Solution

1. Step 1: Analyze the request handling flow

   The request passes through a chain of handlers, each deciding to handle or forward it.

2. Step 2: Identify the matching behavioral pattern

   The Chain of Responsibility pattern allows multiple objects to handle a request in sequence until one handles it.

3. Final Answer:

   Chain of Responsibility pattern -> Option D

4. Quick Check:

   Request passes chain = Chain of Responsibility [OK]

Hint: Request passes chain? Use Chain of Responsibility [OK]

Common Mistakes:

• Confusing Chain with Command
• Using Observer for request handling
• Choosing Strategy incorrectly

4. You have a system where commands need to be queued, logged, and executed later. Which behavioral pattern should you use? Identify the error in this choice:
Using Observer pattern to queue commands.

medium

A. Incorrect, use Command pattern instead

B. Incorrect, use Chain of Responsibility instead

C. Incorrect, use Strategy pattern instead

D. Correct use of Observer

Solution

1. Step 1: Understand the requirement for queuing and executing commands

   Queuing, logging, and executing commands later requires encapsulating requests as objects.

2. Step 2: Identify the pattern that encapsulates requests

   The Command pattern encapsulates requests as objects, allowing queuing and deferred execution.

3. Step 3: Identify the error in using Observer

   Observer is for notifications, not for command encapsulation or queuing.

4. Final Answer:

   Incorrect, use Command pattern instead -> Option A

5. Quick Check:

   Queue commands = Command pattern [OK]

Hint: Queue commands? Use Command, not Observer [OK]

Common Mistakes:

• Using Observer for command queuing
• Confusing Command with Strategy
• Choosing Chain of Responsibility wrongly

5. You are designing a notification system where users can subscribe to different event types, and the system should allow adding new event types without changing existing code. Which combination of behavioral patterns is best suited?

hard

A. Chain of Responsibility for subscriptions and Command for event handling

B. Command for subscriptions and Chain of Responsibility for event handling

C. Observer for subscriptions and Strategy for event handling

D. Strategy for subscriptions and Observer for event handling

Solution

1. Step 1: Identify the subscription mechanism

   Users subscribing to events fits the Observer pattern, which supports dynamic subscription and notification.

2. Step 2: Identify flexible event handling

   Strategy pattern allows interchangeable algorithms for handling different event types without changing existing code.

3. Step 3: Combine patterns for extensibility

   Using Observer for subscriptions and Strategy for event handling supports adding new event types easily and keeps code maintainable.

4. Final Answer:

   Observer for subscriptions and Strategy for event handling -> Option C

5. Quick Check:

   Subscribe = Observer, flexible handling = Strategy [OK]

Hint: Subscribe = Observer, flexible handling = Strategy [OK]

Common Mistakes:

• Mixing Command with subscriptions
• Using Chain of Responsibility for subscriptions
• Confusing Strategy with Observer roles