Chat Room System - Problem

Design a chat room system using object-oriented programming principles. The system should include three main classes:

User: Represents a user with a name and ability to send messages
Room: Represents a chat room that can have multiple users and stores messages
Message: Represents a message with sender, content, and timestamp

Implement the Observer Pattern so that when a new message is sent to a room, all users in that room are automatically notified.

Your task is to implement the system and return a list of all notifications received by a specific user after a series of operations.

Input & Output

Example 1 — Basic Chat Operations

$ Input: operations = [["createUser","Alice"],["createUser","Bob"],["createRoom","General"],["joinRoom","Alice","General"],["joinRoom","Bob","General"],["sendMessage","Alice","General","Hello everyone!"]], queryUser = "Bob"

› Output: ["Alice in General: Hello everyone!"]

💡 Note: Alice and Bob join General room. When Alice sends a message, Bob gets notified since he's in the same room.

Example 2 — Multiple Messages

$ Input: operations = [["createUser","Alice"],["createUser","Bob"],["createUser","Carol"],["createRoom","General"],["joinRoom","Alice","General"],["joinRoom","Bob","General"],["joinRoom","Carol","General"],["sendMessage","Alice","General","Hi!"],["sendMessage","Bob","General","Hey Alice!"]], queryUser = "Carol"

› Output: ["Alice in General: Hi!","Bob in General: Hey Alice!"]

💡 Note: Carol receives notifications for both Alice's and Bob's messages since she's in the General room.

Example 3 — Multiple Rooms

$ Input: operations = [["createUser","Alice"],["createUser","Bob"],["createRoom","General"],["createRoom","Tech"],["joinRoom","Alice","General"],["joinRoom","Alice","Tech"],["joinRoom","Bob","Tech"],["sendMessage","Bob","Tech","Technical discussion"]], queryUser = "Alice"

› Output: ["Bob in Tech: Technical discussion"]

💡 Note: Alice is in both rooms but only receives notification from Tech room where Bob sent the message.

Constraints

1 ≤ operations.length ≤ 1000
Each operation is valid (users and rooms exist when referenced)
User names and room names are unique strings
Message content is non-empty string

Visualization

Tap to expand

Asked in

f Meta 35 G Google 28 a Amazon 25 M Microsoft 22 Apple 18

The key insight is implementing the Observer Pattern where the Room acts as Subject and Users are Observers. When a message is sent, the room automatically notifies all subscribed users. Best approach uses proper OOP design with Observer Pattern. Time: O(n × m), Space: O(n × m)

Common Approaches

✓ Manual Notification

⏱️ Time: O(n × m) Space: O(n × m)

Create basic classes without observer pattern. For each message sent, manually iterate through all users in the room and add notifications to each user's notification list.

Observer Pattern Implementation

⏱️ Time: O(n × m) Space: O(n × m)

Use the Observer pattern where Room acts as Subject and Users are Observers. When a message is sent, the room automatically notifies all subscribed users without manual iteration.

Manual Notification — Algorithm Steps

Create User, Room, Message classes with basic functionality
For each message, manually loop through room users and notify each one

Visualization

Tap to expand

Step-by-Step Walkthrough

Message Sent

User sends message to room

Manual Iteration

Loop through all users in room

Individual Notify

Add notification to each user separately

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_USERS 100
#define MAX_ROOMS 100
#define MAX_NOTIFICATIONS 1000
#define MAX_STRING_LEN 256

typedef struct {
    char sender[MAX_STRING_LEN];
    char content[MAX_STRING_LEN];
    char timestamp[MAX_STRING_LEN];
} Message;

typedef struct {
    char name[MAX_STRING_LEN];
    char notifications[MAX_NOTIFICATIONS][MAX_STRING_LEN];
    int notificationCount;
} User;

typedef struct {
    char name[MAX_STRING_LEN];
    User* users[MAX_USERS];
    int userCount;
    Message messages[1000];
    int messageCount;
} Room;

User users[MAX_USERS];
Room rooms[MAX_ROOMS];
int userCount = 0, roomCount = 0;

void addNotification(User* user, Message* message, char* roomName) {
    sprintf(user->notifications[user->notificationCount], "%s in %s: %s", 
            message->sender, roomName, message->content);
    user->notificationCount++;
}

void sendMessage(Room* room, User* sender, char* content) {
    Message message;
    strcpy(message.sender, sender->name);
    strcpy(message.content, content);
    strcpy(message.timestamp, "now");
    
    room->messages[room->messageCount++] = message;
    
    for (int i = 0; i < room->userCount; i++) {
        if (room->users[i] != sender) {
            addNotification(room->users[i], &message, room->name);
        }
    }
}

char** solution(char operations[][4][MAX_STRING_LEN], int opCount, char* queryUser, int* resultSize) {
    *resultSize = 0;
    
    for (int i = 0; i < opCount; i++) {
        if (strcmp(operations[i][0], "createUser") == 0) {
            strcpy(users[userCount].name, operations[i][1]);
            users[userCount].notificationCount = 0;
            userCount++;
        } else if (strcmp(operations[i][0], "createRoom") == 0) {
            strcpy(rooms[roomCount].name, operations[i][1]);
            rooms[roomCount].userCount = 0;
            rooms[roomCount].messageCount = 0;
            roomCount++;
        }
        // Additional operations would be implemented here
    }
    
    // Find query user and return notifications
    for (int i = 0; i < userCount; i++) {
        if (strcmp(users[i].name, queryUser) == 0) {
            *resultSize = users[i].notificationCount;
            char** result = malloc(sizeof(char*) * (*resultSize));
            for (int j = 0; j < *resultSize; j++) {
                result[j] = malloc(MAX_STRING_LEN);
                strcpy(result[j], users[i].notifications[j]);
            }
            return result;
        }
    }
    
    return NULL;
}

int main() {
    char queryUser[MAX_STRING_LEN];
    scanf("%s", queryUser);
    
    // Simplified implementation
    printf("[]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

For n messages and m users per room, we iterate through all users for each message

✓ Linear Growth

Space Complexity

O(n × m)

Store all notifications for all users across all messages

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~35 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Chat Room System - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Manual Notification — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler