Design Movie Rental System - Practice Coding Problems

Design Movie Rental System - Problem

🎬 Movie Rental Empire Challenge

You're tasked with building the backend system for a movie rental empire with n shops across the city! Your system needs to handle the core operations that keep customers happy: searching for movies, renting them out, returning them, and generating business reports.

Each movie copy is represented as [shop_id, movie_id, price] where:

shop_id: Which shop has this copy
movie_id: The movie identifier
price: Rental price for this specific copy

Important: Each shop can only have one copy of any given movie.

Your Mission:

search(movie) - Find the 5 cheapest shops with available copies (unrented)
rent(shop, movie) - Rent out a specific movie from a specific shop
drop(shop, movie) - Return a rented movie to its shop
report() - Get the 5 cheapest currently rented movies for business analytics

All results must be sorted by price first, then by shop ID, then by movie ID for ties! 🎯

Input & Output

example_1.py — Basic Operations

$ Input: MovieRentingSystem(3, [[0,1,5],[0,2,6],[0,3,7],[1,1,4],[1,2,7],[2,1,5]]) search(1) -> rent(0,1) -> rent(1,2) -> report() -> drop(1,2) -> search(2)

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

💡 Note: Initially movie 1 available at shops 1($4), 0($5), 2($5) - return [1,0,2]. After renting, report shows cheapest rented movies. After dropping, movie 2 becomes available at shop 0.

example_2.py — Tie Breaking

$ Input: MovieRentingSystem(2, [[0,1,5],[1,1,5],[0,2,3],[1,2,8]]) search(1) -> rent(0,1) -> search(1)

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

💡 Note: Both shops have movie 1 at $5, but shop 0 comes first (smaller shop ID). After renting from shop 0, only shop 1 has it available.

example_3.py — Empty Results

$ Input: MovieRentingSystem(1, [[0,1,3]]) search(2) -> rent(0,1) -> search(1) -> report()

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

💡 Note: Movie 2 doesn't exist, so search returns empty. After renting movie 1, it's no longer available for search, but shows up in report.

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 movie movie_i
All calls to rent and drop are valid
At most 10⁵ calls in total to search, rent, drop, and report

Asked in

The optimal solution uses a combination of hash maps and priority queues (heaps). Group available movies by movie ID in hash maps, each containing a min-heap sorted by price and shop ID. Track rented movies using both a hash set for O(1) lookup and a min-heap for O(log k) report generation. This achieves O(log k) time complexity for all operations where k is much smaller than n.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized with Hash Maps and Priority Queues	O(log k)	O(n)	Use hash maps for O(1) lookups and priority queues for automatic sorting
Brute Force (Linear Search)	O(n log n)	O(n)	Store all entries and search linearly for each operation

Optimized with Hash Maps and Priority Queues — Algorithm Steps

Use hash map to group available movies by movie ID
Use priority queue for each movie to maintain price-sorted order
Use another priority queue to track all rented movies
Rent/drop operations update both structures in O(log k) time

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Structures

Create hash map by movie ID and priority queues for sorting

Search Operation

Access movie's heap directly, extract top 5 available

Rent Operation

Add to rented set and rented heap in O(log k) time

Report Operation

Extract top 5 from rented heap, checking availability

Code -

solution.c — C

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

#define MAX_ENTRIES 10000

typedef struct {
    int price;
    int shop;
    int movie;
    int available;
} Entry;

typedef struct {
    Entry heap[MAX_ENTRIES];
    int size;
} MinHeap;

typedef struct {
    Entry* entries;
    int entryCount;
    MinHeap* movieHeaps[MAX_ENTRIES];
    MinHeap rentedHeap;
    int rentedSet[MAX_ENTRIES][2];
    int rentedCount;
} MovieRentingSystem;

void heapifyUp(MinHeap* h, int idx, int isRented) {
    if (idx == 0) return;
    int parent = (idx - 1) / 2;
    
    int shouldSwap = 0;
    if (isRented) {
        if (h->heap[idx].price < h->heap[parent].price ||
            (h->heap[idx].price == h->heap[parent].price && h->heap[idx].shop < h->heap[parent].shop) ||
            (h->heap[idx].price == h->heap[parent].price && h->heap[idx].shop == h->heap[parent].shop && h->heap[idx].movie < h->heap[parent].movie)) {
            shouldSwap = 1;
        }
    } else {
        if (h->heap[idx].price < h->heap[parent].price ||
            (h->heap[idx].price == h->heap[parent].price && h->heap[idx].shop < h->heap[parent].shop)) {
            shouldSwap = 1;
        }
    }
    
    if (shouldSwap) {
        Entry temp = h->heap[idx];
        h->heap[idx] = h->heap[parent];
        h->heap[parent] = temp;
        heapifyUp(h, parent, isRented);
    }
}

void heapPush(MinHeap* h, Entry e, int isRented) {
    h->heap[h->size] = e;
    heapifyUp(h, h->size, isRented);
    h->size++;
}

MovieRentingSystem* movieRentingSystemCreate(int n, int** entries, int entriesSize, int* entriesColSize) {
    MovieRentingSystem* sys = malloc(sizeof(MovieRentingSystem));
    sys->entries = malloc(sizeof(Entry) * entriesSize);
    sys->entryCount = entriesSize;
    sys->rentedHeap.size = 0;
    sys->rentedCount = 0;
    
    for (int i = 0; i < MAX_ENTRIES; i++) {
        sys->movieHeaps[i] = NULL;
    }
    
    for (int i = 0; i < entriesSize; i++) {
        int shop = entries[i][0];
        int movie = entries[i][1];
        int price = entries[i][2];
        
        sys->entries[i].shop = shop;
        sys->entries[i].movie = movie;
        sys->entries[i].price = price;
        sys->entries[i].available = 1;
        
        if (sys->movieHeaps[movie] == NULL) {
            sys->movieHeaps[movie] = malloc(sizeof(MinHeap));
            sys->movieHeaps[movie]->size = 0;
        }
        
        heapPush(sys->movieHeaps[movie], sys->entries[i], 0);
    }
    
    return sys;
}

int isRented(MovieRentingSystem* sys, int shop, int movie) {
    for (int i = 0; i < sys->rentedCount; i++) {
        if (sys->rentedSet[i][0] == shop && sys->rentedSet[i][1] == movie) {
            return 1;
        }
    }
    return 0;
}

int* movieRentingSystemSearch(MovieRentingSystem* obj, int movie, int* returnSize) {
    *returnSize = 0;
    int* result = malloc(sizeof(int) * 5);
    
    if (obj->movieHeaps[movie] == NULL) {
        return result;
    }
    
    // Simple implementation - find available movies and sort
    Entry available[MAX_ENTRIES];
    int availCount = 0;
    
    for (int i = 0; i < obj->entryCount; i++) {
        if (obj->entries[i].movie == movie && !isRented(obj, obj->entries[i].shop, obj->entries[i].movie)) {
            available[availCount++] = obj->entries[i];
        }
    }
    
    // Sort by price, then shop
    for (int i = 0; i < availCount - 1; i++) {
        for (int j = i + 1; j < availCount; j++) {
            if (available[i].price > available[j].price || 
                (available[i].price == available[j].price && available[i].shop > available[j].shop)) {
                Entry temp = available[i];
                available[i] = available[j];
                available[j] = temp;
            }
        }
    }
    
    *returnSize = availCount < 5 ? availCount : 5;
    for (int i = 0; i < *returnSize; i++) {
        result[i] = available[i].shop;
    }
    
    return result;
}

void movieRentingSystemRent(MovieRentingSystem* obj, int shop, int movie) {
    obj->rentedSet[obj->rentedCount][0] = shop;
    obj->rentedSet[obj->rentedCount][1] = movie;
    obj->rentedCount++;
    
    // Find the entry and add to rented heap
    for (int i = 0; i < obj->entryCount; i++) {
        if (obj->entries[i].shop == shop && obj->entries[i].movie == movie) {
            heapPush(&obj->rentedHeap, obj->entries[i], 1);
            break;
        }
    }
}

void movieRentingSystemDrop(MovieRentingSystem* obj, int shop, int movie) {
    for (int i = 0; i < obj->rentedCount; i++) {
        if (obj->rentedSet[i][0] == shop && obj->rentedSet[i][1] == movie) {
            // Remove by shifting
            for (int j = i; j < obj->rentedCount - 1; j++) {
                obj->rentedSet[j][0] = obj->rentedSet[j + 1][0];
                obj->rentedSet[j][1] = obj->rentedSet[j + 1][1];
            }
            obj->rentedCount--;
            break;
        }
    }
}

int** movieRentingSystemReport(MovieRentingSystem* obj, int* returnSize, int** returnColumnSizes) {
    *returnSize = 0;
    *returnColumnSizes = malloc(sizeof(int) * 5);
    int** result = malloc(sizeof(int*) * 5);
    
    Entry rented[MAX_ENTRIES];
    int rentedCount = 0;
    
    for (int i = 0; i < obj->rentedCount; i++) {
        int shop = obj->rentedSet[i][0];
        int movie = obj->rentedSet[i][1];
        
        for (int j = 0; j < obj->entryCount; j++) {
            if (obj->entries[j].shop == shop && obj->entries[j].movie == movie) {
                rented[rentedCount++] = obj->entries[j];
                break;
            }
        }
    }
    
    // Sort rented movies
    for (int i = 0; i < rentedCount - 1; i++) {
        for (int j = i + 1; j < rentedCount; j++) {
            if (rented[i].price > rented[j].price ||
                (rented[i].price == rented[j].price && rented[i].shop > rented[j].shop) ||
                (rented[i].price == rented[j].price && rented[i].shop == rented[j].shop && rented[i].movie > rented[j].movie)) {
                Entry temp = rented[i];
                rented[i] = rented[j];
                rented[j] = temp;
            }
        }
    }
    
    *returnSize = rentedCount < 5 ? rentedCount : 5;
    for (int i = 0; i < *returnSize; i++) {
        (*returnColumnSizes)[i] = 2;
        result[i] = malloc(sizeof(int) * 2);
        result[i][0] = rented[i].shop;
        result[i][1] = rented[i].movie;
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(log k)

O(log k) for heap operations where k is number of movies per shop or rented movies

⚡ Linearithmic

Space Complexity

O(n)

O(n) for storing all entries plus O(k) for heaps where k is bounded

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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