Visitor pattern in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding the core purpose of the Visitor pattern

What is the main advantage of using the Visitor pattern in a system design?

A It ensures only one instance of a class exists throughout the application.

B It simplifies the creation of objects by separating construction from representation.

C It allows adding new operations to existing object structures without modifying those structures.

D It provides a way to access elements of a collection sequentially without exposing its underlying representation.

💡 Hint

Think about how the Visitor pattern helps when you want to add new behaviors without changing existing classes.

The Visitor pattern lets you add new operations to object structures without changing the classes of the elements on which it operates. This promotes open/closed principle.

❓ Architecture

intermediate

Identifying components in Visitor pattern architecture

Which of the following correctly identifies the key components involved in the Visitor pattern?

A Factory, Product, ConcreteProduct, Creator

B Visitor, Element, ConcreteElement, ConcreteVisitor, ObjectStructure

C Component, Composite, Leaf, Client

D Subject, Observer, ConcreteObserver, ConcreteSubject

💡 Hint

Recall the roles that define the Visitor pattern structure.

The Visitor pattern includes Visitor interface, Element interface, ConcreteElement classes, ConcreteVisitor classes, and an ObjectStructure to hold elements.

❓ scaling

advanced

Scaling Visitor pattern for multiple operations

You have a complex object structure with many element types. You need to add multiple new operations frequently. What is a major tradeoff when using the Visitor pattern in this scenario?

A Adding new element types requires modifying all existing visitors, which can be costly.

B The Visitor pattern automatically scales without any tradeoffs.

C The Visitor pattern does not support adding new operations without changing element classes.

D Adding new operations is easy, but adding new element types requires changing all visitors.

💡 Hint

Consider what happens when you add new element types versus new operations.

The Visitor pattern makes adding new operations easy by adding new visitors. However, adding new element types requires updating all existing visitors, which is a tradeoff.

❓ tradeoff

advanced

Tradeoff analysis of Visitor pattern in system design

Which of the following best describes a key disadvantage of using the Visitor pattern in a system with frequently changing element classes?

A It requires modifying all visitor classes whenever a new element class is added.

B It makes adding new operations impossible without changing element classes.

C It tightly couples element classes with visitor implementations, reducing flexibility.

D It increases runtime performance overhead significantly.

💡 Hint

Think about maintenance effort when element classes change often.

When element classes change frequently, the Visitor pattern requires updating all visitor classes to handle new elements, increasing maintenance effort.

❓ component

expert

Request flow in Visitor pattern with multiple visitors

Consider a system where an object structure accepts two different visitors sequentially: a PricingVisitor and a ReportingVisitor. Which sequence correctly describes the request flow when the object structure accepts these visitors?

A ObjectStructure calls accept on each element with PricingVisitor, then calls accept on each element with ReportingVisitor.

B PricingVisitor calls accept on ObjectStructure, which then calls accept on ReportingVisitor.

C ReportingVisitor modifies ObjectStructure, then PricingVisitor visits elements independently.

D ObjectStructure merges PricingVisitor and ReportingVisitor into one visitor before visiting elements.

💡 Hint

Recall how the accept method works in the Visitor pattern for multiple visitors.

The ObjectStructure iterates over elements and calls accept with each visitor separately, allowing each visitor to perform its operation on all elements.

Practice

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

easy

A. To separate operations from the objects on which they operate

B. To create multiple instances of a class

C. To restrict access to certain parts of an object

D. To simplify database queries

Solution

1. Step 1: Understand the Visitor pattern concept

   The Visitor pattern allows defining new operations on objects without changing their classes.

2. Step 2: Identify the main goal

   Its main goal is to separate the operation logic from the object structure to keep code flexible.

3. Final Answer:

   To separate operations from the objects on which they operate -> Option A

4. Quick Check:

   Visitor pattern = separates operations [OK]

Hint: Visitor pattern separates operations from objects [OK]

Common Mistakes:

• Confusing Visitor with Singleton pattern
• Thinking it creates object instances
• Assuming it controls access permissions

2. Which of the following is the correct method signature for a visitor interface method visiting an element called ElementA?

easy

A. void accept(ElementA element);

B. void acceptVisitor(ElementA visitor);

C. void visitElementA();

D. void visit(ElementA element);

Solution

1. Step 1: Recall Visitor interface method naming

   The visitor interface defines methods named visit with the element type as parameter.

2. Step 2: Match correct signature

   The correct signature is void visit(ElementA element); to visit ElementA.

3. Final Answer:

   void visit(ElementA element); -> Option D

4. Quick Check:

   Visitor method = visit(Element) [OK]

Hint: Visitor methods are named visit(Element) [OK]

Common Mistakes:

• Confusing accept and visit method names
• Using no parameters in visit method
• Swapping visitor and element in parameters

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

class ElementA {
  accept(visitor) {
    visitor.visit(this);
  }
}

class PrintVisitor {
  visit(element) {
    console.log('Visited element');
  }
}

const element = new ElementA();
const visitor = new PrintVisitor();
element.accept(visitor);

medium

A. Visited ElementA

B. Error: visit is not a function

C. Visited element

D. No output

Solution

1. Step 1: Trace accept method call

   The accept method calls visitor.visit(this), passing the element instance.

2. Step 2: Check visit method behavior

   The visit method logs 'Visited element' to the console.

3. Final Answer:

   Visited element -> Option C

4. Quick Check:

   Visitor.visit logs message [OK]

Hint: Visitor.visit prints message when accept calls it [OK]

Common Mistakes:

• Expecting element type name in output
• Thinking visit method is missing
• Assuming no output without explicit return

4. Identify the error in this Visitor pattern implementation:

class ElementB {
  accept(visitor) {
    visitor.accept(this);
  }
}

class ConcreteVisitor {
  visit(element) {
    console.log('Visiting element');
  }
}

medium

A. ElementB calls visitor.accept instead of visitor.visit

B. ConcreteVisitor should not have a visit method

C. accept method should return a value

D. ElementB should not have an accept method

Solution

1. Step 1: Check accept method call

   The accept method calls visitor.accept(this), but visitor has no accept method.

2. Step 2: Identify correct visitor method

   The visitor interface defines visit methods, so accept should call visitor.visit(this).

3. Final Answer:

   ElementB calls visitor.accept instead of visitor.visit -> Option A

4. Quick Check:

   accept calls visit, not accept [OK]

Hint: accept calls visitor.visit, not visitor.accept [OK]

Common Mistakes:

• Confusing method names accept and visit
• Expecting accept to return a value
• Removing accept method from element

5. You have a system with multiple element types and want to add a new operation without modifying existing element classes. How does the Visitor pattern help in this scenario?

hard

A. By using inheritance to extend element classes with new operations

B. By creating a new visitor class implementing the operation for all element types

C. By adding new methods to each element class directly

D. By storing operations inside element objects as data

Solution

1. Step 1: Understand the problem of adding new operations

   Modifying existing element classes is risky and breaks encapsulation.

2. Step 2: Apply Visitor pattern solution

   Create a new visitor class that implements the new operation for all element types, keeping element classes unchanged.

3. Final Answer:

   By creating a new visitor class implementing the operation for all element types -> Option B

4. Quick Check:

   Visitor adds operations via new visitor classes [OK]

Hint: Add new visitor class for new operations [OK]

Common Mistakes:

• Modifying element classes directly
• Using inheritance to add operations
• Embedding operations as data in elements