Simplify Path

                                            
class Solution {
public:
    string simplifyPath(string path) {
        stack<string> st;
        string res, dir;
        
        stringstream ss(path);
        
        while(getline(ss, dir, '/')) {
            if (dir == "" || dir == ".") {
                continue;
            } else if (dir == ".." && !st.empty()) {
                st.pop();
            } else if (dir != "..") {
                st.push(dir);
            }
        }
        
        while (!st.empty()) {
            res = "/" + st.top() + res;
            st.pop();
        }
        
        return res.empty() ? "/" : res;
    }
};

                                            
class Solution {
    public String simplifyPath(String path) {
        Deque<String> stack = new ArrayDeque<>();
        Set<String> skip = new HashSet<>(Arrays.asList("..", ".", ""));
        
        for (String dir : path.split("/")) {
            if (dir.equals("..") && !stack.isEmpty()) {
                stack.pop();
            } else if (!skip.contains(dir)) {
                stack.push(dir);
            }
        }
        
        String result = "";
        for (String dir : stack) {
            result = "/" + dir + result;
        }
        
        return result.isEmpty() ? "/" : result;
    }
}

                                            
class Solution(object):
    def simplifyPath(self, path):
        stack = []
        components = path.split('/')
        
        for component in components:
            if component == '..':
                if stack:
                    stack.pop()
            elif component and component != '.':
                stack.append(component)
        
        return '/' + '/'.join(stack)

                                            
public class Solution {
    public string SimplifyPath(string path) {
        Stack<string> stack = new Stack<string>();
        
        string[] components = path.Split('/');
        
        foreach(string component in components) {
            if(component.Equals("..")) {
                if(stack.Count > 0) {
                    stack.Pop();
                }
            } else if(!component.Equals(".") && !string.IsNullOrEmpty(component)) {
                stack.Push(component);
            }
        }
        
        string[] resultComponents = stack.ToArray();
        Array.Reverse(resultComponents);
        
        return "/" + string.Join("/", resultComponents);
    }
}

                                            
/**
 * @param {string} path
 * @return {string}
 */
const simplifyPath = (path) => {
    const stack = [];
    
    for (let dir of path.split('/')) {
        if (dir === '' || dir === '.') {
            continue;
        } else if (dir === '..') {
            stack.pop();
        } else {
            stack.push(dir);
        }
    }
    
    return '/' + stack.join('/');
};

                                            
function simplifyPath(path: string): string {
    const stack = [];
    const parts = path.split('/');

    for (let part of parts) {
        if (part === '' || part === '.') {
            continue;
        } else if (part === '..') {
            stack.pop();
        } else {
            stack.push(part);
        }
    }

    return '/' + stack.join('/');
};

                                            
class Solution {
    /**
     * @param String $path
     * @return String
     */
    function simplifyPath($path) {
        $parts = explode('/', $path);
        $stack = [];
        
        foreach ($parts as $part) {
            if ($part == '' || $part == '.') {
                continue;
            } elseif ($part == '..') {
                array_pop($stack);
            } else {
                array_push($stack, $part);
            }
        }
        
        return '/' . implode('/', $stack);
    }
}

                                            
class Solution {
    func simplifyPath(_ path: String) -> String {
        var stack = [String]()

        let components = path.components(separatedBy: "/")

        for component in components {
            if component == "" || component == "." {
                continue
            } else if component == ".." {
                if !stack.isEmpty {
                    stack.removeLast()
                }
            } else {
                stack.append(component)
            }
        }

        return "/" + stack.joined(separator: "/")
    }
}

                                            
class Solution {
    fun simplifyPath(path: String): String {
        val stack = mutableListOf<String>()
        val components = path.split("/")

        for (component in components) {
            when (component) {
                "", "." -> { }
                ".." -> if (stack.isNotEmpty()) stack.removeAt(stack.size - 1)
                else -> stack.add(component)
            }
        }

        return "/" + stack.joinToString("/")
    }
}

                                            
class Solution {
  String simplifyPath(String path) {
    List<String> stack = [];

    for (String dir in path.split('/')) {
      if (dir == '..') {
        if (stack.isNotEmpty) stack.removeLast();
      } else if (dir != '' && dir != '.') {
        stack.add(dir);
      }
    }

    return '/' + stack.join('/');
  }
}

                                            
func simplifyPath(path string) string {
    stack := []string{}
    dirs := strings.Split(path, "/")
    
    for _, dir := range dirs {
        if dir == "" || dir == "." {
            continue
        } else if dir == ".." {
            if len(stack) > 0 {
                stack = stack[:len(stack)-1]
            }
        } else {
            stack = append(stack, dir)
        }
    }
    
    result := "/" + strings.Join(stack, "/")
    
    return result
}

                                            
# @param {String} path
# @return {String}
def simplify_path(path)
    stack = []
    
    path.split('/').each do |dir|
        next if dir.empty? || dir == '.'
        
        if dir == '..'
            stack.pop
        else
            stack.push(dir)
        end
    end
    
    '/' + stack.join('/')
