Codestin Search App

Design Memory Allocator - Problem

Design and implement a dynamic memory allocator that manages a contiguous block of memory. Think of it like managing RAM in an operating system - you need to efficiently allocate blocks of memory to different processes and free them when they're no longer needed.

You're given an integer n representing the size of a 0-indexed memory array. Initially, all memory units are free (available for allocation).

Your memory allocator must support these operations:

Allocate: Find the leftmost block of consecutive free memory units of a given size and assign it a memory ID (mID)
Free: Release all memory units associated with a given memory ID

Key constraints:

Multiple separate blocks can be allocated to the same mID
When freeing memory, you must free ALL units with that mID, regardless of how they were allocated
Always allocate to the leftmost available position to minimize fragmentation

Input & Output

basic_operations.py — Python

$ Input: ["Allocator", "allocate", "allocate", "allocate", "freeMemory", "allocate", "allocate", "allocate", "freeMemory"] [[10], [1, 1], [1, 2], [1, 3], [2], [3, 4], [1, 1], [1, 1], [1]]

› Output: [null, 0, 1, 2, 1, 3, 6, 7, 1]

💡 Note: Allocator(10) creates memory of size 10. allocate(1,1) finds leftmost free position 0. allocate(1,2) finds position 1. allocate(1,3) finds position 2. freeMemory(2) frees position 1, returns 1. allocate(3,4) finds positions 3-5, returns 3. allocate(1,1) finds position 1 (now free), returns 1. allocate(1,1) finds position 6, returns 6. freeMemory(1) frees positions 0,1,6, returns 3.

multiple_blocks_same_id.py — Python

$ Input: ["Allocator", "allocate", "allocate", "allocate", "freeMemory"] [[8], [2, 1], [2, 1], [2, 2], [1]]

› Output: [null, 0, 2, 4, 4]

💡 Note: Create memory of size 8. allocate(2,1) takes positions 0-1, returns 0. allocate(2,1) takes positions 2-3 for same mID, returns 2. allocate(2,2) takes positions 4-5, returns 4. freeMemory(1) frees ALL positions with mID 1 (both blocks: 0,1,2,3), returns 4.

allocation_failure.py — Python

$ Input: ["Allocator", "allocate", "allocate", "allocate"] [[5], [3, 1], [3, 2], [2, 3]]

› Output: [null, 0, -1, 3]

💡 Note: Create memory of size 5. allocate(3,1) takes positions 0-2, returns 0. allocate(3,2) cannot find 3 consecutive free positions, returns -1. allocate(2,3) finds positions 3-4, returns 3.

Visualization

Tap to expand

Understanding the Visualization

Initialize Memory

Start with empty memory array where 0 = free, mID = allocated

Allocate Memory

Scan from left to find first fit, mark positions with mID, track in hash map

Multiple Allocations

Same mID can have multiple separate blocks, all tracked together

Free Memory

Use hash map to instantly find and free all positions for an mID

Key Takeaway

🎯 Key Insight: Combining array simulation with hash map tracking gives us the best of both worlds - efficient memory state management and fast freeing operations.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Allocation scans up to n positions, freeing takes O(k) where k is number of units to free

✓ Linear Growth

Space Complexity

O(n + m)

Memory array O(n) plus hash map storing up to n positions across m different mIDs

⚡ Linearithmic Space

Constraints

1 ≤ n, size ≤ 1000
1 ≤ mID ≤ 1000
At most 1000 calls will be made to allocate and freeMemory
Memory positions are 0-indexed

Asked in

a Amazon 35 G Google 28 ⊞ Microsoft 22 f Meta 18

The optimal approach uses a memory array to track allocation state combined with a hash map to efficiently track which positions each mID occupies. This enables O(n) allocation scanning and O(k) freeing where k is the number of units to free, avoiding the need to scan the entire array during free operations.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Scan)	O(n)	O(n)	Scan entire memory array for every operation
Array + Hash Map (Optimal)	O(n)	O(n + m)	Memory array for state tracking with hash map for efficient freeing

Brute Force (Linear Scan) — Algorithm Steps

For allocation: Start from index 0, check if we can fit 'size' consecutive free units
If found, mark all units with the given mID and return starting index
For freeing: Scan entire array, count and free all units matching the mID
Return count of freed units

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Memory

Create memory array with all positions free (0)

Scan for Allocation

Linear scan from left to find consecutive free blocks

Allocate Block

Mark found consecutive positions with mID

Scan for Freeing

Linear scan entire array to find and free all mID positions

Code -

solution.c — C

typedef struct {
    int* memory;
    int size;
} Allocator;

Allocator* allocatorCreate(int n) {
    Allocator* obj = (Allocator*)malloc(sizeof(Allocator));
    obj->memory = (int*)calloc(n, sizeof(int));  // 0 means free
    obj->size = n;
    return obj;
}

int allocatorAllocate(Allocator* obj, int size, int mID) {
    // Find leftmost block of 'size' consecutive free units
    for (int start = 0; start <= obj->size - size; start++) {
        // Check if we can allocate 'size' units starting at 'start'
        int canAllocate = 1;
        for (int i = start; i < start + size; i++) {
            if (obj->memory[i] != 0) {
                canAllocate = 0;
                break;
            }
        }
        
        if (canAllocate) {
            // Allocate the block
            for (int i = start; i < start + size; i++) {
                obj->memory[i] = mID;
            }
            return start;
        }
    }
    
    return -1;  // Cannot allocate
}

int allocatorFreeMemory(Allocator* obj, int mID) {
    int freedCount = 0;
    for (int i = 0; i < obj->size; i++) {
        if (obj->memory[i] == mID) {
            obj->memory[i] = 0;
            freedCount++;
        }
    }
    return freedCount;
}

void allocatorFree(Allocator* obj) {
    free(obj->memory);
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each allocation scans up to n positions, each free operation scans all n positions

✓ Linear Growth

Space Complexity

O(n)

Only the memory array storage is needed

⚡ Linearithmic Space

Constraints

1 ≤ n, size ≤ 1000
1 ≤ mID ≤ 1000
At most 1000 calls will be made to allocate and freeMemory
Memory positions are 0-indexed

42.0K Views

Medium Frequency

~25 min Avg. Time

1.5K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Linear Scan) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler