# 0071. Simplify Path

<https://leetcode.com/problems/simplify-path>

## Description

Given a string `path`, which is an **absolute path** (starting with a slash `'/'`) to a file or directory in a Unix-style file system, convert it to the simplified **canonical path**.

In a Unix-style file system, a period `'.'` refers to the current directory, a double period `'..'` refers to the directory up a level, and any multiple consecutive slashes (i.e. `'//'`) are treated as a single slash `'/'`. For this problem, any other format of periods such as `'...'` are treated as file/directory names.

The **canonical path** should have the following format:

* The path starts with a single slash `'/'`.
* Any two directories are separated by a single slash `'/'`.
* The path does not end with a trailing `'/'`.
* The path only contains the directories on the path from the root directory to the target file or directory (i.e., no period `'.'` or double period `'..'`)

Return *the simplified **canonical path***.

**Example 1:**

```
**Input:** path = "/home/"
**Output:** "/home"
**Explanation:** Note that there is no trailing slash after the last directory name.
```

**Example 2:**

```
**Input:** path = "/../"
**Output:** "/"
**Explanation:** Going one level up from the root directory is a no-op, as the root level is the highest level you can go.
```

**Example 3:**

```
**Input:** path = "/home//foo/"
**Output:** "/home/foo"
**Explanation:** In the canonical path, multiple consecutive slashes are replaced by a single one.
```

**Example 4:**

```
**Input:** path = "/a/./b/../../c/"
**Output:** "/c"
```

**Constraints:**

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

## ac

```java
// understanding of "simplify path" is the key

class Solution {
    public String simplifyPath(String path) {
        String[] list = path.split("/");
        Stack<String> stack = new Stack<String>();

        for (int i = 0; i < list.length; i++) {
            switch (list[i]) {
                case "":
                case ".":
                    continue;
                case "..":
                    if (!stack.isEmpty()) stack.pop();
                    break;
                default:
                    stack.push(list[i]);
            }
        }

        String res = "";
        while (!stack.isEmpty()) {
            res = "/" + stack.pop() + res;
        }

        return res.equals("") ? "/" : res;
    }
}
// split by / , get a list
// use a stack or two pointer simulating a stack

// “/b/c/” - directory 'b ’ - > directory 'c '
// "." - current directory
// "./" - current directory
// "../" - one directory up
// e.g
// "/" : root directory
// "b/c/../" : it will go from c to b
// "c/b/./" : it is still in directory b
```