Design a File Sharing System

Design a File Sharing System - Problem

Design a file-sharing system to share a very large file which consists of m small chunks with IDs from 1 to m.

When users join the system, the system should assign a unique ID to them. The unique ID should be used once for each user, but when a user leaves the system, the ID can be reused again.

Users can request a certain chunk of the file, the system should return a list of IDs of all the users who own this chunk. If the user receives a non-empty list of IDs, they receive the requested chunk successfully.

Implement the FileSharing class:

FileSharing(int m) Initializes the object with a file of m chunks.
int join(int[] ownedChunks): A new user joined the system owning some chunks of the file, the system should assign an id to the user which is the smallest positive integer not taken by any other user. Return the assigned id.
void leave(int userID): The user with userID will leave the system, you cannot take file chunks from them anymore.
int[] request(int userID, int chunkID): The user userID requested the file chunk with chunkID. Return a list of the IDs of all users that own this chunk sorted in ascending order.

Input & Output

Example 1 — Basic Operations

$ Input: FileSharing(4), join([1,2]), join([2,3]), request(1,2), leave(1), join([4])

› Output: [null,1,2,[1,2],null,1]

💡 Note: Initialize with 4 chunks. User 1 joins with chunks [1,2], gets ID 1. User 2 joins with chunks [2,3], gets ID 2. User 1 requests chunk 2, returns [1,2] (both users have it). User 1 leaves, ID 1 becomes available. New user joins with chunk [4], gets reused ID 1.

Example 2 — ID Reuse

$ Input: FileSharing(3), join([1]), join([2]), leave(1), join([3])

› Output: [null,1,2,null,1]

💡 Note: Two users join and get IDs 1,2. User 1 leaves, making ID 1 available. Next user gets the smallest available ID which is 1 (reused).

Example 3 — Empty Request

$ Input: FileSharing(2), join([1]), request(1,2)

› Output: [null,1,[]]

💡 Note: User 1 has chunk 1 but requests chunk 2. Since no one owns chunk 2, return empty list and user doesn't get the chunk.

Constraints

1 ≤ m ≤ 10⁵
0 ≤ ownedChunks.length ≤ m
1 ≤ ownedChunks[i] ≤ m
Values of ownedChunks are unique
1 ≤ chunkID ≤ m
userID is guaranteed to be a user in the system if you assign the ID to them
At most 10⁴ calls will be made to join, leave and request

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 D Dropbox 10

The key insight is to use hash maps for O(1) lookups and a min-heap for efficient ID reuse. Best approach uses bidirectional mappings (user→chunks and chunk→users) with priority queue for smallest available ID. Time: O(log k + c), Space: O(nm + mc).

Common Approaches

✓ Brute Force with Linear Search

⏱️ Time: O(n) Space: O(nm)

Use basic arrays to store which chunks each user owns. For join operations, iterate through all user IDs to find the smallest available one. For requests, iterate through all users to find chunk owners.

Hash Map with Min-Heap for ID Reuse

⏱️ Time: O(log k + c) Space: O(nm + mc)

Maintain hash maps for user-to-chunks and chunk-to-users mappings. Use a min-heap to efficiently track and reuse the smallest available user ID. This provides fast operations for all methods.

Brute Force with Linear Search — Algorithm Steps

Store user chunks in a simple array structure
For join: scan all IDs linearly to find smallest available
For request: scan all users to find who owns the chunk
For leave: mark user as inactive

Visualization

Tap to expand

Step-by-Step Walkthrough

Join User

Scan all IDs 1,2,3... to find smallest available

Store Chunks

Store user's owned chunks in simple array

Request Chunk

Scan all users to find who owns the requested chunk

Code -

solution.c — C

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

#define MAX_USERS 10001
#define MAX_AVAILABLE_IDS 10001

// Chunk node for linked list
typedef struct ChunkNode {
    int chunk_id;
    struct ChunkNode* next;
} ChunkNode;

// User entry
typedef struct UserEntry {
    int user_id;
    ChunkNode* chunks;
    struct UserEntry* next;
} UserEntry;

typedef struct {
    int m;
    UserEntry* users;  // linked list of users
    int next_id;
    int available_ids[MAX_AVAILABLE_IDS];
    int available_count;
} FileSharing;

