Skip to content
Related Articles

Related Articles

Save Article
Improve Article
Save Article
Like Article

Simplify the directory path (Unix like)

  • Difficulty Level : Medium
  • Last Updated : 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.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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++




/* 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 path
string 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




/* Java program to simplify a Unix
styled 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

Python3




# 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#




// C# program to simplify a Unix
// styled absolute path of a file
using 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

Javascript




<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>
Output
/c

Time Complexity O(length of string).

Approach 2:

  1. In approach 1, the directories so formed, are first pushed into the stack and then the stack is reversed to form the canonical path.
  2. 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.
  3. 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++




// C++ implementation of optimized Approach 1
#include <bits/stdc++.h>
using namespace std;
 
// function to simplify a Unix - styled
// absolute path
string 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 Code
int 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




// Java implementation of optimized Approach 1
import 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




# Python3 implementation of optimized Approach 1
 
# function to simplify a Unix - styled
# absolute path
def 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#




// C# implementation of optimized Approach 1
using 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.

Javascript




<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>
Output
/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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :