# Simplify Path Leetcode Solution

In this post, we are going to solve the Simplify Path Leetcode Solution problem of Leetcode. This Leetcode problem is done in many programming languages like C++, Java, and Python.

## Problem

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.
```

Constraints:

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

Now, lets see the leetcode solution of Simplify Path Leetcode Solution.

### Simplify Path Leetcode Solution in Python

```class Solution:
def simplifyPath(self, path: str) -> str:
stack = []

for str in path.split('/'):
if str in ('', '.'):
continue
if str == '..':
if stack:
stack.pop()
else:
stack.append(str)

return '/' + '/'.join(stack)
```

### Simplify Path Leetcode Solutionin CPP

```class Solution {
public:
string simplifyPath(string path) {
string ans;
istringstream iss(path);
vector<string> stack;

for (string dir; getline(iss, dir, '/');) {
if (dir.empty() || dir == ".")
continue;
if (dir == "..") {
if (!stack.empty())
stack.pop_back();
} else {
stack.push_back(dir);
}
}

for (const string& s : stack)
ans += "/" + s;

return ans.empty() ? "/" : ans;
}
};
```

### Simplify Path Leetcode Solution in Java

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

for (final String dir : dirs) {
if (dir.isEmpty() || dir.equals("."))
continue;
if (dir.equals("..")) {
if (!stack.isEmpty())
stack.pop();
} else {
stack.push(dir);
}
}

return "/" + String.join("/", stack);
}
}
```

Note: This problem Simplify Path is generated by Leetcode but the solution is provided by Chase2learn This tutorial is only for Educational and Learning purposes.

Sharing Is Caring