Command pattern for undo in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding the Command Pattern for Undo

Which of the following best describes the role of the Command object in implementing undo functionality?

A It directly modifies the user interface without storing any state.

B It stores the action and its inverse operation to allow undoing the action later.

C It only logs the action name without any data to revert changes.

D It executes the action but does not support undo operations.

💡 Hint

Think about how undo requires reversing an action.

The Command object encapsulates both the action and the logic to undo it, enabling the system to revert changes when needed.

❓ Architecture

intermediate

Designing Undo with Command Pattern Components

In a system using the Command pattern for undo, which component is responsible for keeping track of executed commands to support undo operations?

A Command objects themselves keep a global list of all commands.

B Receiver stores the history of commands executed.

C Client directly calls undo methods on commands without tracking.

D Invoker maintains a stack of executed Command objects.

💡 Hint

Consider which part initiates commands and can manage their order.

The Invoker executes commands and keeps a stack of them to allow undoing in reverse order.

❓ scaling

advanced

Scaling Undo in a Multi-User Collaborative System

When scaling undo functionality using the Command pattern in a collaborative multi-user environment, which challenge is most critical to address?

A Ensuring command history consistency across users to avoid conflicts during undo.

B Ignoring command dependencies and undoing commands in any order.

C Allowing each user to undo only their last command without coordination.

D Storing commands only on the client side without synchronization.

💡 Hint

Think about how multiple users' actions affect shared state.

In collaborative systems, command histories must be consistent and coordinated to prevent conflicts when undoing actions.

❓ tradeoff

advanced

Tradeoffs in Storing Command State for Undo

What is a key tradeoff when deciding how much state to store inside Command objects to support undo?

A More stored state increases memory use but simplifies undo logic.

B Less stored state reduces memory but makes undo impossible.

C Storing no state always improves performance without drawbacks.

D Storing state externally always eliminates the need for Command objects.

💡 Hint

Consider memory use versus ease of undo implementation.

Storing more state inside commands uses more memory but makes undo easier and more reliable.

❓ component

expert

Request Flow in Command Pattern Undo Implementation

Given a system using the Command pattern with undo, what is the correct sequence of steps when a user performs an action and then undoes it?

A 1,2,4,3,5,6,7

B 1,3,2,4,5,6,7

C 1,2,3,4,5,6,7

D 1,2,3,5,4,6,7

💡 Hint

Follow the logical flow of action execution and undo.

The user triggers an action, the Invoker creates and executes the Command, which calls the Receiver. The Command is pushed to the undo stack. On undo, the Invoker pops the Command and calls its undo method on the Receiver.

Practice

1. What is the main purpose of the Command pattern in the context of undo functionality?

easy

A. To replace all conditional statements with loops

B. To directly modify the user interface without storing history

C. To store data in a database for permanent record

D. To encapsulate actions as objects with execute and undo methods

Solution

1. Step 1: Understand the role of Command pattern

   The Command pattern wraps actions as objects, allowing them to be executed and undone independently.

2. Step 2: Relate to undo functionality

   This wrapping enables storing commands in a history stack, so undo can call the undo method on the last command.

3. Final Answer:

   To encapsulate actions as objects with execute and undo methods -> Option D

4. Quick Check:

   Command pattern = encapsulate actions for undo [OK]

Hint: Command pattern wraps actions for undo/redo [OK]

Common Mistakes:

• Thinking Command pattern modifies UI directly
• Confusing Command pattern with data storage
• Assuming it replaces loops or conditionals

2. Which method signature correctly belongs to a Command interface supporting undo?

easy

A. void save(); void load();

B. void execute(); void undo();

C. void start(); void finish();

D. void run(); void stop();

Solution

1. Step 1: Identify standard Command interface methods

   The Command pattern typically defines an execute() method to perform the action and an undo() method to reverse it.