end

                                            
impl Solution {
    pub fn simplify_path(path: String) -> String {
        let mut stack: Vec<&str> = Vec::new();
        
        for dir in path.split("/") {
            match dir {
                "" | "." => continue,
                ".." => { stack.pop(); },
                _ => stack.push(dir),
            }
        }
        
        "/".to_string() + &stack.join("/")
    }
}

To solve this coding challenge, we need to create a function that takes an absolute Unix-like file path as input and returns its simplified canonical path. The key aspects of this problem are understanding the significance of ".", "..", and multiple slashes ("/") and manipulating the path accordingly.

Explanation

Initial Setup :

The input path is always an absolute path, meaning it starts with a "/".
We need to use a stack data structure to keep track of the directory levels as we process each component of the path.

Processing Path Components :

Split the path by the "/" character. This allows us to evaluate each component one by one.
Iterate through each component:

If the component is ".." and the stack is not empty, we pop an element from the stack (move up one directory level).
If the component is "." or an empty string (from multiple slashes), we skip it (remain in the current directory).
Otherwise, we push the component to the stack (move into a new directory).

Constructing the Canonical Path :

Join the components in the stack with a single "/" and prepend a "/" to represent the root.
Ensure the result does not end with a slash unless it's the root directory.

By following these steps, we simplify the path according to Unix file system rules.

Detailed Steps in Pseudocode

Here, we elaborate each step with detailed pseudocode including comments to make the logic clear.

Initial Setup

Define a function
simplifyPath

that takes the
path

as an input.
Initialize an empty stack for tracking directories.

Processing Path Components

Split the path by "/" to break it into components.
Loop through each component from the split path:

If the component is "..":

If the stack is not empty, remove the top element from the stack (go up one directory).

Else if the component is not an empty string and not ".":

Add the component to the stack (move to the specified directory).

Constructing the Simplified Path

Join the stack elements with "/" into a single string.
Add the leading "/" to denote the root directory.
Return the resulting simplified path.

Pseudocode

                                            
# Define the function that simplifies the given Unix path
function SimplifyPath(path):

  # Initialize an empty stack to hold the directories in the path
  stack = []

  # Split the path by "/" to get all the components
  components = Split(path, '/')

  # Iterate over each component in the split path
  for component in components:
    
    # If the component is ".." and the stack is not empty
    if component == "..":
      If stack is not empty:
        # Pop from the stack to go back one directory level
        Pop from stack
    
    # Else if the component is "." or an empty string, skip it
    else if component == "." or component is an empty string:
      # Do nothing as we stay in current directory
      continue
    
    # Otherwise, it is a valid directory name
    else:
      # Add the directory name to the stack
      Push component to stack

  # Join the stack with "/" to form the simplified path
  simplified_path = "/" + Join(stack, '/')

  # Return the resulting simplified path
  return simplified_path

In this pseudocode,

Split

represents the operation to split a string by a delimiter, and

Join

represents concatenation of list elements with a specified delimiter. The pseudocode closely mimics the logical steps necessary to achieve the solution.