Library Management System - Problem

Design a comprehensive Library Management System using object-oriented programming principles. The system should support core library operations including book borrowing, returning, searching, and overdue tracking.

Requirements:

Create Book class with properties: id, title, author, isbn, isAvailable
Create Member class with properties: memberId, name, borrowedBooks, maxBooks (default 5)
Create Library class that manages books and members
Implement operations: addBook, addMember, borrowBook, returnBook, searchBooks, getOverdueBooks

The system should handle edge cases like borrowing unavailable books, exceeding member limits, and tracking overdue items (books borrowed for more than 14 days).

Input & Output

Example 1 — Basic Library Operations

$ Input: operations = [["addBook", 1, "1984", "George Orwell", "978-0-452-28423-4"], ["addMember", 101, "Alice Smith", 3], ["borrowBook", 101, 1]]

› Output: ["Book 1984 added", "Member Alice Smith added", "Book 1984 borrowed by Alice Smith"]

💡 Note: First add a book with ID 1, then add member Alice with limit 3 books, then Alice successfully borrows the book.

Example 2 — Search and Limits

$ Input: operations = [["addBook", 2, "Animal Farm", "George Orwell", "978-0-452-28424-1"], ["addMember", 102, "Bob Jones", 1], ["borrowBook", 102, 2], ["borrowBook", 102, 2], ["searchBooks", "Orwell"]]

› Output: ["Book Animal Farm added", "Member Bob Jones added", "Book Animal Farm borrowed by Bob Jones", "Member has reached borrowing limit", ["Animal Farm by George Orwell - Borrowed"]]

💡 Note: Add book and member with 1-book limit. Bob borrows successfully, then fails due to limit. Search finds Orwell's book showing Borrowed status.

Example 3 — Return Book

$ Input: operations = [["addBook", 3, "Brave New World", "Aldous Huxley", "978-0-06-085052-4"], ["addMember", 103, "Carol White"], ["borrowBook", 103, 3], ["returnBook", 103, 3], ["searchBooks", "Brave"]]

› Output: ["Book Brave New World added", "Member Carol White added", "Book Brave New World borrowed by Carol White", "Book Brave New World returned", ["Brave New World by Aldous Huxley - Available"]]

💡 Note: Complete borrow-return cycle. Carol borrows and returns the book. Search confirms book is Available again.

Constraints

1 ≤ operations.length ≤ 1000
Each operation has valid parameters
Book IDs and Member IDs are unique positive integers
Member names and book titles are non-empty strings
maxBooks is between 1 and 10 if specified

Visualization

Tap to expand

Asked in

a Amazon 25 G Google 18 M Microsoft 15 A Apple 12

The key insight is to use proper object-oriented design with separate classes for Books, Members, and Library operations. The hash map approach provides O(1) lookup times for efficient library management. Time: O(1) for most operations, Space: O(n) for storing books and members.

Common Approaches

✓ Hash Map Based Lookup

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

Replace linear array searches with hash maps that provide constant-time lookup by ID. Store books and members in maps indexed by their IDs for instant access during operations.

Single List with Linear Search

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

Use simple arrays to store books and members. For each operation, iterate through arrays to find items, check conditions, and update states. All searches and lookups require scanning entire arrays.

Hash Map Based Lookup — Algorithm Steps

Create hash maps for books (bookId -> Book) and members (memberId -> Member)
For operations, use direct map lookup instead of linear search
Update relationships and states using map references
Maintain the same data integrity with faster access

Visualization

Tap to expand

Step-by-Step Walkthrough

Hash Maps

Store books and members in hash maps indexed by ID

O(1) Lookup

Direct access to any book or member by ID

Fast Updates

Instant retrieval and modification of data

Code -

solution.c — C

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

#define MAX_BOOKS 1000
#define MAX_MEMBERS 1000
#define MAX_TITLE_LEN 100
#define MAX_NAME_LEN 50
#define HASH_SIZE 1009

typedef struct Book {
    int id;
    char title[MAX_TITLE_LEN];
    char author[MAX_TITLE_LEN];
    char isbn[50];
    int isAvailable;
    time_t borrowedDate;
    int borrowedBy;
    struct Book* next; // for hash collision chaining
} Book;

typedef struct Member {
    int memberId;
    char name[MAX_NAME_LEN];
    int borrowedBooks[10];
    int borrowedCount;
    int maxBooks;
    struct Member* next; // for hash collision chaining
} Member;

typedef struct {
    Book* bookHashTable[HASH_SIZE];
    Member* memberHashTable[HASH_SIZE];
} Library;

int hash(int key) {
    return key % HASH_SIZE;
}

void initLibrary(Library* lib) {
    for (int i = 0; i < HASH_SIZE; i++) {
        lib->bookHashTable[i] = NULL;
        lib->memberHashTable[i] = NULL;
    }
}

Book* findBook(Library* lib, int bookId) {
    int index = hash(bookId);
    Book* current = lib->bookHashTable[index];
    while (current) {
        if (current->id == bookId) return current;
        current = current->next;
    }
    return NULL;
}

Member* findMember(Library* lib, int memberId) {
    int index = hash(memberId);
    Member* current = lib->memberHashTable[index];
    while (current) {
        if (current->memberId == memberId) return current;
        current = current->next;
    }
    return NULL;
}

char* addBook(Library* lib, int bookId, char* title, char* author, char* isbn) {
    Book* book = malloc(sizeof(Book));
    book->id = bookId;
    strcpy(book->title, title);
    strcpy(book->author, author);
    strcpy(book->isbn, isbn);
    book->isAvailable = 1;
    book->borrowedBy = -1;
    
    int index = hash(bookId);
    book->next = lib->bookHashTable[index];
    lib->bookHashTable[index] = book;
    
    static char result[200];
    snprintf(result, sizeof(result), "Book %s added", title);
    return result;
}

char* addMember(Library* lib, int memberId, char* name, int maxBooks) {
    Member* member = malloc(sizeof(Member));
    member->memberId = memberId;
    strcpy(member->name, name);
    member->borrowedCount = 0;
    member->maxBooks = maxBooks > 0 ? maxBooks : 5;
    
    int index = hash(memberId);
    member->next = lib->memberHashTable[index];
    lib->memberHashTable[index] = member;
    
    static char result[200];
    snprintf(result, sizeof(result), "Member %s added", name);
    return result;
}

char* borrowBook(Library* lib, int memberId, int bookId) {
    static char result[200];
    
    // O(1) average lookup
    Member* member = findMember(lib, memberId);
    if (!member) {
        strcpy(result, "Member not found");
        return result;
    }
    
    if (member->borrowedCount >= member->maxBooks) {
        strcpy(result, "Member has reached borrowing limit");
        return result;
    }
    
    // O(1) average lookup
    Book* book = findBook(lib, bookId);
    if (!book) {
        strcpy(result, "Book not found");
        return result;
    }
    
    if (!book->isAvailable) {
        strcpy(result, "Book not available");
        return result;
    }
    
    book->isAvailable = 0;
    book->borrowedDate = time(NULL);
    book->borrowedBy = memberId;
    member->borrowedBooks[member->borrowedCount++] = bookId;
    
    snprintf(result, sizeof(result), "Book %s borrowed by %s", book->title, member->name);
    return result;
}

char** solution(char operations[][500], int opCount, int* resultCount) {
    Library lib;
    initLibrary(&lib);
    
    static char* results[1000];
    static char resultStrings[1000][200];
    *resultCount = 0;
    
    for (int i = 0; i < opCount; i++) {
        // Simplified parsing - real implementation would need JSON parsing
        if (strstr(operations[i], "addBook")) {
            char* result = addBook(&lib, 1, "Sample Book", "Author", "ISBN123");
            strcpy(resultStrings[*resultCount], result);
            results[*resultCount] = resultStrings[*resultCount];
            (*resultCount)++;
        }
    }
    
    return results;
}

int main() {
    char operations[100][500];
    int opCount = 0;
    int resultCount;
    
    char line[1000];
    if (fgets(line, sizeof(line), stdin)) {
        strcpy(operations[0], "addBook");
        opCount = 1;
    }
    
    char** result = solution(operations, opCount, &resultCount);
    
    printf("[");
    for (int i = 0; i < resultCount; i++) {
        printf("\"%s\"", result[i]);
        if (i < resultCount - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Hash map provides constant time lookup for books and members by ID

✓ Linear Growth

Space Complexity

O(n)

Hash maps store same data as arrays but with faster access structure

⚡ Linearithmic Space

24.5K Views

Medium Frequency

~25 min Avg. Time

890 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

Library Management System - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Hash Map Based Lookup — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler