Remove Sub-Folders from the Filesystem

Remove Sub-Folders from the Filesystem - Problem

Given a list of folders, return the folders after removing all sub-folders in those folders. You may return the answer in any order.

If a folder[i] is located within another folder[j], it is called a sub-folder of it. A sub-folder of folder[j] must start with folder[j], followed by a "/". For example, "/a/b" is a sub-folder of "/a", but "/b" is not a sub-folder of "/a/b/c".

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.

Input & Output

Example 1 — Basic Case

$ Input: folder = ["/a","/a/b","/c/d","/c/d/e","/c/f"]

› Output: ["/a","/c/d","/c/f"]

💡 Note: "/a/b" is a subfolder of "/a" and "/c/d/e" is a subfolder of "/c/d", so they are removed

Example 2 — No Subfolders

$ Input: folder = ["/a","/b","/c"]

› Output: ["/a","/b","/c"]

💡 Note: No folder is a subfolder of another, so all folders are kept

Example 3 — Deep Nesting

$ Input: folder = ["/a","/a/b/c","/a/b/d"]

› Output: ["/a"]

💡 Note: Both "/a/b/c" and "/a/b/d" are subfolders of "/a", so only "/a" remains

Constraints

1 ≤ folder.length ≤ 4 × 10⁴
2 ≤ folder[i].length ≤ 100
folder[i] contains only lowercase letters and '/'
folder[i] always starts with the character '/'
Each folder name is unique

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 12 G Google 8

The key insight is to sort folders alphabetically so parent folders appear before their subfolders. This allows us to check only against the last added folder instead of all folders. Best approach is sort first with Time: O(n log n), Space: O(n)

Common Approaches

✓ Brute Force - Check All Pairs

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

For each folder, check if it's a sub-folder of any other folder by comparing prefixes. If a folder starts with another folder followed by '/', it's a sub-folder and should be removed.

Sort First - Efficient Detection

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

By sorting the folders lexicographically, any parent folder will appear before its subfolders. We can then iterate through the sorted list and only check if the current folder is a subfolder of the previously added folder.

Brute Force - Check All Pairs — Algorithm Steps

Iterate through each folder
For each folder, check against all other folders
If current folder is a sub-folder of another, mark it for removal
Return folders that aren't sub-folders

Visualization

Tap to expand

Step-by-Step Walkthrough

Compare Each Pair

Check if one folder is a subfolder of another

Prefix Matching

Use string prefix matching with '/' separator

Filter Results

Keep only folders that aren't subfolders

Code -

solution.c — C

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

#define MAX_FOLDERS 40001
#define MAX_LEN 101

char folders[MAX_FOLDERS][MAX_LEN];
char* sortedPtrs[MAX_FOLDERS];
char* result[MAX_FOLDERS];
int folderCount = 0;

int compare(const void* a, const void* b) {
    return strcmp(*(char**)a, *(char**)b);
}

bool isSubfolder(const char* parent, const char* child) {
    int parentLen = strlen(parent);
    if (strncmp(child, parent, parentLen) != 0) {
        return false;
    }
    return child[parentLen] == '/';
}

int main() {
    char input[4000000];
    fgets(input, sizeof(input), stdin);
    
    char current[MAX_LEN] = "";
    int currIdx = 0;
    bool inString = false;
    
    for (int i = 0; input[i] != '\0'; i++) {
        char c = input[i];
        if (c == '"') {
            if (inString) {
                current[currIdx] = '\0';
                strcpy(folders[folderCount], current);
                sortedPtrs[folderCount] = folders[folderCount];
                folderCount++;
                currIdx = 0;
            }
            inString = !inString;
        } else if (inString) {
            current[currIdx++] = c;
        }
    }
    
    qsort(sortedPtrs, folderCount, sizeof(char*), compare);
    
    int resultCount = 0;
    
    for (int i = 0; i < folderCount; i++) {
        if (resultCount == 0) {
            result[resultCount++] = sortedPtrs[i];
        } else {
            if (!isSubfolder(result[resultCount - 1], sortedPtrs[i])) {
                result[resultCount++] = sortedPtrs[i];
            }
        }
    }
    
    printf("[");
    for (int i = 0; i < resultCount; i++) {
        if (i > 0) printf(",");
        printf("\"%s\"", result[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × m)

Nested loops over n folders, each string comparison takes O(m) time where m is average path length

⚡ Linearithmic

Space Complexity

O(1)

Only using variables for iteration, no extra data structures

⚡ Linearithmic Space

28.5K Views

Medium Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Pairs — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler