Design Movie Rental System

Design Movie Rental System - Problem

You have a movie renting company consisting of n shops. You want to implement a renting system that supports searching for, booking, and returning movies. The system should also support generating a report of the currently rented movies.

Each movie is given as a 2D integer array entries where entries[i] = [shop_i, movie_i, price_i] indicates that there is a copy of movie movie_i at shop shop_i with a rental price of price_i. Each shop carries at most one copy of a movie movie_i.

The system should support the following functions:

Search: Finds the cheapest 5 shops that have an unrented copy of a given movie. The shops should be sorted by price in ascending order, and in case of a tie, the one with the smaller shop_i should appear first.
Rent: Rents an unrented copy of a given movie from a given shop.
Drop: Drops off a previously rented copy of a given movie at a given shop.
Report: Returns the cheapest 5 rented movies as a 2D list where each entry is [shop, movie], sorted by price, then by shop, then by movie.

Input & Output

Example 1 — Basic Movie Rental Operations

$ Input: n = 3, entries = [[0,1,5],[0,2,6],[0,3,7],[1,1,4],[1,2,7],[2,1,5]], operations = [["search",1],["rent",1,1],["search",2],["report"]]

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

💡 Note: Search movie 1: shops [1,0,2] by price [4,5,5]. Rent from shop 1. Search movie 2: shop [0]. Report: rented movie from shop 1 is [1,1].

Example 2 — Multiple Rent and Drop Operations

$ Input: n = 2, entries = [[0,1,1],[0,2,2],[1,1,3]], operations = [["search",1],["rent",0,1],["drop",0,1],["search",1]]

› Output: [[0,1],[],[],[0,1]]

💡 Note: Initially movie 1 available at shops [0,1] with prices [1,3]. After rent and drop, same availability restored.

Example 3 — Report with Multiple Movies

$ Input: n = 2, entries = [[0,1,2],[1,1,3],[0,2,1]], operations = [["rent",0,1],["rent",1,1],["rent",0,2],["report"]]

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

💡 Note: After renting 3 movies, report shows them sorted by price: $1 movie 2 from shop 0, $2 movie 1 from shop 0, $3 movie 1 from shop 1.

Constraints

1 ≤ n ≤ 3 × 10⁴
1 ≤ entries.length ≤ 10⁵
0 ≤ shop_i < n
1 ≤ movie_i, price_i ≤ 10⁴
Each shop carries at most one copy of a movie
1 ≤ operations.length ≤ 10⁵

Visualization

Tap to expand

Asked in

N Netflix 15 a Amazon 12 G Google 8 M Microsoft 6

The key insight is to use hash maps to group movies by ID and heaps to maintain sorted order by price. This enables O(log n) search and report operations instead of O(n) linear scans. Best approach uses hash maps with priority queues for efficient movie rental system operations. Time: O(log n), Space: O(n)

Common Approaches

✓ Brute Force with Lists

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

Keep all movie information in simple lists. For each search operation, scan through all entries to find available movies. For reports, scan through all rented movies.

Hash Maps with Heaps

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

Store movies grouped by movie ID in hash maps. Use heaps (priority queues) to efficiently find the cheapest available movies and track rented movies in sorted order.

Brute Force with Lists — Algorithm Steps

Store all movies in a single list
For search: scan all movies, filter available ones, sort by price
For rent/drop: find and update movie status
For report: scan all rented movies and sort

Visualization

Tap to expand

Step-by-Step Walkthrough

Store Entries

Keep all movies in a single list with availability status

Linear Search

For each operation, scan through entire list

Sort Results

Sort found movies by price and shop ID

Code -

solution.c — C

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

#define MAX_ENTRIES 100000
#define MAX_INPUT 1000000

typedef struct {
    int shop, movie, price, rented;
} Entry;

typedef struct {
    Entry entries[MAX_ENTRIES];
    int count;
} MovieRentingSystem;

void initSystem(MovieRentingSystem* system, int entryCount) {
    system->count = entryCount;
    for (int i = 0; i < entryCount; i++) {
        system->entries[i].rented = 0;
    }
}

int compareAvailable(const void* a, const void* b) {
    int* x = (int*)a;
    int* y = (int*)b;
    if (x[0] != y[0]) return x[0] - y[0];
    return x[1] - y[1];
}

int search(MovieRentingSystem* system, int movie, int result[]) {
    static int available[MAX_ENTRIES][2];
    int count = 0;
    
    for (int i = 0; i < system->count; i++) {
        if (system->entries[i].movie == movie && !system->entries[i].rented) {
            available[count][0] = system->entries[i].price;
            available[count][1] = system->entries[i].shop;
            count++;
        }
    }
    
    qsort(available, count, sizeof(available[0]), compareAvailable);
    
    int returnCount = count < 5 ? count : 5;
    for (int i = 0; i < returnCount; i++) {
        result[i] = available[i][1];
    }
    return returnCount;
}

void rent(MovieRentingSystem* system, int shop, int movie) {
    for (int i = 0; i < system->count; i++) {
        if (system->entries[i].shop == shop && system->entries[i].movie == movie) {
            system->entries[i].rented = 1;
            break;
        }
    }
}

void drop(MovieRentingSystem* system, int shop, int movie) {
    for (int i = 0; i < system->count; i++) {
        if (system->entries[i].shop == shop && system->entries[i].movie == movie) {
            system->entries[i].rented = 0;
            break;
        }
    }
}