int compare_ints(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

FileSharing* fileSharingCreate(int m) {
    FileSharing* obj = (FileSharing*)malloc(sizeof(FileSharing));
    obj->m = m;
    obj->next_id = 1;
    obj->available_count = 0;
    obj->users = NULL;
    
    return obj;
}

UserEntry* findUser(FileSharing* obj, int user_id) {
    UserEntry* current = obj->users;
    while (current != NULL) {
        if (current->user_id == user_id) {
            return current;
        }
        current = current->next;
    }
    return NULL;
}

void addChunkToUser(UserEntry* user, int chunk_id) {
    // Check if chunk already exists
    ChunkNode* current = user->chunks;
    while (current != NULL) {
        if (current->chunk_id == chunk_id) {
            return; // already exists
        }
        current = current->next;
    }
    
    // Add new chunk
    ChunkNode* new_chunk = (ChunkNode*)malloc(sizeof(ChunkNode));
    new_chunk->chunk_id = chunk_id;
    new_chunk->next = user->chunks;
    user->chunks = new_chunk;
}

bool userHasChunk(UserEntry* user, int chunk_id) {
    ChunkNode* current = user->chunks;
    while (current != NULL) {
        if (current->chunk_id == chunk_id) {
            return true;
        }
        current = current->next;
    }
    return false;
}

int fileSharingJoin(FileSharing* obj, int* ownedChunks, int ownedChunksSize) {
    int user_id;
    
    if (obj->available_count > 0) {
        // Sort available IDs to get the smallest
        qsort(obj->available_ids, obj->available_count, sizeof(int), compare_ints);
        user_id = obj->available_ids[0];
        
        // Remove the used ID from available_ids
        for (int i = 0; i < obj->available_count - 1; i++) {
            obj->available_ids[i] = obj->available_ids[i + 1];
        }
        obj->available_count--;
    } else {
        user_id = obj->next_id;
        obj->next_id++;
    }
    
    // Create new user entry
    UserEntry* new_user = (UserEntry*)malloc(sizeof(UserEntry));
    new_user->user_id = user_id;
    new_user->chunks = NULL;
    new_user->next = obj->users;
    obj->users = new_user;
    
    // Add owned chunks
    for (int i = 0; i < ownedChunksSize; i++) {
        if (ownedChunks[i] >= 1 && ownedChunks[i] <= obj->m) {
            addChunkToUser(new_user, ownedChunks[i]);
        }
    }
    
    return user_id;
}

void freeChunks(ChunkNode* chunks) {
    while (chunks != NULL) {
        ChunkNode* temp = chunks;
        chunks = chunks->next;
        free(temp);
    }
}

void fileSharingLeave(FileSharing* obj, int userID) {
    UserEntry* prev = NULL;
    UserEntry* current = obj->users;
    
    while (current != NULL) {
        if (current->user_id == userID) {
            // Remove from linked list
            if (prev == NULL) {
                obj->users = current->next;
            } else {
                prev->next = current->next;
            }
            
            // Free chunks and user entry
            freeChunks(current->chunks);
            free(current);
            
            // Add userID to available IDs
            obj->available_ids[obj->available_count] = userID;
            obj->available_count++;
            
            return;
        }
        prev = current;
        current = current->next;
    }
}

static int owners[MAX_USERS];

int* fileSharingRequest(FileSharing* obj, int userID, int chunkID, int* returnSize) {
    int owner_count = 0;
    
    // Find all owners of this chunk
    UserEntry* current = obj->users;
    while (current != NULL) {
        if (chunkID >= 1 && chunkID <= obj->m && userHasChunk(current, chunkID)) {
            owners[owner_count++] = current->user_id;
        }
        current = current->next;
    }
    
    // If owners exist, add chunk to requesting user
    if (owner_count > 0) {
        UserEntry* requesting_user = findUser(obj, userID);
        if (requesting_user != NULL && chunkID >= 1 && chunkID <= obj->m) {
            addChunkToUser(requesting_user, chunkID);
        }
    }
    
    // Sort owners
    qsort(owners, owner_count, sizeof(int), compare_ints);
    
    *returnSize = owner_count;
    return owners;
}

void fileSharingFree(FileSharing* obj) {
    UserEntry* current = obj->users;
    while (current != NULL) {
        UserEntry* temp = current;
        current = current->next;
        freeChunks(temp->chunks);
        free(temp);
    }
    free(obj);
}

int main() {
    int m;
    if (scanf("%d", &m) != 1) {
        return 1;
    }
    
    // Create FileSharing instance
    FileSharing* fs = fileSharingCreate(m);
    
    // Output null as expected
    printf("null\n");
    
    // Clean up
    fileSharingFree(fs);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each join and request operation requires linear scan through all users

✓ Linear Growth

Space Complexity

O(nm)

Store chunks for each user, worst case all users own all chunks

⚡ Linearithmic Space

18.2K Views

Medium Frequency

~35 min Avg. Time

456 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with Linear Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler