Command pattern in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding the core purpose of the Command pattern

Which of the following best describes the main purpose of the Command pattern in software design?

A To create a single instance of a class to control access to a resource.

B To encapsulate a request as an object, allowing parameterization and queuing of requests.

C To define a family of algorithms and make them interchangeable at runtime.

D To separate the construction of a complex object from its representation.

💡 Hint

Think about how commands can be stored and executed later.

The Command pattern encapsulates a request as an object, which allows you to parameterize clients with queues, requests, and operations. This supports undoable operations and logging.

❓ Architecture

intermediate

Identifying components in a Command pattern architecture

In a typical Command pattern architecture, which component is responsible for executing the actual operation?

A Receiver

B Client

C Invoker

D Command

💡 Hint

Consider which part knows how to perform the work.

The Receiver is the component that knows how to perform the operations associated with carrying out a request. The Command object calls methods on the Receiver to fulfill the request.

❓ scaling

advanced

Scaling command execution in distributed systems

You want to design a system using the Command pattern that supports executing commands asynchronously across multiple servers. Which approach best supports scalability and fault tolerance?

A Distribute commands to multiple worker nodes via a message queue, allowing parallel processing and retries on failure.

B Execute commands synchronously on the client side to avoid network overhead.

C Store commands in a local file and process them in batches once a day.

D Use a centralized command queue with a single worker processing commands sequentially.

💡 Hint

Think about how to handle many commands efficiently and recover from failures.

Distributing commands via a message queue to multiple workers allows parallel processing, improving scalability. Message queues also support retries and fault tolerance, making the system more robust.

❓ tradeoff

advanced

Tradeoffs of using the Command pattern for undo functionality

When implementing undo functionality using the Command pattern, what is a key tradeoff to consider?

A The Command pattern cannot support undo operations effectively.

B Undo functionality requires commands to be stateless, simplifying design but limiting features.

C Commands must store state to reverse actions, increasing memory usage and complexity.

D Undo operations are automatically handled by the Invoker without extra code.

💡 Hint

Think about what is needed to reverse an action.

To support undo, commands often need to store the state before execution or implement reverse operations. This adds memory overhead and complexity to the command objects.

❓ estimation

expert

Estimating command queue capacity for a high-traffic system

A system uses the Command pattern with a command queue to handle user requests. The system expects 10,000 commands per second, each command averaging 5 KB in size. The queue should hold commands for up to 10 seconds to handle spikes. What is the minimum queue storage capacity required?

A 50 MB

B 500 KB

C 5 GB

D 500 MB

💡 Hint

Calculate total commands in 10 seconds and multiply by command size.

10,000 commands/sec * 10 seconds = 100,000 commands. Each command is 5 KB, so total = 100,000 * 5 KB = 500,000 KB = 500 MB.