Design In-Memory File System - Practice Coding Problems

Design In-Memory File System - Problem

🗂️ Design In-Memory File System

Imagine you're building a cloud storage system that needs to simulate a complete file system entirely in memory. You need to create a data structure that can handle all the basic operations you'd expect from a real file system: listing directories, creating folders, writing files, and reading their contents.

Your FileSystem class should support these operations:

List Directory/File (ls): Given a path, return all files and folders in lexicographic order. If it's a file, return just that filename.
Create Directory (mkdir): Create a new directory (and any missing parent directories) at the given path.
Write/Append to File (addContentToFile): Create a new file with content, or append to existing file content.
Read File (readContentFromFile): Return the complete content of a file.

Think of it like implementing your own version of a simplified Unix file system commands!

Input & Output

Basic Operations

$ Input: fs = FileSystem() fs.ls("/") # [] fs.mkdir("/a/b/c") fs.addContentToFile("/a/b/c/d", "hello") fs.ls("/") # ["a"] fs.readContentFromFile("/a/b/c/d") # "hello"

› Output: [] ["a"] "hello"

💡 Note: Create directory structure, add file with content, then list and read operations work correctly

File vs Directory Listing

$ Input: fs = FileSystem() fs.addContentToFile("/goowmfn", "c") fs.ls("/goowmfn") # ["goowmfn"] fs.ls("/") # ["goowmfn"]

› Output: ["goowmfn"] ["goowmfn"]

💡 Note: When ls() is called on a file path, it returns just the filename. When called on directory containing that file, it lists the file.

Content Appending

$ Input: fs = FileSystem() fs.addContentToFile("/a", "hello") fs.addContentToFile("/a", " world") fs.readContentFromFile("/a") # "hello world"

› Output: "hello world"

💡 Note: Multiple calls to addContentToFile append content to existing files rather than overwriting

Visualization

Tap to expand

Understanding the Visualization

Root Foundation

Start with root node (/) as the foundation of our file system tree

Branch Navigation

Each path component leads us down a specific branch in the tree

Efficient Access

Operations only traverse the path depth, not the entire file system

Key Takeaway

🎯 Key Insight: By representing the file system as a tree where each node is a directory containing files and subdirectories, we achieve O(path_depth) complexity for all operations - much faster than linear searching through all paths.

Time & Space Complexity

Time Complexity

⏱️

O(L)

Where L is the length of the path (number of directories in path). Each operation only needs to traverse the path once.

✓ Linear Growth

Space Complexity

O(N * L)

Where N is total number of files/directories and L is average path depth. Shared prefixes save space compared to storing full paths.

✓ Linear Space

Constraints

1 ≤ path.length, filePath.length ≤ 100
1 ≤ content.length ≤ 50
All paths are absolute paths starting with '/' and do not end with '/' except for root
At most 300 calls will be made to the methods
File and directory names consist of only lowercase English letters and digits

Asked in

The optimal solution uses a Trie-like tree structure where each node represents a directory containing maps for subdirectories and files. This enables O(path_depth) operations instead of linear searches, making it efficient for large file systems while naturally representing the hierarchical structure.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search)	O(n)	O(n * L)	Store all paths as strings in lists and search linearly for operations
Trie-Based File System (Optimal)	O(L)	O(N * L)	Use a Trie-like tree structure where each node represents a directory with files and subdirectories

Brute Force (Linear Search) — Algorithm Steps

Maintain separate lists for all file paths and directory paths
For ls(): search through all paths that start with given path
For mkdir(): add directory path to directory list
For file operations: search file list for exact path matches
Sort results when needed for lexicographic order

Visualization

Tap to expand

Step-by-Step Walkthrough

Store All Paths

Maintain lists of all file and directory paths as strings

Linear Search

For any operation, scan through all paths to find matches

String Matching

Use string prefix matching to find files/dirs in target directory

Code -

solution.c — C

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

#define MAX_PATHS 1000
#define MAX_PATH_LEN 256
#define MAX_CONTENT_LEN 1024

