Command pattern in LLD - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define the Command interface method.

LLD

interface Command {
    void [1]();
}

Drag options to blanks, or click blank then click option'

Aexecute

Brun

Cstart

Dcall

Attempts:

3 left

💡 Hint

Common Mistakes

Using method names like run or start which are not standard in Command pattern.

Leaving the method name empty or incorrect.

The Command interface defines the execute method which all commands implement.

2fill in blank

medium

Complete the code to implement the execute method in a concrete command.

LLD

class LightOnCommand implements Command {
    private Light light;

    public LightOnCommand(Light light) {
        this.light = light;
    }

    public void [1]() {
        light.on();
    }
}

Drag options to blanks, or click blank then click option'

Aexecute

Bcall

Cstart

Drun

Attempts:

3 left

💡 Hint

Common Mistakes

Using a method name different from the interface.

Not calling the receiver's method inside execute.

The concrete command implements the execute method to call the receiver's action.

3fill in blank

hard

Fix the error in the Invoker class to call the command properly.

LLD

class RemoteControl {
    private Command slot;

    public void setCommand(Command command) {
        this.slot = command;
    }

    public void buttonWasPressed() {
        slot.[1]();
    }
}

Drag options to blanks, or click blank then click option'

Acall

Brun

Cstart

Dexecute

Attempts:

3 left

💡 Hint

Common Mistakes

Calling a method name not defined in the Command interface.

Forgetting to call the method on the command object.

The Invoker calls the execute method on the command to perform the action.

4fill in blank

hard

Fill both blanks to complete the UndoableCommand interface extending Command and adding undo method.

LLD

interface UndoableCommand extends Command {
    void [1]();
    void [2]();
}

Drag options to blanks, or click blank then click option'

Aexecute

Bundo

Credo

Drun

Attempts:

3 left

💡 Hint

Common Mistakes

Using incorrect method names like redo or run.

Not including execute method in the interface.

The UndoableCommand interface extends Command by adding undo method alongside execute.

5fill in blank

hard

Fill all three blanks to complete the Client code that creates a command, sets it to the invoker, and triggers execution.

LLD

Light light = new Light();
Command lightOn = new LightOnCommand([1]);
RemoteControl remote = new RemoteControl();
remote.[2](lightOn);
remote.[3]();

Drag options to blanks, or click blank then click option'

Alight

BsetCommand

CbuttonWasPressed

Dexecute

Attempts:

3 left

💡 Hint

Common Mistakes

Passing wrong object to command constructor.

Using wrong method names on the invoker.

Calling execute directly on the invoker.

The client creates a receiver light, a command with that receiver, sets the command on the invoker, and presses the button to execute.

Practice

1. What is the main purpose of the Command pattern in system design?

easy

A. To create multiple instances of a class efficiently

B. To ensure only one instance of a class exists

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

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

Solution

1. Step 1: Understand the Command pattern role

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

2. Step 2: Compare with other patterns

   Creating multiple instances relates to Prototype or Factory, a family of algorithms to Strategy, and a single instance to Singleton; these are not Command.

3. Final Answer:

   To encapsulate a request as an object, allowing parameterization and queuing of requests -> Option D

4. Quick Check:

   Command pattern = encapsulate request [OK]

Hint: Command pattern = wrap action as object for flexibility [OK]

Common Mistakes:

• Confusing Command with Singleton or Factory patterns
• Thinking Command creates instances instead of encapsulating actions
• Mixing Command with Strategy pattern

2. Which of the following is the correct method signature for the execute method in a Command interface?

easy

A. void execute(String[] args);

B. void execute();

C. boolean execute(String commandName);

D. int execute(int commandId);

Solution

1. Step 1: Recall Command interface basics

   The Command interface typically defines a simple execute() method without parameters to perform the action.

2. Step 2: Analyze options

   The options with parameters (String[], int commandId, String commandName) or return types are not standard in Command pattern interfaces; the command object itself holds necessary data.

