Remove Sub-Folders from the Filesystem - Practice Coding Problems

Remove Sub-Folders from the Filesystem - Problem

Imagine you're organizing a computer filesystem and need to clean up redundant folder paths. You have a list of folder paths, but some folders are actually sub-folders of others, creating unnecessary clutter.

Your task is to remove all sub-folders and keep only the root-level folders that aren't contained within any other folder in the list.

What makes a sub-folder? A folder is considered a sub-folder if:

It starts with another folder's path
Followed by a forward slash /
Then additional path components

Example: "/a/b" is a sub-folder of "/a", but "/b" is NOT a sub-folder of "/a/b/c"

Goal: Given a list of folder paths, return only the folders that aren't sub-folders of any other folder in the list. The order of the result doesn't matter.

Input & Output

example_1.py — Basic Case

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

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

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

example_2.py — No Subfolders

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

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

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

example_3.py — Nested Chain

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

› Output: ["/a"]

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

Visualization

Tap to expand

Understanding the Visualization

Initial State

We have mixed folder paths in random order

Sort Alphabetically

Sorting ensures subfolders appear right after their parents

Linear Scan

Check each folder against the last kept folder only

Clean Result

Keep only root folders, skip all subfolders

Key Takeaway

🎯 Key Insight: Sorting is the key optimization - it ensures that subfolders always appear immediately after their parent folders, allowing us to make the minimum number of comparisons needed.

Time & Space Complexity

Time Complexity

⏱️

O(n² × m)

n² for nested loops comparing all pairs, m for average string length comparison

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables, not counting the output array

✓ Linear Space

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

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal approach is to sort the folders alphabetically first, then perform a single linear scan. After sorting, any subfolder will appear immediately after its parent folder, so we only need to compare each folder with the last folder we decided to keep. This reduces the time complexity from O(n²) to O(n log n) and makes the solution much more efficient.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n² × m)	O(1)	Compare every folder against every other folder to find sub-folder relationships
Sorting + Linear Scan	O(n log n + n×m)	O(n)	Sort folders alphabetically, then check each folder against the previously kept folder

Brute Force (Nested Loops) — Algorithm Steps

Initialize result list with all folders
For each folder in the list, check against all other folders
If current folder starts with another folder + '/', mark it as sub-folder
Remove all marked sub-folders from result
Return the remaining folders

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with all folders as potential results

Compare All Pairs

For each folder, check if it's a subfolder of any other

Mark Subfolders

Mark folders that start with another folder + '/'

Filter Results

Keep only unmarked folders

Code -

solution.c — C

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

char** removeSubfolders(char** folder, int folderSize, int* returnSize) {
    char** result = (char**)malloc(folderSize * sizeof(char*));
    *returnSize = 0;
    
    for (int i = 0; i < folderSize; i++) {
        int isSubfolder = 0;
        
        // Check if current folder is a subfolder of any other folder
        for (int j = 0; j < folderSize; j++) {
            if (i != j) {
                int parentLen = strlen(folder[j]);
                if (strlen(folder[i]) > parentLen && 
                    strncmp(folder[i], folder[j], parentLen) == 0 &&
                    folder[i][parentLen] == '/') {
                    isSubfolder = 1;
                    break;
                }
            }
        }
        
        if (!isSubfolder) {
            result[*returnSize] = (char*)malloc((strlen(folder[i]) + 1) * sizeof(char));
            strcpy(result[*returnSize], folder[i]);
            (*returnSize)++;
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × m)

n² for nested loops comparing all pairs, m for average string length comparison

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables, not counting the output array

✓ Linear Space

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

52.3K Views

Medium Frequency

~15 min Avg. Time

1.8K 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

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler