leetcode 71. Simplify Path（栈）

Given an absolute path for a file (Unix-style), simplify it. Or in other words, convert it to the canonical path.

In a UNIX-style file system, a period . refers to the current directory. Furthermore, a double period … moves the directory up a level.

Note that the returned canonical path must always begin with a slash /, and there must be only a single slash / between two directory names. The last directory name (if it exists) must not end with a trailing /. Also, the canonical path must be the shortest string representing the absolute path.

Example 1:

Input: “/home/”
Output: “/home”
Explanation: Note that there is no trailing slash after the last directory name.
Example 2:

Input: “/…/”
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: “/home//foo/”
Output: “/home/foo”
Explanation: In the canonical path, multiple consecutive slashes are replaced by a single one.
Example 4:

Input: “/a/./b/…/…/c/”
Output: “/c”
Example 5:

Input: “/a/…/…/b/…/c//.//”
Output: “/c”
Example 6:

Input: “/a//bc/d//././/…”
Output: “/a/b/c”

C++

class Solution {
public:
    string simplifyPath(string path) {
        string res,tmp;
        vector<string> s;
        stringstream ss(path);
        while(getline(ss,tmp,'/')){
            if(tmp=="" or tmp==".")continue;
            if(tmp!="..")
                s.push_back(tmp);
            else if(!s.empty())s.pop_back();
        }
        for(auto k:s)res+="/"+k;
        return res.empty()?"/":res;
    }
};

Java

class Solution {
    public String simplifyPath(String path) {
        Deque<String> s=new ArrayDeque<String>();
        for(String k:path.split("/")){
            if(k.equals("..")){
                if(!s.isEmpty())s.pop();
            } else if (!k.isEmpty()&&!k.equals(".")) {
                s.push(k);
            }
        }
        StringBuilder r=new StringBuilder();
        while(!s.isEmpty())
            r.append("/").append(s.pollLast());
        return r.length()==0?"/":r.toString();
    }
}

Python

class Solution:
    def simplifyPath(self, path: str) -> str:
        a=[p for p in path.split("/") if p!="." and p!=""]
        s=[]
        for k in a:
            if k=="..":
                if len(s)>0:
                    s.pop()
            else:
                s.append(k)
        return "/"+"/".join(s)

Go

func simplifyPath(path string) string {
    a:=strings.Split(path,"/")
    s:=[]string{}
    for _,k:=range a {
        if strings.EqualFold(k, "..") {
            if len(s)>0 {
                s=s[:len(s)-1] // pop
            }
        } else if strings.EqualFold(k, "") || strings.EqualFold(k, ".") {
            continue
        } else {
            s=append(s,k)
        }
    }
    r:=strings.Builder{}
    for _,k := range s {
        r.WriteString("/"+k)
    }
    if len(s)==0 {
        return "/"
    }
    return r.String()
}