typedef struct {
    char files[MAX_PATHS][MAX_PATH_LEN];
    char contents[MAX_PATHS][MAX_CONTENT_LEN];
    char dirs[MAX_PATHS][MAX_PATH_LEN];
    int fileCount;
    int dirCount;
} FileSystem;

FileSystem* fileSystemCreate() {
    FileSystem* fs = (FileSystem*)malloc(sizeof(FileSystem));
    fs->fileCount = 0;
    fs->dirCount = 1;
    strcpy(fs->dirs[0], "/");
    return fs;
}

char** fileSystemLs(FileSystem* obj, char* path, int* returnSize) {
    char** result = (char**)malloc(MAX_PATHS * sizeof(char*));
    *returnSize = 0;
    
    // Check if path is a file
    for (int i = 0; i < obj->fileCount; i++) {
        if (strcmp(obj->files[i], path) == 0) {
            char* filename = strrchr(path, '/');
            result[0] = (char*)malloc(MAX_PATH_LEN);
            strcpy(result[0], filename + 1);
            *returnSize = 1;
            return result;
        }
    }
    
    // Collect directory contents
    char prefix[MAX_PATH_LEN];
    sprintf(prefix, "%s/", path);
    int prefixLen = strlen(prefix);
    
    for (int i = 0; i < obj->fileCount; i++) {
        if (strncmp(obj->files[i], prefix, prefixLen) == 0) {
            char* remaining = obj->files[i] + prefixLen;
            char* slash = strchr(remaining, '/');
            if (slash) *slash = '\0';
            
            // Check if already added
            int found = 0;
            for (int j = 0; j < *returnSize; j++) {
                if (strcmp(result[j], remaining) == 0) {
                    found = 1;
                    break;
                }
            }
            if (!found) {
                result[*returnSize] = (char*)malloc(MAX_PATH_LEN);
                strcpy(result[*returnSize], remaining);
                (*returnSize)++;
            }
        }
    }
    
    return result;
}

void fileSystemMkdir(FileSystem* obj, char* path) {
    char temp[MAX_PATH_LEN];
    strcpy(temp, path);
    
    for (int i = 1; i <= strlen(path); i++) {
        if (path[i] == '/' || i == strlen(path)) {
            char currentPath[MAX_PATH_LEN];
            strncpy(currentPath, path, i);
            currentPath[i] = '\0';
            
            int found = 0;
            for (int j = 0; j < obj->dirCount; j++) {
                if (strcmp(obj->dirs[j], currentPath) == 0) {
                    found = 1;
                    break;
                }
            }
            if (!found) {
                strcpy(obj->dirs[obj->dirCount], currentPath);
                obj->dirCount++;
            }
        }
    }
}

void fileSystemAddContentToFile(FileSystem* obj, char* filePath, char* content) {
    int found = -1;
    for (int i = 0; i < obj->fileCount; i++) {
        if (strcmp(obj->files[i], filePath) == 0) {
            found = i;
            break;
        }
    }
    
    if (found >= 0) {
        strcat(obj->contents[found], content);
    } else {
        strcpy(obj->files[obj->fileCount], filePath);
        strcpy(obj->contents[obj->fileCount], content);
        obj->fileCount++;
    }
}

char* fileSystemReadContentFromFile(FileSystem* obj, char* filePath) {
    for (int i = 0; i < obj->fileCount; i++) {
        if (strcmp(obj->files[i], filePath) == 0) {
            return obj->contents[i];
        }
    }
    return NULL;
}

void fileSystemFree(FileSystem* obj) {
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Every operation requires scanning through all stored paths linearly

✓ Linear Growth

Space Complexity

O(n * L)

Stores every full path as string, where L is average path length

⚡ Linearithmic Space

Constraints

1 ≤ path.length, filePath.length ≤ 100
1 ≤ content.length ≤ 50
All paths are absolute paths starting with '/' and do not end with '/' except for root
At most 300 calls will be made to the methods
File and directory names consist of only lowercase English letters and digits

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

🗂️ Design In-Memory File System

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Linear Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler