Design File System

Design File System - Problem

You are asked to design a file system that allows you to create new paths and associate them with different values.

The format of a path is one or more concatenated strings of the form: / followed by one or more lowercase English letters. For example, "/leetcode" and "/leetcode/problems" are valid paths while an empty string "" and "/" are not.

Implement the FileSystem class:

bool createPath(string path, int value) Creates a new path and associates a value to it if possible and returns true. Returns false if the path already exists or its parent path doesn't exist.
int get(string path) Returns the value associated with path or returns -1 if the path doesn't exist.

Input & Output

Example 1 — Basic Operations

$ Input: operations = ["FileSystem", "createPath", "get"], parameters = [[], ["/a", 1], ["/a"]]

› Output: [null, true, 1]

💡 Note: Create FileSystem, create path /a with value 1, then get /a returns 1

Example 2 — Parent Path Required

$ Input: operations = ["FileSystem", "createPath", "createPath"], parameters = [[], ["/leet", 1], ["/leet/code", 2]]

› Output: [null, true, true]

💡 Note: Create /leet first, then /leet/code succeeds because parent /leet exists

Example 3 — Missing Parent

$ Input: operations = ["FileSystem", "createPath"], parameters = [[], ["/leet/code", 2]]

› Output: [null, false]

💡 Note: Cannot create /leet/code because parent /leet doesn't exist

Constraints

1 ≤ operations.length ≤ 10⁴
1 ≤ path.length ≤ 100
1 ≤ value ≤ 10⁹

Visualization

Tap to expand

Asked in

F Facebook 35 a Amazon 28 G Google 22

The key insight is to use a hash map for O(1) path lookups and extract parent paths by string manipulation. For createPath, verify the parent exists before creating new paths. Best approach uses hash map with O(1) time complexity and O(n) space.

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force with List Storage

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

Maintain a list of path-value pairs and search through the entire list for each createPath and get operation. For createPath, verify parent exists by checking all paths in the list.

Hash Map Optimization

⏱️ Time: O(1) Space: O(n)

Store paths and their values in a hash map for constant time lookups. For createPath, extract the parent path by removing the last component and check if it exists in the map. This provides much faster operations compared to linear search.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_SIZE 1000

typedef struct {
    int row, col;
} Position;

typedef struct {
    int width, height;
    Position *food;
    int foodSize;
    int foodIndex;
    int score;
    Position snake[MAX_SIZE];
    int snakeSize;
    char positionSet[MAX_SIZE][20];  // Simple hash set simulation
    int setSize;
} SnakeGame;

int findInSet(SnakeGame* obj, int row, int col) {
    char key[20];
    sprintf(key, "%d,%d", row, col);
    for (int i = 0; i < obj->setSize; i++) {
        if (strcmp(obj->positionSet[i], key) == 0) {
            return i;
        }
    }
    return -1;
}

void addToSet(SnakeGame* obj, int row, int col) {
    sprintf(obj->positionSet[obj->setSize], "%d,%d", row, col);
    obj->setSize++;
}

void removeFromSet(SnakeGame* obj, int row, int col) {
    int index = findInSet(obj, row, col);
    if (index != -1) {
        for (int i = index; i < obj->setSize - 1; i++) {
            strcpy(obj->positionSet[i], obj->positionSet[i + 1]);
        }
        obj->setSize--;
    }
}

SnakeGame* snakeGameCreate(int width, int height, Position* food, int foodSize) {
    SnakeGame* obj = (SnakeGame*)malloc(sizeof(SnakeGame));
    obj->width = width;
    obj->height = height;
    obj->food = food;
    obj->foodSize = foodSize;
    obj->foodIndex = 0;
    obj->score = 0;
    obj->snake[0].row = 0;
    obj->snake[0].col = 0;
    obj->snakeSize = 1;
    obj->setSize = 0;
    addToSet(obj, 0, 0);
    return obj;
}

int snakeGameMove(SnakeGame* obj, char* direction) {
    Position head = obj->snake[0];
    Position newHead;
    
    if (strcmp(direction, "U") == 0) {
        newHead.row = head.row - 1;
        newHead.col = head.col;
    } else if (strcmp(direction, "D") == 0) {
        newHead.row = head.row + 1;
        newHead.col = head.col;
    } else if (strcmp(direction, "L") == 0) {
        newHead.row = head.row;
        newHead.col = head.col - 1;
    } else {
        newHead.row = head.row;
        newHead.col = head.col + 1;
    }
    
    if (newHead.row < 0 || newHead.row >= obj->height ||
        newHead.col < 0 || newHead.col >= obj->width) {
        return -1;
    }
    
    int ateFood = (obj->foodIndex < obj->foodSize &&
                   newHead.row == obj->food[obj->foodIndex].row &&
                   newHead.col == obj->food[obj->foodIndex].col);
    
    if (!ateFood) {
        Position tail = obj->snake[obj->snakeSize - 1];
        obj->snakeSize--;
        removeFromSet(obj, tail.row, tail.col);
    }
    
    if (findInSet(obj, newHead.row, newHead.col) != -1) {
        return -1;
    }
    
    for (int i = obj->snakeSize; i > 0; i--) {
        obj->snake[i] = obj->snake[i - 1];
    }
    obj->snake[0] = newHead;
    obj->snakeSize++;
    addToSet(obj, newHead.row, newHead.col);
    
    if (ateFood) {
        obj->score++;
        obj->foodIndex++;
    }
    
    return obj->score;
}

// Simple test with hardcoded values for demonstration
int main() {
    // Create a simple test case
    Position* food = (Position*)malloc(2 * sizeof(Position));
    food[0].row = 1; food[0].col = 2;
    food[1].row = 0; food[1].col = 1;
    
    SnakeGame* game = snakeGameCreate(3, 2, food, 2);
    
    printf("[null,%d,%d,%d]\n", 
           snakeGameMove(game, "R"),
           snakeGameMove(game, "D"), 
           snakeGameMove(game, "R"));
    
    // Cleanup
    free(food);
    free(game);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.0K Views

Medium Frequency

~25 min Avg. Time

890 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