Chain of Responsibility pattern in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding the Chain of Responsibility Pattern

Which of the following best describes the main purpose of the Chain of Responsibility pattern?

A It allows multiple objects to handle a request without coupling the sender to the receiver by passing the request along a chain until an object handles it.

B It creates a single object responsible for handling all requests directly without delegation.

C It duplicates the request to all objects in a list so all handle it simultaneously.

D It forces the sender to know exactly which object will handle the request before sending it.

💡 Hint

Think about how requests are passed along in a chain until handled.

The Chain of Responsibility pattern passes a request along a chain of objects until one handles it, reducing coupling between sender and receiver.

❓ Architecture

intermediate

Identifying Components in Chain of Responsibility

In a Chain of Responsibility design, which component is responsible for deciding whether to handle a request or pass it to the next handler?

A The factory that creates handlers.

B The client that creates the request.

C The receiver object outside the chain.

D The handler object in the chain.

💡 Hint

Consider which object in the chain processes or forwards the request.

The handler object decides to process the request or pass it along the chain, making option D correct.

❓ scaling

advanced

Scaling Chain of Responsibility for High Throughput

You have a Chain of Responsibility handling requests in a web server. To scale for high throughput, which approach is best?

A Make the chain synchronous so each request waits for the previous to finish.

B Create multiple independent chains and distribute requests among them to process in parallel.

C Add more handlers to a single chain to increase processing power sequentially.

D Use a single handler to avoid overhead of passing requests along the chain.

💡 Hint

Think about parallel processing and avoiding bottlenecks.

Multiple independent chains allow parallel processing of requests, improving throughput, unlike a single sequential chain.

❓ tradeoff

advanced

Tradeoffs in Chain of Responsibility Pattern

What is a common tradeoff when using the Chain of Responsibility pattern in system design?

A It improves processing speed but tightly couples sender and receiver.

B It simplifies code but requires all handlers to process every request.

C It reduces coupling but can increase request processing time due to passing along the chain.

D It eliminates the need for handlers but increases client complexity.

💡 Hint

Consider the balance between flexibility and performance.

The pattern reduces coupling but may increase latency as requests pass through multiple handlers before being processed.

❓ estimation

expert

Estimating Maximum Chain Length for Performance

You design a Chain of Responsibility where each handler adds 2ms processing time. For a max acceptable latency of 100ms per request, what is the maximum number of handlers in the chain?

A 50 handlers

B 100 handlers

C 25 handlers

D 200 handlers

💡 Hint

Divide max latency by time per handler.

100ms max latency / 2ms per handler = 50 handlers max.

Practice

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

easy

A. To pass a request along a chain of handlers until one handles it

B. To create multiple copies of an object

C. To ensure only one instance of a class exists

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

Solution

1. Step 1: Understand the pattern's behavior

   The Chain of Responsibility pattern allows a request to be passed along a chain of objects until one can handle it.

2. Step 2: Compare options with the pattern's purpose

   The options describing singleton (one instance), prototype (object copies), and strategy (interchangeable algorithms) refer to other design patterns, not Chain of Responsibility.

3. Final Answer:

   To pass a request along a chain of handlers until one handles it -> Option A

4. Quick Check:

   Chain of Responsibility = pass request along chain [OK]

Hint: Remember: Chain passes request until handled [OK]

Common Mistakes:

• Confusing with Singleton or Strategy patterns
• Thinking it creates object copies
• Assuming it handles all requests at once

2. Which of the following is the correct way to link handlers in a Chain of Responsibility pattern?

easy

A. Handlers are linked using a global static list

B. Handlers are independent and do not reference each other

C. Handlers communicate through a shared database

D. Each handler holds a reference to the next handler in the chain

Solution

1. Step 1: Recall how handlers are connected

   In Chain of Responsibility, each handler has a reference to the next handler to pass the request along.

2. Step 2: Evaluate other options

   Global static lists, shared databases, and independent handlers describe unrelated or incorrect linking methods that contradict the chain concept.

3. Final Answer:

   Each handler holds a reference to the next handler in the chain -> Option D