int compareRented(const void* a, const void* b) {
    int* x = (int*)a;
    int* y = (int*)b;
    if (x[0] != y[0]) return x[0] - y[0];
    if (x[1] != y[1]) return x[1] - y[1];
    return x[2] - y[2];
}

int report(MovieRentingSystem* system, int result[][2]) {
    static int rented[MAX_ENTRIES][3];
    int count = 0;
    
    for (int i = 0; i < system->count; i++) {
        if (system->entries[i].rented) {
            rented[count][0] = system->entries[i].price;
            rented[count][1] = system->entries[i].shop;
            rented[count][2] = system->entries[i].movie;
            count++;
        }
    }
    
    qsort(rented, count, sizeof(rented[0]), compareRented);
    
    int returnCount = count < 5 ? count : 5;
    for (int i = 0; i < returnCount; i++) {
        result[i][0] = rented[i][1];
        result[i][1] = rented[i][2];
    }
    return returnCount;
}

void printArray(int arr[], int size) {
    printf("[");
    for (int i = 0; i < size; i++) {
        if (i > 0) printf(",");
        printf("%d", arr[i]);
    }
    printf("]");
}

void printArray2D(int arr[][2], int size) {
    printf("[");
    for (int i = 0; i < size; i++) {
        if (i > 0) printf(",");
        printf("[%d,%d]", arr[i][0], arr[i][1]);
    }
    printf("]");
}

int parseInt(char* str, char** endptr) {
    int num = 0;
    int sign = 1;
    char* pos = str;
    
    if (*pos == '-') {
        sign = -1;
        pos++;
    }
    while (*pos >= '0' && *pos <= '9') {
        num = num * 10 + (*pos - '0');
        pos++;
    }
    if (endptr) *endptr = pos;
    return num * sign;
}

void parseEntries(char* str, MovieRentingSystem* system) {
    int pos = 0;
    int count = 0;
    
    // Skip initial '['
    while (str[pos] != '[') pos++;
    pos++;
    
    while (str[pos] != '\0' && count < MAX_ENTRIES) {
        if (str[pos] == '[') {
            pos++;
            char* endptr;
            system->entries[count].shop = parseInt(str + pos, &endptr);
            pos = endptr - str;
            while (str[pos] == ',' || str[pos] == ' ') pos++;
            system->entries[count].movie = parseInt(str + pos, &endptr);
            pos = endptr - str;
            while (str[pos] == ',' || str[pos] == ' ') pos++;
            system->entries[count].price = parseInt(str + pos, &endptr);
            pos = endptr - str;
            system->entries[count].rented = 0;
            count++;
            
            while (str[pos] != ']' && str[pos] != '\0') pos++;
            if (str[pos] == ']') pos++;
        } else {
            pos++;
        }
    }
    system->count = count;
}

int main() {
    static char buffer[MAX_INPUT];
    static MovieRentingSystem system;
    static int searchResult[5];
    static int reportResult[5][2];
    
    int n;
    scanf("%d\n", &n);
    
    fgets(buffer, MAX_INPUT, stdin);
    buffer[strcspn(buffer, "\n")] = 0;
    parseEntries(buffer, &system);
    
    fgets(buffer, MAX_INPUT, stdin);
    buffer[strcspn(buffer, "\n")] = 0;
    
    printf("[");
    int first = 1;
    
    char* pos = buffer + 1; // Skip initial '['
    while (*pos != '\0' && *pos != ']') {
        if (*pos == '[') {
            if (!first) printf(",");
            first = 0;
            
            pos++;
            if (*pos == '"') {
                pos++;
                if (strncmp(pos, "search", 6) == 0) {
                    pos += 6;
                    while (*pos != ',' && *pos != '\0') pos++;
                    pos++;
                    char* endptr;
                    int movie = parseInt(pos, &endptr);
                    pos = endptr;
                    int count = search(&system, movie, searchResult);
                    printArray(searchResult, count);
                } else if (strncmp(pos, "rent", 4) == 0) {
                    pos += 4;
                    while (*pos != ',' && *pos != '\0') pos++;
                    pos++;
                    char* endptr;
                    int shop = parseInt(pos, &endptr);
                    pos = endptr;
                    while (*pos != ',' && *pos != '\0') pos++;
                    pos++;
                    int movie = parseInt(pos, &endptr);
                    pos = endptr;
                    rent(&system, shop, movie);
                    printf("[]");
                } else if (strncmp(pos, "drop", 4) == 0) {
                    pos += 4;
                    while (*pos != ',' && *pos != '\0') pos++;
                    pos++;
                    char* endptr;
                    int shop = parseInt(pos, &endptr);
                    pos = endptr;
                    while (*pos != ',' && *pos != '\0') pos++;
                    pos++;
                    int movie = parseInt(pos, &endptr);
                    pos = endptr;
                    drop(&system, shop, movie);
                    printf("[]");
                } else if (strncmp(pos, "report", 6) == 0) {
                    int count = report(&system, reportResult);
                    printArray2D(reportResult, count);
                    pos += 6;
                }
            }
            
            while (*pos != ']' && *pos != '\0') pos++;
            if (*pos == ']') pos++;
        } else {
            pos++;
        }
    }
    
    printf("]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each operation scans through all n movie entries

✓ Linear Growth

Space Complexity

O(n)

Store all movie entries in memory

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~45 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with Lists — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler