Design Memory Allocator - Practice Coding Problems

Design Memory Allocator - Problem

You are given an integer n representing the size of a 0-indexed memory array. All memory units are initially free.

You have a memory allocator with the following functionalities:

Allocate a block of size consecutive free memory units and assign it the id mID.
Free all memory units with the given id mID.

Note that:

Multiple blocks can be allocated to the same mID.
You should free all the memory units with mID, even if they were allocated in different blocks.

Implement the Allocator class:

Allocator(int n) Initializes an Allocator object with a memory array of size n.
int allocate(int size, int mID) Find the leftmost block of size consecutive free memory units and allocate it with the id mID. Return the block's first index. If such a block does not exist, return -1.
int freeMemory(int mID) Free all memory units with the id mID. Return the number of memory units you have freed.

Input & Output

Example 1 — Basic Operations

$ Input: operations = ["Allocator", "allocate", "allocate", "allocate", "freeMemory"], values = [[10], [1, 1], [1, 2], [1, 3], [2]]

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

💡 Note: Initialize allocator with size 10. allocate(1,1) returns 0 (first position). allocate(1,2) returns 1. allocate(1,3) returns 2. freeMemory(2) frees 1 unit and returns 1.

Example 2 — Failed Allocation

$ Input: operations = ["Allocator", "allocate", "allocate", "allocate"], values = [[2], [1, 1], [1, 2], [1, 3]]

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

💡 Note: Memory size is 2. First two allocations succeed at positions 0 and 1. Third allocation fails since no free space exists, returns -1.

Example 3 — Multiple Blocks Same ID

$ Input: operations = ["Allocator", "allocate", "allocate", "freeMemory"], values = [[10], [2, 1], [3, 1], [1]]

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

💡 Note: allocate(2,1) uses positions [0,1]. allocate(3,1) uses positions [2,3,4]. freeMemory(1) frees all 5 positions allocated to mID=1.

Constraints

1 ≤ n, size ≤ 1000
1 ≤ mID ≤ 1000
At most 1000 calls will be made to allocate and freeMemory

Visualization

Tap to expand

Understanding the Visualization

Input

Memory size n=10, operations: allocate(3,1), allocate(2,2), freeMemory(1)

Process

Track memory state and find consecutive free blocks

Output

Return starting positions or counts of freed memory

Key Takeaway

🎯 Key Insight: Simulate memory with array, scan linearly for consecutive free blocks

Asked in

a Amazon 15 M Microsoft 8 G Google 5

The key insight is to simulate memory allocation using an array where each cell stores the mID of the allocated block (0 for free). The brute force approach scans linearly for both allocation and freeing. The optimized approach adds a hashmap to track positions for each mID, making free operations faster. Best overall approach uses array simulation with hashmap tracking. Time: O(n), Space: O(n)

Common Approaches

Approach	Time	Space	Notes
✓ Array Simulation	O(n)	O(n)	Use array to track memory state and linear search for allocation
HashMap + Array Tracking	O(n)	O(n)	Combine array simulation with hashmap for efficient mID tracking

Array Simulation — Algorithm Steps

Initialize array of size n with all zeros (free)
For allocate: scan array to find size consecutive zeros, mark with mID
For free: scan entire array, count and reset all cells with mID to zero

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create memory array filled with zeros (free)

Allocate

Find consecutive free blocks and mark with mID

Free

Scan array and reset all blocks with target mID

Code -

solution.c — C

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

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

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

int allocatorAllocate(Allocator* obj, int size, int mID) {
    for (int i = 0; i <= obj->n - size; i++) {
        int canAllocate = 1;
        for (int j = i; j < i + size; j++) {
            if (obj->memory[j] != 0) {
                canAllocate = 0;
                break;
            }
        }
        if (canAllocate) {
            for (int j = i; j < i + size; j++) {
                obj->memory[j] = mID;
            }
            return i;
        }
    }
    return -1;
}

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

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

int main() {
    printf("[null,-1,0,0,2]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Both allocate and free operations scan through the entire memory array

✓ Linear Growth

Space Complexity

O(n)

Memory array of size n to track allocation state

⚡ Linearithmic Space

23.4K Views

Medium Frequency

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

Array Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler