Notification to all parties in LLD - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to send a notification to all users.

LLD

for user in users:
    user.[1](message)

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

Aalert

Bnotify

Csend

Dmessage

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'send' which is too generic and may not exist in the user object.

Using 'alert' which is not the method defined for notifications.

The method notify is used to send notifications to users in this system.

2fill in blank

medium

Complete the code to add a notification to the queue for asynchronous processing.

LLD

notification_queue.[1](notification)

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

Aremove

Bpop

Cdequeue

Denqueue

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'pop' which removes an item instead of adding.

Using 'dequeue' which removes an item from the queue.

The enqueue method adds an item to the queue for later processing.

3fill in blank

hard

Fix the error in the notification dispatch function to correctly handle failures.

LLD

try:
    dispatcher.[1](notification)
except Exception as e:
    logger.error(str(e))

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

Adispatch

Bsend

Cnotify

Dsend_notification

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'send' which may not exist in dispatcher.

Using 'notify' which is a user method, not dispatcher.

The correct method to send notifications in the dispatcher is dispatch.

4fill in blank

hard

Fill both blanks to filter notifications and send only urgent ones.

LLD

urgent_notifications = [n for n in notifications if n.[1] [2] 'urgent']
for notification in urgent_notifications:
    notification.send()

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

Apriority

B==

C!=

Dstatus

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'status' instead of 'priority' for filtering.

Using '!=' which filters out urgent notifications.

We filter notifications where the priority is equal (==) to 'urgent'.

5fill in blank

hard

Fill all three blanks to create a dictionary of user IDs and their last notification timestamps, filtering only active users.

LLD

last_notifications = {user.[1]: user.notifications[-1].[2] for user in users if user.[3]

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

Aid

Btimestamp

Cis_active

Dname

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'name' instead of 'id' as dictionary key.

Using 'status' or other attributes instead of 'is_active' for filtering.

We use id as the key, timestamp of the last notification as the value, and filter users where is_active is true.

Practice

1.

What is the main purpose of a notification system that sends messages to all parties?

easy

A. To quickly share important messages with everyone involved

B. To store large amounts of data securely

C. To perform complex calculations on user data

D. To create user profiles and preferences

Solution

1. Step 1: Understand the role of notifications

   Notifications are designed to deliver messages to users or parties quickly and efficiently.

2. Step 2: Identify the main goal

   The main goal is to share important information with all involved parties without delay.

3. Final Answer:

   To quickly share important messages with everyone involved -> Option A

4. Quick Check:

   Notification purpose = quick message sharing [OK]

Hint: Notifications = fast message delivery to all involved [OK]

Common Mistakes:

• Confusing notifications with data storage
• Thinking notifications perform data processing
• Assuming notifications create user profiles

2.

Which of the following is the correct way to represent a notification service that sends messages to all parties in pseudocode?

function notifyAll(parties, message) {
  for (let i = 0; i < parties.length; i++) {
    parties[i].send(message);
  }
}

easy

A. Call send(message) once without looping

B. Send message only to the first party

C. Loop through parties and call send(message) on each

D. Loop through parties but do not send any message

Solution

1. Step 1: Analyze the pseudocode loop

   The code loops through each party in the parties list using a for loop.

2. Step 2: Check the send method call

   Inside the loop, it calls send(message) on each party, ensuring all get notified.

3. Final Answer:

   Loop through parties and call send(message) on each -> Option C

4. Quick Check:

   Loop + send call = notify all [OK]

Hint: Loop through all parties to send message [OK]

Common Mistakes:

• Sending message only once
• Not looping through all parties
• Calling send outside the loop

3.

Consider this code snippet for notifying parties:

parties = ["Alice", "Bob", "Charlie"]
function notifyAll(parties, message) {
  let notified = []
  for (const person of parties) {
    notified.push(person + ": " + message)
  }
  return notified
}

console.log(notifyAll(parties, "Meeting at 5 PM"))

What will be the output?

medium

A. ["Alice: Meeting at 5 PM", "Bob: Meeting at 5 PM", "Charlie: Meeting at 5 PM"]

B. ["Meeting at 5 PM", "Meeting at 5 PM", "Meeting at 5 PM"]

C. ["Alice", "Bob", "Charlie"]

D. Error: notifyAll is not defined

Solution

1. Step 1: Understand the loop behavior

   The function loops over each person in parties and creates a string combining their name and the message.

2. Step 2: Check the returned list

   The notified list contains strings like "Alice: Meeting at 5 PM" for each party.

3. Final Answer:

   ["Alice: Meeting at 5 PM", "Bob: Meeting at 5 PM", "Charlie: Meeting at 5 PM"] -> Option A

4. Quick Check:

   Loop + string concat = list of personalized messages [OK]

Hint: Each party gets message with their name prefixed [OK]

Common Mistakes:

• Returning only messages without names
• Returning original party list
• Assuming function is undefined

4.

Identify the bug in this notification function and select the fix:

function notifyAll(parties, message) {
  for (let i = 0; i < parties.length; i++) {
    parties.send(message)
  }
}

medium

A. Remove the loop and call parties.send(message) once

B. Add a return statement inside the loop

C. Change i < parties.length to i <= parties.length

D. Change parties.send(message) to parties[i].send(message)

Solution

1. Step 1: Identify incorrect method call

   The code calls send on the entire parties array instead of individual party objects.

2. Step 2: Fix by indexing the array

   Use parties[i].send(message) to call send on each party in the loop.

3. Final Answer:

   Change parties.send(message) to parties[i].send(message) -> Option D

4. Quick Check:

   Call send on each party object [OK]

Hint: Call send on parties[i], not parties array [OK]

Common Mistakes:

• Calling send on the whole array
• Using wrong loop condition
• Adding unnecessary return inside loop

5.

You are designing a notification system to alert all parties involved in a project. Which design choice best ensures scalability and reliability?

• A. Use a single server to send notifications sequentially to all parties.
• B. Send notifications only to a random subset of parties to reduce load.
• C. Store all notifications in a database and send them manually when needed.
• D. Use a message queue to distribute notification tasks to multiple worker servers.

hard

A. Single server sending sequentially

B. Message queue with multiple workers

C. Store notifications and send manually

D. Send to random subset to reduce load

Solution

1. Step 1: Evaluate single server approach

   Sending sequentially from one server limits scalability and can cause delays or failures.

2. Step 2: Consider message queue with workers

   Using a message queue allows distributing notification tasks to multiple workers, improving scalability and reliability.

3. Step 3: Assess other options

   Storing notifications for manual sending is slow; sending to random subset misses parties.

4. Final Answer:

   Message queue with multiple workers -> Option B

5. Quick Check:

   Queue + workers = scalable, reliable notifications [OK]

Hint: Use queues and workers for scalable notifications [OK]

Common Mistakes:

• Relying on single server for all notifications
• Sending notifications manually
• Skipping parties to reduce load