How do you solve Event Emitter on LeetCode?

Event Emitter (LeetCode #2694) can be solved using Brute Force or Optimal Solution. The optimal approach is Optimal Solution with O(n) time complexity and O(n) space complexity. Key insight: Understanding how to manage subscriptions and emissions efficiently is crucial.

What is the brute force solution for Event Emitter?

The brute force approach for Event Emitter is Brute Force, with O(n²) time complexity and O(n) space complexity. In the brute force approach, we will use a simple data structure to store events and their associated callbacks. Each time an event is emitted, we will iterate through the callbacks and execute them one by one. The optimal Optimal Solution approach improves this to O(n).

What are the interview tips for Event Emitter?

Clearly explain your thought process while coding. Test edge cases, such as emitting events with no subscribers. Practice writing clean and maintainable code.

What are common mistakes when solving Event Emitter?

Not returning the correct unsubscribe function. Failing to handle cases where no callbacks are subscribed.

#2694

Event Emitter

Medium

Hash MapArray

LeetCode ↗

Approaches

Brute ForceOptimal

Complexity Comparison

	Brute Force	Optimal Solution★
Time	O(n²)	O(n)
Space	O(n)	O(n)

💡

Intuition

Time O(n)Space O(n)

In the optimal approach, we maintain a dictionary to store events and their callbacks, allowing for efficient subscription and emission. This structure allows us to quickly access and manage the callbacks associated with each event.

⚙️

Algorithm

3 steps

1Step 1: Initialize a dictionary to hold events and their corresponding callbacks.
2Step 2: In the subscribe method, add the callback to the list of callbacks for the specified event.
3Step 3: In the emit method, retrieve the callbacks for the event and execute them, collecting the results in an array.

solution.py14 lines

1class EventEmitter:
2    def __init__(self):
3        self.events = {}
4
5    def subscribe(self, event, callback):
6        if event not in self.events:
7            self.events[event] = []
8        self.events[event].append(callback)
9        return {'unsubscribe': lambda: self.events[event].remove(callback)}
10
11    def emit(self, event, *args):
12        if event not in self.events:
13            return []
14        return [callback(*args) for callback in self.events[event]]

ℹ

Complexity note: The time complexity is O(n) for emitting events because we only iterate through the list of callbacks once. The space complexity remains O(n) due to storing the callbacks.

1Understanding how to manage subscriptions and emissions efficiently is crucial.
2Recognizing that events can have multiple callbacks helps in designing the data structure.

Solutions and explanations are original Tejav content. Problem titles © LeetCode — use the LeetCode button above for the full problem statement.