3. Final Answer:

   void execute(); -> Option B

4. Quick Check:

   Command execute method = void execute() [OK]

Hint: Command execute usually has no parameters [OK]

Common Mistakes:

• Adding parameters to execute method unnecessarily
• Confusing Command with other patterns that require arguments
• Assuming execute returns a value

3. Given the following code snippet implementing the Command pattern, what will be the output?

class Light {
  turnOn() { console.log('Light is ON'); }
  turnOff() { console.log('Light is OFF'); }
}

class TurnOnCommand {
  constructor(light) { this.light = light; }
  execute() { this.light.turnOn(); }
}

class TurnOffCommand {
  constructor(light) { this.light = light; }
  execute() { this.light.turnOff(); }
}

class RemoteControl {
  setCommand(command) { this.command = command; }
  pressButton() { this.command.execute(); }
}

const light = new Light();
const remote = new RemoteControl();
remote.setCommand(new TurnOnCommand(light));
remote.pressButton();
remote.setCommand(new TurnOffCommand(light));
remote.pressButton();

medium

A. Light is ON\nLight is OFF

B. Light is OFF\nLight is ON

C. Light is ON\nLight is ON

D. Light is OFF\nLight is OFF

Solution

1. Step 1: Trace first command execution

   The remote sets the command to TurnOnCommand and calls execute, which calls light.turnOn(), printing 'Light is ON'.

2. Step 2: Trace second command execution

   The remote sets the command to TurnOffCommand and calls execute, which calls light.turnOff(), printing 'Light is OFF'.

3. Final Answer:

   Light is ON\nLight is OFF -> Option A

4. Quick Check:

   TurnOn then TurnOff commands print ON then OFF [OK]

Hint: Follow command set and execute calls step-by-step [OK]

Common Mistakes:

• Mixing order of commands
• Assuming commands execute immediately without setting
• Confusing method names turnOn and turnOff

4. In the following code, what is the main issue that prevents the Command pattern from working correctly?

class Light {
  turnOn() { console.log('Light is ON'); }
}

class TurnOnCommand {
  constructor() { }
  execute() { this.light.turnOn(); }
}

const light = new Light();
const command = new TurnOnCommand();
command.execute();

medium

A. The execute method should return a value

B. The Light class is missing the turnOff method

C. The TurnOnCommand constructor does not receive or store the Light object

D. The command object is not instantiated properly

Solution

1. Step 1: Check TurnOnCommand constructor

   The constructor does not accept or assign the Light object to this.light, so this.light is undefined.

2. Step 2: Analyze execute method call

   Calling this.light.turnOn() fails because this.light is undefined, causing an error.

3. Final Answer:

   The TurnOnCommand constructor does not receive or store the Light object -> Option C

4. Quick Check:

   Missing light reference in command = error [OK]

Hint: Ensure command stores receiver object before execute [OK]

Common Mistakes:

• Ignoring missing receiver object in command
• Thinking missing turnOff method causes error here
• Assuming execute must return a value

5. You are designing a text editor with undo functionality using the Command pattern. Which design choice best supports undo operations efficiently?

hard

A. Store a history stack of Command objects and call an undo() method on the last command

B. Keep a log of all text changes as strings and replay them to undo

C. Use a single Command object that modifies text directly without history

D. Implement undo by reloading the entire document from disk

Solution

1. Step 1: Understand undo with Command pattern

   Each Command object should implement both execute() and undo() methods to reverse its action.

2. Step 2: Evaluate design choices

   Storing a history stack of Command objects allows calling undo() on the last command efficiently. Other options either lack command encapsulation or are inefficient.

3. Final Answer:

   Store a history stack of Command objects and call an undo() method on the last command -> Option A

4. Quick Check:

   Undo = command history stack with undo() [OK]

Hint: Undo needs command history with undo method [OK]

Common Mistakes:

• Using string logs instead of command objects
• Not implementing undo in commands
• Reloading entire document is inefficient