Simplify the directory path (Unix like)

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

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

using System;
using System.Collections.Generic;
using System.IO;

class Solution {
    public static string SimplifyPath(string path)
    {
        // Create a stack to hold directory names
        Stack<string> stack = new Stack<string>();
        string[] tokens = path.Split('/');

        foreach(string token in tokens)
        {
            if (token == "..") {
                // Popping if ".." is found
                if (stack.Count > 0) {
                    stack.Pop();
                }
            }
            else if (!string.IsNullOrEmpty(token)
                     && token != ".") {
                // Pushing valid directory names onto the
                // stack
                stack.Push(token);
            }
        }

        // Build the final simplified path
        string finalPath = "";
        if (stack.Count == 0) {
            // Adding '/' to the final string if the stack
            // is empty
            finalPath = "/";
        }
        else {
            // Building the final simplified path from the
            // stack
            string[] directories = stack.ToArray();
            Array.Reverse(directories);
            finalPath = "/" + string.Join("/", directories);
        }

        return finalPath;
    }

    static void Main()
    {
        // Absolute path that needs to be simplified
        string str = "/a/./b/../../c/";
        string res = SimplifyPath(str);
        Console.WriteLine(res);
    }
}