Simplify the directory path (Unix like)

07 Sep, 2021
Given an absolute path for a file (Unix-style), simplify it. Note that absolute path always begin with ‘/’ ( root directory ), a dot in path represent current directory and double dot represents parent directory.Examples: 
"/a/./"   --> means stay at the current directory 'a'
"/a/b/.." --> means jump to the parent directory
              from 'b' to 'a'
"////"    --> consecutive multiple '/' are a  valid  
              path, they are equivalent to single "/".

Input : /home/
Output : /home

Input : /a/./b/../../c/
Output : /c

Input : /a/..
Output:/

Input : /a/../
Output : /

Input : /../../../../../a
Output : /a

Input : /a/./b/./c/./d/
Output : /a/b/c/d

Input : /a/../.././../../.
Output:/

Input : /a//b//c//////d
Output : /a/b/c/d
Note: The given input will always have a valid absolute path.
Approach 1:By looking at examples we can see that the above simplification process just behaves like a stack. Whenever we encounter any file’s name, we simply push it into the stack. when we come across ” . ” we do nothing. When we find “..” in our path, we simply pop the topmost element as we have to jump back to parent’s directory. When we see multiple “////” we just ignore them as they are equivalent to one single “/”. After iterating through the whole string the elements remaining in the stack is our simplified absolute path. We have to create another stack to reverse the elements stored inside the original stack and then store the result inside a string. 
C++
Java
Python3
C#
Javascript
/* C++ program to simplify a Unix   styled absolute path of a file */#include <bits/stdc++.h>using namespace std; // function to simplify a Unix - styled// absolute pathstring simplify(string A){    // stack to store the file's names.    stack<string> st;     // temporary string which stores the extracted    // directory name or commands("." / "..")    // Eg. "/a/b/../."    // dir will contain "a", "b", "..", ".";    string dir;     // contains resultant simplifies string.    string res;     // every string starts from root directory.    res.append("/");     // stores length of input string.    int len_A = A.length();     for (int i = 0; i < len_A; i++) {         // we will clear the temporary string        // every time to accommodate new directory        // name or command.        dir.clear();         // skip all the multiple '/' Eg. "/////""        while (A[i] == '/')            i++;         // stores directory's name("a", "b" etc.)        // or commands("."/"..") into dir        while (i < len_A && A[i] != '/') {            dir.push_back(A[i]);            i++;        }         // if dir has ".." just pop the topmost        // element if the stack is not empty        // otherwise ignore.        if (dir.compare("..") == 0) {            if (!st.empty())                st.pop();                   }         // if dir has "." then simply continue        // with the process.        else if (dir.compare(".") == 0)            continue;                 // pushes if it encounters directory's        // name("a", "b").        else if (dir.length() != 0)            st.push(dir);           }     // a temporary stack  (st1) which will contain    // the reverse of original stack(st).    stack<string> st1;    while (!st.empty()) {        st1.push(st.top());        st.pop();    }     // the st1 will contain the actual res.    while (!st1.empty()) {        string temp = st1.top();                 // if it's the last element no need        // to append "/"        if (st1.size() != 1)            res.append(temp + "/");        else            res.append(temp);         st1.pop();    }     return res;} // Driver code.int main(){    // absolute path which we have to simplify.    string str("/a/./b/../../c/");    string res = simplify(str);    cout << res;    return 0;}
/* Java program to simplify a Unixstyled absolute path of a file */import java.io.*;import java.util.*; class GFG{    public static void main(String []args)    {        // absolute path which we have to simplify.        String str = new String("/a/./b/../../c/");        String res = simplify(str);        System.out.println(res);    }     // function to simplify a Unix - styled    // absolute path    static String simplify(String A)    {        // Stack to store the file's names.        Stack<String> st = new Stack<String>();         // temporary String which stores the extracted        // directory name or commands("." / "..")        // Eg. "/a/b/../."                 // contains resultant simplifies String.        String res = "";         // every String starts from root directory.        res += "/";         // stores length of input String.        int len_A = A.length();         for (int i = 0; i < len_A; i++)        {             // we will clear the temporary String            // every time to accommodate new directory            // name or command.            // dir will contain "a", "b", "..", ".";            String dir = "";             // skip all the multiple '/' Eg. "/////""            while (i < len_A && A.charAt(i) == '/')                i++;             // stores directory's name("a", "b" etc.)            // or commands("."/"..") into dir            while (i < len_A && A.charAt(i) != '/')            {                dir += A.charAt(i);                i++;            }             // if dir has ".." just pop the topmost            // element if the Stack is not empty            // otherwise ignore.            if (dir.equals("..") == true)            {                if (!st.empty())                    st.pop();                }             // if dir has "." then simply continue            // with the process.            else if (dir.equals(".") == true)                continue;                         // pushes if it encounters directory's            // name("a", "b").            else if (dir.length() != 0)                st.push(dir);        }         // a temporary Stack (st1) which will contain        // the reverse of original Stack(st).        Stack<String> st1 = new Stack<String>();        while (!st.empty())        {                         st1.push(st.pop());            // st.pop();        }                  // the st1 will contain the actual res.        while (!st1.empty())        {                         // if it's the last element no need            // to append "/"            if (st1.size() != 1)                res += (st1.pop() + "/");            else                res += st1.pop();             // st1.pop();        }        return res;    } } // This code is contributed by ankush_953
# Python program to simplify a Unix# styled absolute path of a file # function to simplify a Unix - styled# absolute path  def simplify(A):    # stack to store the file's names.    st = []     # temporary string which stores the extracted    # directory name or commands("." / "..")    # Eg. "/a/b/../."    # dir will contain "a", "b", "..", ".";    dir = ""     # contains resultant simplifies string.    res = ""     # every string starts from root directory.    res += "/"     # stores length of input string.    len_A = len(A)    i = 0    while i < len_A:         # we will clear the temporary string        # every time to accommodate new directory        # name or command.        dir_str = ""         # skip all the multiple '/' Eg. "##/""        while (i < len_A and A[i] == '/'):            i += 1         # stores directory's name("a", "b" etc.)        # or commands("."/"..") into dir        while (i < len_A and A[i] != '/'):            dir_str += A[i]            i += 1         # if dir has ".." just pop the topmost        # element if the stack is not empty        # otherwise ignore.        if dir_str == "..":            if len(st):                st.pop()         # if dir has "." then simply continue        # with the process.        elif dir_str == '.':            continue         # pushes if it encounters directory's        # name("a", "b").        elif len(dir_str) > 0:            st.append(dir_str)         i += 1     # a temporary stack (st1) which will contain    # the reverse of original stack(st).    st1 = []    while len(st):        st1.append(st[-1])        st.pop()     # the st1 will contain the actual res.    while len(st1):        temp = st1[-1]         # if it's the last element no need        # to append "/"        if (len(st1) != 1):            res += (temp + "/")        else:            res += temp        st1.pop()     return res  # Driver code. # absolute path which we have to simplify.string = "/a/./b/../../c/"res = simplify(string)print(res) # This code is contributed by ankush_953
// C# program to simplify a Unix// styled absolute path of a fileusing System;using System.Collections.Generic; class GFG{    public static void Main(String []args)    {        // absolute path which we have to simplify.        String str = ("/a/./b/../../c/");        String res = simplify(str);        Console.WriteLine(res);    }     // function to simplify a Unix - styled    // absolute path    static String simplify(String A)    {        // Stack to store the file's names.        Stack<String> st = new Stack<String>();         // temporary String which stores the extracted        // directory name or commands("." / "..")        // Eg. "/a/b/../."                 // contains resultant simplifies String.        String res = "";         // every String starts from root directory.        res += "/";         // stores length of input String.        int len_A = A.Length;         for (int i = 0; i < len_A; i++)        {             // we will clear the temporary String            // every time to accommodate new directory            // name or command.            // dir will contain "a", "b", "..", ".";            String dir = "";             // skip all the multiple '/' Eg. "/////""            while (i < len_A && A[i] == '/')                i++;             // stores directory's name("a", "b" etc.)            // or commands("."/"..") into dir            while (i < len_A && A[i] != '/')            {                dir += A[i];                i++;            }             // if dir has ".." just pop the topmost            // element if the Stack is not empty            // otherwise ignore.            if (dir.Equals("..") == true)            {                if (st.Count!=0)                    st.Pop();                }             // if dir has "." then simply continue            // with the process.            else if (dir.Equals(".") == true)                continue;                         // pushes if it encounters directory's            // name("a", "b").            else if (dir.Length != 0)                st.Push(dir);        }         // a temporary Stack (st1) which will contain        // the reverse of original Stack(st).        Stack<String> st1 = new Stack<String>();        while (st.Count!=0)        {                         st1.Push(st.Pop());            // st.pop();        }                  // the st1 will contain the actual res.        while (st1.Count!=0)        {                         // if it's the last element no need            // to append "/"            if (st1.Count!= 1)                res += (st1.Pop() + "/");            else                res += st1.Pop();             // st1.pop();        }        return res;    }} // This code is contributed by Rajput-Ji
<script>    // Javascript program to simplify a Unix    // styled absolute path of a file         // function to simplify a Unix - styled    // absolute path    function simplify(A)    {        // Stack to store the file's names.        let st = [];          // temporary String which stores the extracted        // directory name or commands("." / "..")        // Eg. "/a/b/../."                  // contains resultant simplifies String.        let res = "";          // every String starts from root directory.        res += "/";          // stores length of input String.        let len_A = A.length;          for (let i = 0; i < len_A; i++)        {              // we will clear the temporary String            // every time to accommodate new directory            // name or command.            // dir will contain "a", "b", "..", ".";            let dir = "";              // skip all the multiple '/' Eg. "/////""            while (i < len_A && A[i] == '/')                i++;              // stores directory's name("a", "b" etc.)            // or commands("."/"..") into dir            while (i < len_A && A[i] != '/')            {                dir += A[i];                i++;            }              // if dir has ".." just pop the topmost            // element if the Stack is not empty            // otherwise ignore.            if (dir == "..")            {                if (st.length!=0)                    st.pop();               }              // if dir has "." then simply continue            // with the process.            else if (dir == ".")                continue;                          // pushes if it encounters directory's            // name("a", "b").            else if (dir.length != 0)                st.push(dir);        }          // a temporary Stack (st1) which will contain        // the reverse of original Stack(st).        let st1 = [];        while (st.length!=0)        {                          st1.push(st[st.length - 1]);            st.pop();        }                    // the st1 will contain the actual res.        while (st1.length!=0)        {                          // if it's the last element no need            // to append "/"            if (st1.length!= 1)            {                res += (st1[st1.length - 1] + "/");                st.pop();            }            else            {                res += st1[st1.length - 1];                st1.pop();            }        }        return res;    }         // absolute path which we have to simplify.    let str = ("/a/./b/../../c/");    let res = simplify(str);    document.write(res);         // This code is contributed by divyesh072019.</script>
/c
Time Complexity O(length of string).
Approach 2:
In approach 1, the directories so formed, are first pushed into the stack and then the stack is reversed to form the canonical path.The only optimization here is to reduce the number of stack operations and this can be done by using vectors in place of a stack.Push and pop operations can be done in vector using push_back() and pop_back() functions respectively and the canonical path can be generated by simply traversing the vector from left to right.
In approach 1, the directories so formed, are first pushed into the stack and then the stack is reversed to form the canonical path.
The only optimization here is to reduce the number of stack operations and this can be done by using vectors in place of a stack.
Push and pop operations can be done in vector using push_back() and pop_back() functions respectively and the canonical path can be generated by simply traversing the vector from left to right.
Below is the implementation of approach 1 using vectors.
C++
Java
Python3
C#
Javascript
// C++ implementation of optimized Approach 1#include <bits/stdc++.h>using namespace std; // function to simplify a Unix - styled// absolute pathstring simplify(string path){    // using vector in place of stack    vector<string> v;    int n = path.length();    string ans;    for (int i = 0; i < n; i++) {        string dir = "";        // forming the current directory.        while (i < n && path[i] != '/') {            dir += path[i];            i++;        }         // if ".." , we pop.        if (dir == "..") {            if (!v.empty())                v.pop_back();        }        else if (dir == "." || dir == "") {            // do nothing (added for better understanding.)        }        else {            // push the current directory into the vector.            v.push_back(dir);        }    }     // forming the ans    for (auto i : v) {        ans += "/" + i;    }     // vector is empty    if (ans == "")        return "/";     return ans;} // Driver Codeint main(){    // absolute path which we have to simplify.    string str("/a/./b/../../c/");    string res = simplify(str);    cout << res;    return 0;} // This code is contributed by yashbeersingh42
// Java implementation of optimized Approach 1import java.util.*;public class Main{    // function to simplify a Unix - styled    // absolute path    static String simplify(String path)    {                // using vector in place of stack        Vector<String> v = new Vector<String>();        int n = path.length();        String ans = "";        for (int i = 0; i < n; i++) {            String dir = "";                        // forming the current directory.            while (i < n && path.charAt(i) != '/') {                dir += path.charAt(i);                i++;            }                   // if ".." , we pop.            if (dir.equals("..")) {                if (v.size() != 0)                {                    v.remove(v.size() - 1);                }            }            else if (dir.equals(".") || dir.equals("")) {                // do nothing (added for better understanding.)            }            else {                // push the current directory into the vector.                v.add(dir);            }        }               // forming the ans        for(String i : v) {            ans += "/" + i;        }               // vector is empty        if (ans == "")            return "/";               return ans;    }         public static void main(String[] args) {        // absolute path which we have to simplify.        String str = "/a/./b/../../c/";        String res = simplify(str);        System.out.print(res);    }} // This code is contributed by decode2207.
# Python3 implementation of optimized Approach 1 # function to simplify a Unix - styled# absolute pathdef simplify(path):       # using vector in place of stack    v = []    n = len(path)    ans = ""    for i in range(n):        Dir = ""                 # forming the current directory.        while (i < n and path[i] != '/'):            Dir += path[i]            i+=1          # if ".." , we pop.        if (Dir == "..") :            if (len(v) > 0):                v.pop()        elif (Dir == "." or Dir == ""):            # do nothing (added for better understanding.)            continue        else:            # push the current directory into the vector.            v.append(Dir)      # forming the ans    for i in v:        ans += "/" + i      # vector is empty    if (ans == ""):        return "/"      return ans # absolute path which we have to simplify.Str = "/a/./b/../../c/"res = simplify(Str)print(res) # This code is contributed by rameshtravel07
// C# implementation of optimized Approach 1using System;using System.Collections.Generic;class GFG {         // function to simplify a Unix - styled    // absolute path    static string simplify(string path)    {               // using vector in place of stack        List<string> v = new List<string>();        int n = path.Length;        string ans = "";        for (int i = 0; i < n; i++) {            string dir = "";                       // forming the current directory.            while (i < n && path[i] != '/') {                dir += path[i];                i++;            }                  // if ".." , we pop.            if (dir == "..") {                if (v.Count != 0)                    v.RemoveAt(v.Count - 1);            }            else if (dir == "." || dir == "") {                // do nothing (added for better understanding.)            }            else {                // push the current directory into the vector.                v.Add(dir);            }        }              // forming the ans        foreach(string i in v) {            ans += "/" + i;        }              // vector is empty        if (ans == "")            return "/";              return ans;    }   static void Main()  {         // absolute path which we have to simplify.    string str = "/a/./b/../../c/";    string res = simplify(str);    Console.Write(res);  }} // This code is contributed by divyeshrabadiya07.
<script>    // Javascript implementation of optimized Approach 1         // function to simplify a Unix - styled    // absolute path    function simplify(path)    {        // using vector in place of stack        let v = [];        let n = path.length;        let ans = "";        for (let i = 0; i < n; i++) {            let dir = "";                         // forming the current directory.            while (i < n && path[i] != '/') {                dir += path[i];                i++;            }             // if ".." , we pop.            if (dir == "..") {                if (v.length > 0)                    v.pop();            }            else if (dir == "." || dir == "") {                // do nothing (added for better understanding.)            }            else {                // push the current directory into the vector.                v.push(dir);            }        }         // forming the ans        for(let i of v) {            ans += "/" + i;        }         // vector is empty        if (ans == "")            return "/";         return ans;    }         // absolute path which we have to simplify.    let Str = "/a/./b/../../c/";    let res = simplify(Str);    document.write(res); // This code is contributed by mukesh07.</script>
/c
    Time Complexity: O(length of string).
This article is contributed by arshpreet soodan. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
Akanksha_Rai
ankush_953
Rajput-Ji
preethisun
yashbeersingh42
clintra
rameshtravel07
mukesh07
divyeshrabadiya07
divyesh072019
decode2207
Stack
Strings
Strings
Stack
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Introduction to Data Structures
What is Data Structure: Types, Classifications and Applications
Design a stack with operations on middle element
How to efficiently implement k stacks in a single array?
Real-time application of Data Structures
Write a program to reverse an array or string
Reverse a string in Java
Write a program to print all permutations of a given string
C++ Data Types
Different Methods to Reverse a String in C++