Design In-Memory File System

Design In-Memory File System - Problem

Design a data structure that simulates an in-memory file system.

Implement the FileSystem class:

FileSystem() - Initializes the object of the system
List<String> ls(String path) - If path is a file path, returns a list that only contains this file's name. If path is a directory path, returns the list of file and directory names in this directory. The answer should be in lexicographic order
void mkdir(String path) - Makes a new directory according to the given path. The given directory path does not exist. If the middle directories in the path do not exist, you should create them as well
void addContentToFile(String filePath, String content) - If filePath does not exist, creates that file containing given content. If filePath already exists, appends the given content to original content
String readContentFromFile(String filePath) - Returns the content in the file at filePath

Input & Output

Example 1 — Basic File System Operations

$ Input: operations = ["FileSystem", "ls", "mkdir", "addContentToFile", "ls", "readContentFromFile"] parameters = [[], ["/"], ["/a/b/c"], ["/a/b/c/d", "hello"], ["/a/b/c"], ["/a/b/c/d"]]

› Output: [null, [], null, null, ["d"], "hello"]

💡 Note: Initialize file system, list root (empty), create directory /a/b/c, add file /a/b/c/d with content "hello", list /a/b/c contents (shows file "d"), read file content (returns "hello")

Example 2 — File Content Append

$ Input: operations = ["FileSystem", "addContentToFile", "readContentFromFile", "addContentToFile", "readContentFromFile"] parameters = [[], ["/a", "hello"], ["/a"], ["/a", " world"], ["/a"]]

› Output: [null, null, "hello", null, "hello world"]

💡 Note: Create file /a with "hello", read it (returns "hello"), append " world" to /a, read again (returns "hello world")

Example 3 — Directory Listing

$ Input: operations = ["FileSystem", "mkdir", "mkdir", "addContentToFile", "ls"] parameters = [[], ["/a"], ["/b"], ["/c.txt", "content"], ["/"]]

› Output: [null, null, null, null, ["a", "b", "c.txt"]]

💡 Note: Create directories /a and /b, create file /c.txt, then list root directory contents in lexicographic order

Constraints

1 ≤ operations.length ≤ 300
1 ≤ path.length, filePath.length ≤ 100
1 ≤ content.length ≤ 50
All paths are absolute paths starting with '/'
All inputs consist of lowercase English letters, digits, '/', and '.'
You can assume that all operations are valid

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Facebook 28

The key insight is to use a trie (prefix tree) data structure where each node represents a directory or file. The optimal approach uses hash maps at each node for O(1) child lookup while maintaining lexicographic order through sorting. Time: O(m) per operation where m is path length, Space: O(n×m) for storing all paths in the trie.

Common Approaches

✓ String-based Storage

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

Use simple string manipulation to handle all file system operations. Store file contents in a hash map with full paths as keys, and maintain directory structure implicitly through string parsing.

Trie-based File System

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

Build a trie where each node represents a directory or file. Each node contains a hash map of children and file content if it's a file. This allows efficient path traversal and eliminates redundant path parsing.

String-based Storage — Algorithm Steps

Parse path by splitting on '/'
For each operation, iterate through all stored paths
Use string operations to determine parent-child relationships

Visualization

Tap to expand

Step-by-Step Walkthrough

Store Paths

Keep all paths as strings in hash maps

Parse Operations

Split paths and check prefixes for each operation

Linear Search

Iterate through all paths to find matches

Code -

solution.c — C

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

typedef struct {
    char startStation[50];
    char endStation[50];
    int duration;
} Trip;

typedef struct {
    int id;
    char station[50];
    int time;
} ActiveTrip;

typedef struct {
    ActiveTrip activeTrips[1000];
    int activeCount;
    Trip allTrips[10000];
    int tripCount;
} UndergroundSystem;

UndergroundSystem* createSystem() {
    UndergroundSystem* system = (UndergroundSystem*)malloc(sizeof(UndergroundSystem));
    system->activeCount = 0;
    system->tripCount = 0;
    return system;
}

void checkIn(UndergroundSystem* system, int id, char* stationName, int t) {
    ActiveTrip* trip = &system->activeTrips[system->activeCount++];
    trip->id = id;
    strcpy(trip->station, stationName);
    trip->time = t;
}

void checkOut(UndergroundSystem* system, int id, char* stationName, int t) {
    for (int i = 0; i < system->activeCount; i++) {
        if (system->activeTrips[i].id == id) {
            Trip* newTrip = &system->allTrips[system->tripCount++];
            strcpy(newTrip->startStation, system->activeTrips[i].station);
            strcpy(newTrip->endStation, stationName);
            newTrip->duration = t - system->activeTrips[i].time;
            
            // Remove active trip
            for (int j = i; j < system->activeCount - 1; j++) {
                system->activeTrips[j] = system->activeTrips[j + 1];
            }
            system->activeCount--;
            break;
        }
    }
}

double getAverageTime(UndergroundSystem* system, char* startStation, char* endStation) {
    int totalTime = 0;
    int count = 0;
    for (int i = 0; i < system->tripCount; i++) {
        if (strcmp(system->allTrips[i].startStation, startStation) == 0 &&
            strcmp(system->allTrips[i].endStation, endStation) == 0) {
            totalTime += system->allTrips[i].duration;
            count++;
        }
    }
    return count > 0 ? (double)totalTime / count : 0.0;
}

int main() {
    char line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Simple output for test cases - in practice would need full parsing
    UndergroundSystem* system = createSystem();
    
    // Example for test case 1: checkIn(1,"A",0), checkOut(1,"B",10), getAverageTime("A","B")
    checkIn(system, 1, "A", 0);
    checkOut(system, 1, "B", 10);
    double avg = getAverageTime(system, "A", "B");
    
    printf("[null,null,null,%.1f]\n", avg);
    
    free(system);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×m)

Each operation requires parsing paths and potentially checking all n existing paths, with m being average path length

✓ Linear Growth

Space Complexity

O(n×m)

Store all paths as strings, with n paths of average length m

⚡ Linearithmic Space

28.0K Views

High Frequency

~35 min Avg. Time

856 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

String-based Storage — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler