Simplify Path - Practice Coding Problems

Simplify Path - Problem

String Stack Medium

Imagine you're building a Unix terminal navigation system that needs to clean up messy file paths! 🗂️

You're given an absolute path for a Unix-style file system (always starting with '/'), and your job is to transform it into its simplified canonical form.

Unix Path Rules:

'.' = current directory (ignore it)
'..' = go back to parent directory
'///' = treat multiple slashes as single '/'
'...' or '.abc' = valid directory names

Canonical Path Rules:

Must start with single '/'
Directories separated by exactly one '/'
No trailing '/' (except root)
No '.' or '..' components

Examples:
"/home//foo/" → "/home/foo"
"/a/./b/../../c/" → "/c"
"/../" → "/"

Input & Output

example_1.py — Basic Path

$ Input: "/home/"

› Output: "/home"

💡 Note: Trailing slash is removed, but the directory remains

example_2.py — Complex Navigation

$ Input: "/a/./b/../../c/"

› Output: "/c"

💡 Note: '.' is ignored, '..' goes back to parent, so we go: /a → /a/b → /a → / → /c

example_3.py — Root Edge Case

$ Input: "/../"

› Output: "/"

💡 Note: Cannot go above root directory, so '..' from root stays at root

Constraints

1 ≤ path.length ≤ 3000
path consists of English letters, digits, period '.', slash '/' or underscore '_'
path is a valid absolute Unix path

Visualization

Tap to expand

Understanding the Visualization

Parse Path

Split the path into individual components separated by '/'

Stack Processing

Use a stack to track your current location in the directory tree

Handle Components

Push directories, ignore '.', pop on '..' operations

Build Result

Join the final stack contents to create the canonical path

Key Takeaway

🎯 Key Insight: A stack naturally models the directory hierarchy - pushing when going deeper into directories and popping when going back to parent directories with '..' operations.

Asked in

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

The optimal solution uses a stack-based approach to process path components in a single pass. We split the path by '/' and for each component: push directories onto the stack, ignore '.' (current directory), and pop from stack when we see '..' (parent directory). Finally, join the stack contents with '/' to get the canonical path. Time: O(n), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (String Manipulation)	O(n²)	O(n)	Split path, manually track position through multiple passes
Stack-Based Approach (Optimal)	O(n)	O(n)	Use stack to track directory hierarchy in single pass

Brute Force (String Manipulation) — Algorithm Steps

Split path by '/' separator
Initialize result path as empty
For each component, decide action
Manually rebuild path each time we go back
Handle edge cases with multiple passes

Visualization

Tap to expand

Step-by-Step Walkthrough

Split Path

Break '/a/./b/../c' into ['a', '.', 'b', '..', 'c']

Filter Dots

Remove '.' components: ['a', 'b', '..', 'c']

Process '..'

When we see '..', remove it and previous component

Rebuild Path

Join remaining components with '/' separator

Code -

solution.c — C

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

char* simplifyPath(char* path) {
    char* components[1000];
    int count = 0;
    
    // Tokenize path
    char* pathCopy = malloc(strlen(path) + 1);
    strcpy(pathCopy, path);
    
    char* token = strtok(pathCopy, "/");
    while (token != NULL) {
        if (strcmp(token, ".") != 0 && strlen(token) > 0) {
            components[count] = malloc(strlen(token) + 1);
            strcpy(components[count], token);
            count++;
        }
        token = strtok(NULL, "/");
    }
    
    // Process with multiple passes
    int i = 0;
    while (i < count) {
        if (strcmp(components[i], "..") == 0) {
            if (i > 0) {
                // Remove previous and current
                free(components[i-1]);
                free(components[i]);
                for (int j = i-1; j < count-2; j++) {
                    components[j] = components[j+2];
                }
                count -= 2;
                i = (i >= 2) ? i-2 : 0;
            } else {
                // Just remove current
                free(components[i]);
                for (int j = i; j < count-1; j++) {
                    components[j] = components[j+1];
                }
                count--;
            }
            continue;
        }
        i++;
    }
    
    // Build result
    char* result = malloc(3000);
    strcpy(result, "/");
    for (i = 0; i < count; i++) {
        if (i > 0) strcat(result, "/");
        strcat(result, components[i]);
        free(components[i]);
    }
    
    free(pathCopy);
    return result;
}

int main() {
    char input[3000];
    fgets(input, sizeof(input), stdin);
    // Remove quotes and newline
    input[strlen(input)-1] = '\0';
    if (input[0] == '"') {
        memmove(input, input+1, strlen(input));
        input[strlen(input)-1] = '\0';
    }
    
    char* result = simplifyPath(input);
    printf("\"%s\"\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each '..' operation potentially requires rebuilding the entire path, leading to quadratic time in worst case

⚠ Quadratic Growth

Space Complexity

O(n)

Space for splitting the path and storing intermediate results

⚡ Linearithmic Space

125.0K Views

High Frequency

~18 min Avg. Time

2.9K 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 (String Manipulation) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler