My java 8ms solution 53% faster
IntuitionApproachComplexity
Time complexity:

Space complexity:
Code
# Intuition
<!-- Describe your first thoughts on how to solve this problem. -->

# Approach
<!-- Describe your approach to solving the problem. -->

# Complexity
- Time complexity:
<!-- Add your time complexity here, e.g. $$O(n)$$ -->

- Space complexity:
<!-- Add your space complexity here, e.g. $$O(n)$$ -->

# Code
```java []
class Solution {
    public List<String> ambiguousCoordinates(String s) {
        List<String> res = new ArrayList<>();
        getAllComb(s, res);
        return res;
    }

    public void getAllComb(String s, List<String> res){
        int n = s.length();
        for(int i = 1; i < n - 2; i++){
            List<String> left = getCombs(1, i, s);
            List<String> right = getCombs(i + 1, n - 2, s);
            for(String l : left){
                for(String r : right){
                    res.add("(" + l + ", " + r + ")");
                }
            }
        }
    }

    public List<String> getCombs(int idx, int eidx, String s){
        List<String> res = new ArrayList<>();
        if(idx == eidx){
            res.add(String.valueOf(s.charAt(idx)));
            return res;
        }
        for(int i = idx + 1; i <= eidx; i++){
            String left = s.substring(idx, i);
            String right = s.substring(i, eidx + 1);
            long nl = Long.parseLong(left);
            long nr = Long.parseLong(right);
            if(nr % 10 == 0 || (nl == 0 && left.length() > 1)){
                break;
            }
            res.add(left + "." + right);
            if(nl == 0){
                break;
            }
        }
        String subs = s.substring(idx, eidx + 1);
        long val = Long.parseLong(subs);
        if(String.valueOf(val).equals(subs)){
            res.add(subs);
        }
        return res;
    }
}
```
['Java']