Mediator pattern in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding the role of the Mediator

In a system using the Mediator pattern, what is the primary responsibility of the Mediator component?

A To replace all components with a single monolithic module

B To directly manage communication between components, reducing dependencies

C To store data persistently for all components

D To handle user interface rendering only

💡 Hint

Think about how components communicate without knowing each other directly.

The Mediator acts as a central hub that manages communication between components, helping to reduce tight coupling.

❓ Architecture

intermediate

Identifying components in a Mediator architecture

Which of the following best describes the components involved in a Mediator pattern architecture?

A Components communicate only through a central Mediator object that coordinates interactions

B Multiple components communicate directly with each other without any central controller

C A single component handles all logic and no communication is needed

D Components communicate through a shared global variable

💡 Hint

Focus on how communication is controlled in the pattern.

The Mediator pattern uses a central object to coordinate communication, preventing components from referring to each other directly.

❓ scaling

advanced

Scaling challenges with the Mediator pattern

What is a common scalability challenge when using the Mediator pattern in a large system?

A The Mediator can become a bottleneck as it handles all communication, increasing complexity

B Components become tightly coupled to each other, making changes difficult

C The system requires multiple Mediators to communicate directly with each other

D The Mediator pattern eliminates the need for any communication between components

💡 Hint

Consider what happens when one component handles all communication in a big system.

As the Mediator handles all interactions, it can grow complex and slow down the system if not designed carefully.

❓ tradeoff

advanced

Tradeoffs of using the Mediator pattern

Which tradeoff is true when applying the Mediator pattern in system design?

A It always improves performance by removing all indirect communication

B It simplifies the Mediator but increases dependencies between components

C It eliminates the need for any communication logic in the system

D It reduces component dependencies but can increase the complexity of the Mediator itself

💡 Hint

Think about what shifts when communication is centralized.

The pattern reduces direct dependencies but moves complexity into the Mediator, which must handle all coordination.

❓ component

expert

Request flow in a Mediator pattern system

Consider a chat application using the Mediator pattern where users send messages through a central chat room mediator. Which sequence correctly describes the request flow when User A sends a message to User B?

A 1,3,2,4

B 2,1,3,4

C 1,2,3,4

D 1,4,2,3

💡 Hint

Follow the logical order of message sending and receiving through the mediator.

The correct flow starts with User A sending the message to the Mediator, which then identifies the recipient and forwards the message, finally User B receives it.

Practice

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

easy

A. To store data persistently in a database

B. To increase direct communication between all components

C. To replace all components with a single monolithic class

D. To centralize communication between components and reduce dependencies

Solution

1. Step 1: Understand the role of Mediator

   The Mediator pattern acts as a central hub to manage communication between components, avoiding direct links between them.

2. Step 2: Compare options with Mediator's purpose

   To centralize communication between components and reduce dependencies correctly states the purpose: centralizing communication and reducing dependencies. Other options describe unrelated or incorrect behaviors.

3. Final Answer:

   To centralize communication between components and reduce dependencies -> Option D

4. Quick Check:

   Mediator centralizes communication = A [OK]

Hint: Mediator centralizes communication, not direct links [OK]

Common Mistakes:

• Thinking Mediator increases direct component communication
• Confusing Mediator with data storage patterns
• Assuming Mediator merges components into one

2. Which of the following is the correct way to define a Mediator interface in a low-level design?

easy

A. interface Mediator { void notify(Component sender, String event); }

B. class Mediator { void notifyAll(); }

C. interface Mediator { void sendMessage(String message); }

D. class Mediator { void receive(Component sender); }

Solution

1. Step 1: Identify typical Mediator method signature

   The Mediator usually has a method to notify it about events from components, often with sender and event details.

2. Step 2: Match method signatures to this pattern

   interface Mediator { void notify(Component sender, String event); } matches this pattern with notify(Component sender, String event). Others lack sender info or use incorrect method names.

3. Final Answer:

   interface Mediator { void notify(Component sender, String event); } -> Option A

4. Quick Check:

   Notify method with sender and event = B [OK]

Hint: Mediator notify method includes sender and event [OK]

Common Mistakes:

• Omitting sender parameter in notify method
• Using generic sendMessage without context
• Naming methods incorrectly for Mediator role

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

class Mediator {
  notify(sender, event) {
    if (event === 'A') return 'Handled A';
    if (event === 'B') return 'Handled B';
    return 'Unknown event';
  }
}

const mediator = new Mediator();
console.log(mediator.notify('Component1', 'B'));

medium

A. Handled A

B. Error: notify method missing

C. Handled B

D. Unknown event

Solution

1. Step 1: Analyze notify method logic

   The method returns 'Handled A' if event is 'A', 'Handled B' if event is 'B', else 'Unknown event'.

2. Step 2: Check the call with event 'B'

   The call is mediator.notify('Component1', 'B'), so it matches the second condition and returns 'Handled B'.

3. Final Answer:

   Handled B -> Option C

4. Quick Check:

   Event 'B' returns 'Handled B' [OK]

Hint: Match event string exactly in notify method [OK]

Common Mistakes:

• Confusing event 'B' with 'A'
• Assuming default case triggers for known events
• Expecting error due to missing parameters

4. In the following Mediator implementation, what is the main issue?

class Mediator {
  notify(sender, event) {
    if (event === 'start') {
      sender.start();
    } else if (event === 'stop') {
      sender.stop();
    }
  }
}

class Component {
  start() { console.log('Started'); }
  stop() { console.log('Stopped'); }
}

const mediator = new Mediator();
const comp = new Component();
mediator.notify(comp, 'start');

medium

A. Component class lacks notify method

B. Mediator calls methods on sender directly, creating tight coupling

C. notify method does not handle unknown events

D. Missing constructor in Mediator class

Solution

1. Step 1: Review Mediator's notify method behavior

   The Mediator calls start() or stop() directly on the sender component.

2. Step 2: Identify design issue

   This direct call creates tight coupling between Mediator and Component, defeating the purpose of loose coupling in Mediator pattern.

3. Final Answer:

   Mediator calls methods on sender directly, creating tight coupling -> Option B

4. Quick Check:

   Tight coupling breaks Mediator pattern goal = A [OK]

Hint: Mediator should avoid calling sender methods directly [OK]

Common Mistakes:

• Ignoring tight coupling caused by direct calls
• Thinking missing notify in Component is an error
• Assuming constructor absence causes failure

5. You are designing a chat application where multiple users send messages to each other. Which design using the Mediator pattern best fits this scenario?

hard

A. A ChatRoom mediator receives messages from users and forwards them to the intended recipients.

B. Users store messages locally and synchronize with a database periodically.

C. Each user sends messages directly to all other users without a central controller.

D. Users communicate only through email notifications handled by a separate service.

Solution

1. Step 1: Understand the chat communication needs

   Users need a central place to send and receive messages without direct dependencies on each other.

2. Step 2: Match with Mediator pattern usage

   A ChatRoom mediator receives messages from users and forwards them to the intended recipients. describes a ChatRoom mediator that manages message routing, fitting the Mediator pattern perfectly.

3. Final Answer:

   A ChatRoom mediator receives messages from users and forwards them to the intended recipients. -> Option A

4. Quick Check:

   Central message routing = C [OK]

Hint: Mediator centralizes message routing in chat apps [OK]

Common Mistakes:

• Choosing direct user-to-user messaging (no mediator)
• Confusing data storage with communication pattern
• Selecting unrelated communication methods