2. Step 2: Match method signatures

   Only void execute(); void undo(); has execute() and undo(), matching the Command pattern for undo.

3. Final Answer:

   void execute(); void undo(); -> Option B

4. Quick Check:

   Command methods = execute and undo [OK]

Hint: Look for execute() and undo() methods [OK]

Common Mistakes:

• Choosing unrelated method names like run/stop
• Confusing start/finish with undo functionality
• Assuming save/load are Command methods

3. Given the following code snippet, what will be the output after calling undo() on the last command?

class AddCommand:
    def __init__(self, value, receiver):
        self.value = value
        self.receiver = receiver
    def execute(self):
        self.receiver.total += self.value
    def undo(self):
        self.receiver.total -= self.value

class Receiver:
    def __init__(self):
        self.total = 0

receiver = Receiver()
cmd1 = AddCommand(5, receiver)
cmd2 = AddCommand(3, receiver)
cmd1.execute()
cmd2.execute()
cmd2.undo()
print(receiver.total)

medium

A. 5

B. 8

C. 3

D. 0

Solution

1. Step 1: Trace command executions

   Initially, receiver.total = 0. After cmd1.execute(), total = 0 + 5 = 5. After cmd2.execute(), total = 5 + 3 = 8.

2. Step 2: Apply undo on cmd2

   cmd2.undo() subtracts 3, so total = 8 - 3 = 5.

3. Final Answer:

   5 -> Option A

4. Quick Check:

   Execute adds, undo subtracts = 5 [OK]

Hint: Undo reverses last execute effect on total [OK]

Common Mistakes:

• Forgetting to subtract on undo
• Assuming undo resets total to zero
• Mixing order of execute and undo

4. Identify the bug in this undo implementation of a Command pattern:

class MultiplyCommand:
    def __init__(self, value, receiver):
        self.value = value
        self.receiver = receiver
        self.prev = None
    def execute(self):
        self.prev = self.receiver.total
        self.receiver.total *= self.value
    def undo(self):
        self.receiver.total /= self.value

receiver = type('Receiver', (), {'total': 10})()
cmd = MultiplyCommand(2, receiver)
cmd.execute()
cmd.undo()
print(receiver.total)

medium

A. Execute should add instead of multiply

B. Undo method is missing

C. Undo should restore previous value, not divide

D. Receiver class is not defined

Solution

1. Step 1: Analyze execute and undo methods

   Execute saves previous total and multiplies current total by value. Undo divides total by value.

2. Step 2: Identify problem with undo

   Undo divides by value, but if value is zero or changed, this may not restore original total exactly. It should restore saved previous total instead.

3. Final Answer:

   Undo should restore previous value, not divide -> Option C

4. Quick Check:

   Undo must restore saved state, not recalculate [OK]

Hint: Undo must restore saved state, not recalculate [OK]

Common Mistakes:

• Assuming division always reverses multiplication
• Not saving previous state before execute
• Ignoring edge cases like zero multiplication

5. You are designing a text editor with undo using the Command pattern. Which approach best supports multiple undo and redo operations efficiently?

hard

A. Use two stacks: one for undo commands, one for redo commands

B. Store all commands in a single list without pointers

C. Only keep the last command for undo, discard others

D. Save full document snapshots after each command

Solution

1. Step 1: Understand undo/redo requirements

   Undo reverses last command, redo reapplies commands undone. Efficient support requires tracking both undo and redo history.

2. Step 2: Evaluate data structures

   Two stacks allow pushing commands on execute, popping for undo, and pushing undone commands to redo stack. This supports multiple undo/redo efficiently.

3. Final Answer:

   Use two stacks: one for undo commands, one for redo commands -> Option A

4. Quick Check:

   Two stacks = efficient undo/redo [OK]

Hint: Two stacks handle undo and redo efficiently [OK]

Common Mistakes:

• Using single list without tracking position
• Keeping only last command loses history
• Saving full snapshots wastes memory