4. Quick Check:

   Handler links = next handler reference [OK]

Hint: Handlers link by referencing the next handler [OK]

Common Mistakes:

• Using global lists instead of direct references
• Assuming handlers are independent
• Confusing with event broadcasting

3. Consider this simplified handler chain code snippet:

class Handler:
    def __init__(self, successor=None):
        self.successor = successor
    def handle(self, request):
        if self.can_handle(request):
            return f"Handled {request}"
        elif self.successor:
            return self.successor.handle(request)
        else:
            return "Not handled"
    def can_handle(self, request):
        return False

class ConcreteHandlerA(Handler):
    def can_handle(self, request):
        return request == 'A'

class ConcreteHandlerB(Handler):
    def can_handle(self, request):
        return request == 'B'

chain = ConcreteHandlerA(ConcreteHandlerB())
print(chain.handle('B'))

What is the output of this code?

medium

A. Handled B

B. Handled A

C. Not handled

D. Error

Solution

1. Step 1: Trace the request through the chain

   The request 'B' is first checked by ConcreteHandlerA, which returns False for can_handle('B'). It passes the request to ConcreteHandlerB.

2. Step 2: ConcreteHandlerB handles the request

   ConcreteHandlerB's can_handle('B') returns True, so it returns "Handled B".

3. Final Answer:

   Handled B -> Option A

4. Quick Check:

   Request 'B' handled by second handler [OK]

Hint: Request passes chain until a handler returns true [OK]

Common Mistakes:

• Assuming first handler handles all requests
• Confusing return values
• Missing the chain passing logic

4. Given the following code snippet, identify the bug that breaks the Chain of Responsibility pattern:

class Handler:
    def __init__(self, successor=None):
        self.successor = successor
    def handle(self, request):
        if self.can_handle(request):
            return f"Handled {request}"
        else:
            return "Not handled"
    def can_handle(self, request):
        return False

class ConcreteHandler(Handler):
    def can_handle(self, request):
        return request == 'X'

chain = ConcreteHandler()
print(chain.handle('Y'))

What is the main issue here?

medium

A. The successor is not initialized properly

B. The can_handle method always returns True

C. The handler does not pass the request to the successor

D. The handle method has a syntax error

Solution

1. Step 1: Analyze the handle method logic

   The handle method checks can_handle; if False, it returns "Not handled" immediately without passing to successor.

2. Step 2: Identify missing chain passing

   It should call self.successor.handle(request) if successor exists, but this is missing.

3. Final Answer:

   The handler does not pass the request to the successor -> Option C

4. Quick Check:

   Missing successor call breaks chain [OK]

Hint: Always pass request to successor if not handled [OK]

Common Mistakes:

• Forgetting to call successor.handle()
• Assuming can_handle always returns True
• Ignoring successor initialization

5. You are designing a logging system using the Chain of Responsibility pattern. You want to handle logs of different severity: DEBUG, INFO, WARNING, ERROR. Each handler should process logs at its level and pass higher severity logs down the chain. Which design best fits this requirement?

hard

A. Each handler processes only its level and passes all logs to the next handler

B. Each handler processes logs at its level and passes only higher severity logs to the next handler

C. Each handler processes all logs regardless of severity and stops the chain

D. Each handler processes logs randomly without order

Solution

1. Step 1: Understand the logging severity flow

   Logs should be handled at their level, and higher severity logs should continue down the chain for further handling.

2. Step 2: Evaluate options for correct chain behavior

   Each handler processes logs at its level and passes only higher severity logs to the next handler matches this: handlers process their level and pass higher severity logs onward. Each handler processes only its level and passes all logs to the next handler passes all logs regardless, which is inefficient. Each handler processes all logs regardless of severity and stops the chain stops chain prematurely. Each handler processes logs randomly without order is random and incorrect.

3. Final Answer:

   Each handler processes logs at its level and passes only higher severity logs to the next handler -> Option B

4. Quick Check:

   Process level, pass higher severity [OK]

Hint: Process own level, pass higher severity logs down [OK]

Common Mistakes:

• Passing all logs without filtering
• Stopping chain too early
• Ignoring severity order