Design File System - Practice Coding Problems

Design File System - Problem

Design a File System that supports creating hierarchical paths and storing values! 📁

You need to build a file system where you can:
• Create paths like /leetcode or /leetcode/problems
• Associate values with each path
• Retrieve values by path

The catch? You can only create a path if its parent path already exists. For example, you can't create /leetcode/problems unless /leetcode exists first!

Path Format Rules:
• Must start with /
• Followed by one or more lowercase letters
• Can have multiple segments like /a/b/c
• Empty string "" and lone "/" are invalid

Operations to implement:
• createPath(path, value) - Returns true if path created successfully, false if path exists or parent doesn't exist
• get(path) - Returns the value for the path, or -1 if path doesn't exist

Input & Output

example_1.py — Basic Operations

$ Input: fs = FileSystem() fs.createPath("/leet", 1) fs.createPath("/leet/code", 2) fs.get("/leet/code") fs.createPath("/c/d", 1) fs.get("/c")

› Output: true true 2 false -1

💡 Note: First two createPath operations succeed because /leet can be created (parent is root) and /leet/code can be created (parent /leet exists). Third operation fails because parent /c doesn't exist. Last get returns -1 because /c doesn't exist.

example_2.py — Duplicate Path

$ Input: fs = FileSystem() fs.createPath("/a", 1) fs.createPath("/a", 2) fs.get("/a")

› Output: true false 1

💡 Note: First createPath succeeds and creates /a with value 1. Second createPath fails because /a already exists. The value remains 1 from the first creation.

example_3.py — Deep Hierarchy

$ Input: fs = FileSystem() fs.createPath("/a", 1) fs.createPath("/a/b", 2) fs.createPath("/a/b/c", 3) fs.get("/a/b/c") fs.createPath("/a/x/y", 4)

› Output: true true true 3 false

💡 Note: Successfully creates a deep hierarchy /a → /a/b → /a/b/c. The last createPath fails because /a/x doesn't exist (can't create /a/x/y without parent /a/x).

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start with empty hash map to store path-value pairs

Create Path

Check if parent exists, then add new path to hash map

Get Value

Look up path directly in hash map for instant retrieval

Key Takeaway

🎯 Key Insight: Using a hash map transforms this from O(n) linear search to O(1) instant lookup, making it highly scalable for real-world file systems!

Time & Space Complexity

Time Complexity

⏱️

O(1)

Hash map provides O(1) average lookup, parent path extraction is O(path_length)

✓ Linear Growth

Space Complexity

O(n)

Store n path-value pairs in hash map

⚡ Linearithmic Space

Constraints

The number of calls to the two functions is at most 10⁴ in total
2 ≤ path.length ≤ 100
path will be a valid path that starts with '/' and contains only lowercase English letters
1 ≤ value ≤ 10⁹
At most 10⁴ unique paths will be created

Asked in

a Amazon 25 G Google 20 ⊞ Microsoft 15 f Meta 12

The optimal solution uses a hash map to store path-value pairs, providing O(1) average time complexity for both operations. For parent validation, we extract the parent path by finding the last '/' and checking if it exists in our hash map. This approach scales excellently with large numbers of paths and operations.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Map (Optimal)	O(1)	O(n)	Use hash map for O(1) path lookup and parent validation
Brute Force (Linear Search)	O(n)	O(n)	Store paths in a list and search linearly for parent validation

Hash Map (Optimal) — Algorithm Steps

Store all paths and values in a hash map for O(1) access
For createPath: check if path already exists in O(1)
Extract parent path by finding last '/' and taking substring
Check if parent exists in hash map in O(1)
For get: directly lookup path in hash map

Visualization

Tap to expand

Step-by-Step Walkthrough

Hash Storage

Store paths in hash map for instant access

Parent Extraction

Extract parent path by removing last segment

Fast Validation

Check parent existence in O(1) time

Code -

solution.c — C

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

#define MAX_PATHS 1000
#define MAX_PATH_LEN 100
#define HASH_SIZE 1009

typedef struct Node {
    char path[MAX_PATH_LEN];
    int value;
    struct Node* next;
} Node;

typedef struct {
    Node* buckets[HASH_SIZE];
} FileSystem;

unsigned int hash(char* path) {
    unsigned int hash = 5381;
    int c;
    while ((c = *path++)) {
        hash = ((hash << 5) + hash) + c;
    }
    return hash % HASH_SIZE;
}

FileSystem* fileSystemCreate() {
    FileSystem* fs = (FileSystem*)calloc(1, sizeof(FileSystem));
    return fs;
}

bool fileSystemCreatePath(FileSystem* obj, char* path, int value) {
    if (!path || strcmp(path, "/") == 0 || strlen(path) == 0 || path[0] != '/') {
        return false;
    }
    
    unsigned int idx = hash(path);
    
    // Check if path already exists
    Node* current = obj->buckets[idx];
    while (current) {
        if (strcmp(current->path, path) == 0) {
            return false;
        }
        current = current->next;
    }
    
    // Find parent path
    int lastSlash = -1;
    int len = strlen(path);
    for (int i = len - 1; i >= 0; i--) {
        if (path[i] == '/') {
            lastSlash = i;
            break;
        }
    }
    
    if (lastSlash == 0) {  // Direct child of root
        Node* newNode = (Node*)malloc(sizeof(Node));
        strcpy(newNode->path, path);
        newNode->value = value;
        newNode->next = obj->buckets[idx];
        obj->buckets[idx] = newNode;
        return true;
    }
    
    char parentPath[MAX_PATH_LEN];
    strncpy(parentPath, path, lastSlash);
    parentPath[lastSlash] = '\0';
    
    // Check if parent exists
    unsigned int parentIdx = hash(parentPath);
    current = obj->buckets[parentIdx];
    while (current) {
        if (strcmp(current->path, parentPath) == 0) {
            Node* newNode = (Node*)malloc(sizeof(Node));
            strcpy(newNode->path, path);
            newNode->value = value;
            newNode->next = obj->buckets[idx];
            obj->buckets[idx] = newNode;
            return true;
        }
        current = current->next;
    }
    
    return false;
}

int fileSystemGet(FileSystem* obj, char* path) {
    unsigned int idx = hash(path);
    Node* current = obj->buckets[idx];
    
    while (current) {
        if (strcmp(current->path, path) == 0) {
            return current->value;
        }
        current = current->next;
    }
    return -1;
}

void fileSystemFree(FileSystem* obj) {
    for (int i = 0; i < HASH_SIZE; i++) {
        Node* current = obj->buckets[i];
        while (current) {
            Node* temp = current;
            current = current->next;
            free(temp);
        }
    }
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Hash map provides O(1) average lookup, parent path extraction is O(path_length)

✓ Linear Growth

Space Complexity

O(n)

Store n path-value pairs in hash map

⚡ Linearithmic Space

Constraints

The number of calls to the two functions is at most 10⁴ in total
2 ≤ path.length ≤ 100
path will be a valid path that starts with '/' and contains only lowercase English letters
1 ≤ value ≤ 10⁹
At most 10⁴ unique paths will be created

28.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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Hash Map (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler