File System Simulator - Problem

Design and implement a File System Simulator that supports basic file system operations. Your simulator should handle directories and files with the following commands:

Commands to implement:

mkdir <path> - Create a directory at the given path
touch <path> - Create a file at the given path
ls <path> - List contents of a directory (return sorted list)
cd <path> - Change current working directory
pwd - Print current working directory path

Your implementation should:

Start with root directory / as current directory
Support both absolute paths (starting with /) and relative paths
Handle .. to go up one directory level
Return appropriate responses for each command

Note: For this problem, assume all paths are valid and operations are legal (no error handling required).

Input & Output

Example 1 — Basic Operations

$ Input: commands = ["mkdir home", "cd home", "pwd", "touch file.txt", "ls"]

› Output: ["/home", ["file.txt"]]

💡 Note: Create 'home' directory, navigate to it, print path '/home', create 'file.txt', and list contents showing ['file.txt']

Example 2 — Nested Directories

$ Input: commands = ["mkdir /docs", "mkdir /docs/projects", "ls /docs", "cd /docs/projects", "pwd"]

› Output: [["projects"], "/docs/projects"]

💡 Note: Create nested directories, list '/docs' showing ['projects'], then navigate and show current path

Example 3 — Mixed Content

$ Input: commands = ["mkdir folder", "touch file1.txt", "touch file2.txt", "ls"]

› Output: [["file1.txt", "file2.txt", "folder"]]

💡 Note: Create mixed files and directory, then list shows all contents sorted alphabetically

Constraints

1 ≤ commands.length ≤ 100
Each command is one of: mkdir, touch, ls, cd, pwd
All paths are valid and operations are legal
Path names contain only alphanumeric characters and dots

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 f Meta 18

The key insight is using a tree structure where each directory node maintains direct references to its children. This eliminates the need for string parsing and linear searches. The optimal approach uses FileSystemNode objects with parent-child relationships for O(depth + children) navigation. Time: O(d + k), Space: O(n).

Common Approaches

✓ String-Based Path Traversal

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

Maintain a flat list of all directory and file paths as strings. For each operation, parse the path and search through the entire list to find matches or determine where to create new entries.

Tree Structure with Node Objects

⏱️ Time: O(d + k) Space: O(n)

Implement a proper tree structure where each directory is a node containing references to its child directories and files. Navigate by following node references instead of string manipulation.

String-Based Path Traversal — Algorithm Steps

Store all paths in a simple list with type indicators (file/directory)
For each command, parse the path and search linearly through all stored paths
Create new entries by adding strings to the list
For ls, filter paths that start with the target directory and extract immediate children

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create empty paths list, set current directory to '/'

Process Commands

For each command, parse path and search through all stored paths

Execute Operation

Add new paths or filter existing ones based on command type

Code -

solution.c — C

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

#define MAX_PATHS 1000
#define MAX_PATH_LEN 256
#define MAX_CMD_LEN 512

struct PathEntry {
    char path[MAX_PATH_LEN];
    char type[10];
};

char* solution(char commands[][MAX_CMD_LEN], int numCommands) {
    static struct PathEntry paths[MAX_PATHS];
    int pathCount = 0;
    strcpy(paths[0].path, "/");
    strcpy(paths[0].type, "dir");
    pathCount = 1;
    
    char currentDir[MAX_PATH_LEN] = "/";
    static char result[10000] = "[";
    int first = 1;
    
    for (int i = 0; i < numCommands; i++) {
        char* cmd = strtok(commands[i], " ");
        char* arg = strtok(NULL, " ");
        
        if (strcmp(cmd, "pwd") == 0) {
            if (!first) strcat(result, ",");
            strcat(result, "\"");
            strcat(result, currentDir);
            strcat(result, "\"");
            first = 0;
        } else if (strcmp(cmd, "cd") == 0) {
            if (arg[0] == '/') {
                strcpy(currentDir, arg);
            } else {
                if (strcmp(currentDir, "/") == 0) {
                    strcpy(currentDir, "/");
                    strcat(currentDir, arg);
                } else {
                    strcat(currentDir, "/");
                    strcat(currentDir, arg);
                }
            }
        } else if (strcmp(cmd, "mkdir") == 0) {
            char path[MAX_PATH_LEN];
            if (arg[0] == '/') {
                strcpy(path, arg);
            } else {
                if (strcmp(currentDir, "/") == 0) {
                    strcpy(path, "/");
                    strcat(path, arg);
                } else {
                    strcpy(path, currentDir);
                    strcat(path, "/");
                    strcat(path, arg);
                }
            }
            strcpy(paths[pathCount].path, path);
            strcpy(paths[pathCount].type, "dir");
            pathCount++;
        } else if (strcmp(cmd, "touch") == 0) {
            char path[MAX_PATH_LEN];
            if (arg[0] == '/') {
                strcpy(path, arg);
            } else {
                if (strcmp(currentDir, "/") == 0) {
                    strcpy(path, "/");
                    strcat(path, arg);
                } else {
                    strcpy(path, currentDir);
                    strcat(path, "/");
                    strcat(path, arg);
                }
            }
            strcpy(paths[pathCount].path, path);
            strcpy(paths[pathCount].type, "file");
            pathCount++;
        } else if (strcmp(cmd, "ls") == 0) {
            char path[MAX_PATH_LEN];
            if (arg) {
                strcpy(path, arg);
            } else {
                strcpy(path, currentDir);
            }
            
            char contents[100][MAX_PATH_LEN];
            int contentCount = 0;
            
            char prefix[MAX_PATH_LEN];
            if (strcmp(path, "/") == 0) {
                strcpy(prefix, "/");
            } else {
                strcpy(prefix, path);
                strcat(prefix, "/");
            }
            
            for (int j = 0; j < pathCount; j++) {
                if (strcmp(paths[j].path, path) != 0 && strstr(paths[j].path, prefix) == paths[j].path) {
                    char* remaining = paths[j].path + strlen(prefix);
                    if (strchr(remaining, '/') == NULL && strlen(remaining) > 0) {
                        strcpy(contents[contentCount], remaining);
                        contentCount++;
                    }
                }
            }
            
            // Simple sort
            for (int a = 0; a < contentCount - 1; a++) {
                for (int b = a + 1; b < contentCount; b++) {
                    if (strcmp(contents[a], contents[b]) > 0) {
                        char temp[MAX_PATH_LEN];
                        strcpy(temp, contents[a]);
                        strcpy(contents[a], contents[b]);
                        strcpy(contents[b], temp);
                    }
                }
            }
            
            if (!first) strcat(result, ",");
            strcat(result, "[");
            for (int j = 0; j < contentCount; j++) {
                if (j > 0) strcat(result, ",");
                strcat(result, "\"");
                strcat(result, contents[j]);
                strcat(result, "\"");
            }
            strcat(result, "]");
            first = 0;
        }
    }
    
    strcat(result, "]");
    return result;
}

int main() {
    char line[5000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array manually
    char commands[100][MAX_CMD_LEN];
    int numCommands = 0;
    
    char* start = strchr(line, '"');
    while (start) {
        start++; // Skip opening quote
        char* end = strchr(start, '"');
        if (end) {
            int len = end - start;
            strncpy(commands[numCommands], start, len);
            commands[numCommands][len] = '\0';
            numCommands++;
            start = strchr(end + 1, '"');
        } else {
            break;
        }
    }
    
    printf("%s\n", solution(commands, numCommands));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×m)

Each command requires searching through n paths, with m average path length for string operations

✓ Linear Growth

Space Complexity

O(n×m)

Store n paths as strings, each of average length m

⚡ Linearithmic Space

34.2K Views

Medium Frequency

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

File System Simulator - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

String-Based Path Traversal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler