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.