i like my solution, kind of simple, understandable and fast:

class Solution:
    def simplifyPath(self, path):
        stack = []
        for c in path:
            if c == "/":
                while stack and (stack[-1] == "/" or stack[-1] == "."):
                    stack.pop()
                stack.append(c)
            elif c == ".":
                if stack and stack[-1] == ".": # .. command, moves up one directory
                    stack.pop()
                    if stack and stack[-1] == "/": 
                        stack.pop()
                    while stack and stack[-1] != "/":
                        stack.pop()
                else:
                    stack.append(c) # add ., maybe next . is .. command
            else:
                stack.append(c)

        #

class Solution:
    def simplifyPath(self, path):
        stack = []
        for index in range(len(path)):
            char = path[index]
            if stack:
                if char == "." and index != len(path)-1 and path[index+1] == char:
                    # Go back a dir, pop twice
                    stack.pop()
                    if stack:
                        stack.pop() # Always check for underflow while popping
                elif char == "/" and ((index != len(path)-1 and path[index+1] == char) or stack[-1] == char): 
                    # Simplify // to / by not pushing anything to stack
                    continue
            if char not in ["."]:
                # Ignore . and push char to stack
                stack.append(char)
        return "".join(

class Solution:
    def simplifyPath(self, path):
        
        stack = []
        i = 0 
        temp = []  # for accumulating sub path characters like "foo/home". it stores foo and home

        while i < len(path):
            # if we have perviously accumulated path push it to the stack
            if path[i] == "/" and len(temp) > 0:
                stack.append(''.join(temp))
                temp = []

            # ".." case. pop the previous element
            elif path[i] == "." and len(stack) > 0 and stack[-1] == '.':
                stack.pop()
                if len(stack) > 0:
                    stack.pop()

            # "/." case. pop the "."
            elif path[i] == "/" and len(stack) > 0 and stack[-1] == '.':
                stack.pop()

            #

So I ended up with that awful, yet working solution

class Solution:
    def simplifyPath(self, path):
        stack = []
        l = len(path)
        i = 0

        while i < l:
            char = path[i]

            if char == '/':
                while stack and stack[-1] == '/':
                    stack.pop()
            elif char == '.':
                if i < l - 1 and path[i + 1] == '.':
                    if stack and stack[-1] == '/':
                        stack.pop()

                    while stack and stack[-1] != '/':
                        stack.pop()

            if char != '.':
                stack.append(char)
            i += 1

        while stack and stack[-1] == '/':
            stack.pop()

        if not stack:
            return '/'

        re

In my view, even in Java, as for Python (where you have syntactic sugar like list comprehensions and tuple unpacking for example), the solution should leverage the language specific API.

In modern Java we don't use Stack anymore, so ArrayDeque should be used. In Java ArrayDeque is a double-ended queue that can be used to add elements to the head or to the tail and remove elements from the head and from the tail. Unlike LinkedList, ArrayDeque guarantees to retrieve the elements in the same order as they were entered when using an iterator (for loop).

import java.util.*;
import java.util.stream.*;
public class Solution {
    public String simplifyPath(String path) {
       Deque<String> stack = new ArrayDeque<>();
      
       var patWoSlash = path.split("/");