Simplify Path

Simplify Path - Problem

String Stack Medium

You are given an absolute path for a Unix-style file system, which always begins with a slash '/'. Your task is to transform this absolute path into its simplified canonical path.

The rules of a Unix-style file system are as follows:

A single period '.' represents the current directory.
A double period '..' represents the previous/parent directory.
Multiple consecutive slashes such as '//' and '///' are treated as a single slash '/'.
Any sequence of periods that does not match the rules above should be treated as a valid directory or file name. For example, '...' and '....' are valid directory or file names.

The simplified canonical path should follow these rules:

The path must start with a single slash '/'.
Directories within the path must be separated by exactly one slash '/'.
The path must not end with a slash '/', unless it is the root directory.
The path must not have any single or double periods ('.' and '..') used to denote current or parent directories.

Return the simplified canonical path.

Input & Output

Example 1 — Basic Path Simplification

$ Input: path = "/home/"

› Output: "/home"

💡 Note: Remove trailing slash except for root directory

Example 2 — Parent Directory Navigation

$ Input: path = "/home/../var/./log/../"

› Output: "/var"

💡 Note: Start with home, go back with .., enter var, stay with ., enter log, go back with ..

Example 3 — Multiple Consecutive Slashes

$ Input: path = "/home//foo/"

› Output: "/home/foo"

💡 Note: Multiple slashes '//' treated as single '/', remove trailing slash

Constraints

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

Visualization

Tap to expand

Asked in

f Facebook 15 a Amazon 12 G Google 8 M Microsoft 6

The key insight is to use a stack to track valid directory names while processing path components. Split the path by '/' delimiter, then for each component: push valid names onto stack, pop for '..' (parent directory), and ignore '.' (current directory). The stack approach naturally handles the navigation logic. Time: O(n), Space: O(n)

Common Approaches

✓ Character-by-Character Processing

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

Iterate through each character, manually handling slashes, dots, and directory names. This approach requires complex state tracking for current directory name and multiple edge cases.

Stack-Based Directory Tracking

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

Split the input path by '/' delimiter to get individual components, then use a stack to track valid directories. Push valid names, pop for '..', and ignore '.' components.

Character-by-Character Processing — Algorithm Steps

Step 1: Iterate through each character
Step 2: Track current directory name being built
Step 3: Handle special cases for '.', '..', and multiple slashes
Step 4: Build result string manually

Visualization

Tap to expand

Step-by-Step Walkthrough

Character Scan

Process each character individually

State Tracking

Track current directory being built

Result Building

Manually construct result string

Code -

solution.c — C

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

char* solution(char* path) {
    char** stack = (char**)malloc(1000 * sizeof(char*));
    int top = 0;
    char* token = strtok(path, "/");
    
    while (token != NULL) {
        if (strcmp(token, "..") == 0) {
            if (top > 0) {
                free(stack[--top]);
            }
        } else if (strcmp(token, ".") != 0) {
            stack[top] = (char*)malloc((strlen(token) + 1) * sizeof(char));
            strcpy(stack[top], token);
            top++;
        }
        token = strtok(NULL, "/");
    }
    
    char* result = (char*)malloc(10000 * sizeof(char));
    strcpy(result, "/");
    
    for (int i = 0; i < top; i++) {
        if (i > 0) strcat(result, "/");
        strcat(result, stack[i]);
        free(stack[i]);
    }
    
    free(stack);
    return result;
}

int main() {
    char path[10000];
    fgets(path, sizeof(path), stdin);
    path[strcspn(path, "\n")] = 0;
    
    char* result = solution(path);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string of length n

✓ Linear Growth

Space Complexity

O(n)

Result string storage in worst case

⚡ Linearithmic Space

78.0K Views

High Frequency

~25 min Avg. Time

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

Character-by-Character Processing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler