Ambiguous Coordinates solution and explanation

def ambiguousCoordinates(S):
    def valid_parts(s):
        n = len(s)
        return [s[:i] + '.' + s[i:] for i in range(1, n)] + [s] if n == 1 or s[0] != '0' else []

    S = S[1:-1]
    res = []
    for i in range(1, len(S)):
        left, right = S[:i], S[i:]
        valid_left = valid_parts(left)
        valid_right = valid_parts(right)
        for a in valid_left:
            for b in valid_right:
                res.append(f'({a}, {b})')
    return res

# Example usage
assert ambiguousCoordinates('(123)') == ['(1, 2.3)', '(1, 23)', '(1.2, 3)', '(12, 3)']

import java.util.ArrayList;
import java.util.List;

public class AmbiguousCoordinates {
    public List<String> ambiguousCoordinates(String S) {
        List<String> result = new ArrayList<>();
        String s = S.substring(1, S.length() - 1);

        for (int i = 1; i < s.length(); i++) {
            List<String> leftParts = getValidParts(s.substring(0, i));
            List<String> rightParts = getValidParts(s.substring(i));

            for (String left : leftParts) {
                for (String right : rightParts) {
                    result.add("(" + left + ", " + right + ")");
                }
            }
        }

        return result;
    }

    private List<String> getValidParts(String s) {
        List<String> parts = new ArrayList<>();
        if (s.length() == 1 || s.charAt(0) != '0') {
            parts.add(s);
        }
        for (int i = 1; i < s.length(); i++) {
            String left = s.substring(0, i);
            String right = s.substring(i);

            if ((left.length() == 1 || left.charAt(0) != '0') && right.charAt(right.length() - 1) != '0') {
                parts.add(left + "." + right);
            }
        }
        return parts;
    }

    public static void main(String[] args) {
        AmbiguousCoordinates ac = new AmbiguousCoordinates();
        System.out.println(ac.ambiguousCoordinates("(123)"));
    }
}

function ambiguousCoordinates(s) {
    function generateValidParts(str) {
        let n = str.length;
        let res = [];

        if (n == 1 || str[0] !== '0') {
            res.push(str);
        }

        for (let i = 1; i < n; i++) {
            let left = str.substring(0, i);
            let right = str.substring(i);

            if ((left.length === 1 || left[0] !== '0') && right[right.length - 1] !== '0') {
                res.push(left + '.' + right);
            }
        }
        return res;
    }

    s = s.slice(1, -1);
    let results = [];

    for (let i = 1; i < s.length; i++) {
        let left = s.substring(0, i);
        let right = s.substring(i);

        let validLeft = generateValidParts(left);
        let validRight = generateValidParts(right);

        for (let l of validLeft) {
            for (let r of validRight) {
                results.push(`(${l}, ${r})`);
            }
        }
    }

    return results;
}

console.log(ambiguousCoordinates('(123)'));

using System;
using System.Collections.Generic;

public class Solution {
    public IList<string> AmbiguousCoordinates(string S) {
        List<string> result = new List<string>();
        string s = S.Substring(1, S.Length - 2);

        for (int i = 1; i < s.Length; i++) {
            var leftParts = GetValidParts(s.Substring(0, i));
            var rightParts = GetValidParts(s.Substring(i));

            foreach (var left in leftParts) {
                foreach (var right in rightParts) {
                    result.Add($"({left}, {right})");
                }
            }
        }

        return result;
    }

    private List<string> GetValidParts(string s) {
        var parts = new List<string>();

        if (s.Length == 1 || s[0] != '0') {
            parts.Add(s);
        }

        for (int i = 1; i < s.Length; i++) {
            var left = s.Substring(0, i);
            var right = s.Substring(i);

            if ((left.Length == 1 || left[0] != '0') && right[right.Length - 1] != '0') {
                parts.Add(left + "." + right);
            }
        }

        return parts;
    }

    public static void Main(string[] args) {
        var solution = new Solution();
        var coords = solution.AmbiguousCoordinates("(123)");
        foreach (var coord in coords) {
            Console.WriteLine(coord);
        }
    }
}

class Solution {
public:
    vector<string> ambiguousCoordinates(string s) {
        int n = s.size();
        vector<string> ans;
        auto f = [&](int i, int j) {
            vector<string> res;
            for (int k = 1; k <= j - i; ++k) {
                string l = s.substr(i, k);
                string r = s.substr(i + k, j - i - k);
                bool ok = (l == "0" || l[0] != '0') && r.back() != '0';
                if (ok) {
                    res.push_back(l + (k < j - i ? "." : "") + r);
                }
            }
            return res;
        };
        for (int i = 2; i < n - 1; ++i) {
            for (auto& x : f(1, i)) {
                for (auto& y : f(i, n - 1)) {
                    ans.emplace_back("(" + x + ", " + y + ")");
                }
            }
        }
        return ans;
    }
};

function ambiguousCoordinates(s: string): string[] {
    s = s.slice(1, s.length - 1);
    const n = s.length;
    const dfs = (s: string) => {
        const res: string[] = [];
        for (let i = 1; i < s.length; i++) {
            const t = `${s.slice(0, i)}.${s.slice(i)}`;
            if (`${Number(t)}` === t) {
                res.push(t);
            }
        }
        if (`${Number(s)}` === s) {
            res.push(s);
        }
        return res;
    };
    const ans: string[] = [];
    for (let i = 1; i < n; i++) {
        for (const left of dfs(s.slice(0, i))) {
            for (const right of dfs(s.slice(i))) {
                ans.push(`(${left}, ${right})`);
            }
        }
    }
    return ans;
}

func ambiguousCoordinates(s string) []string {
	f := func(i, j int) []string {
		res := []string{}
		for k := 1; k <= j-i; k++ {
			l, r := s[i:i+k], s[i+k:j]
			ok := (l == "0" || l[0] != '0') && (r == "" || r[len(r)-1] != '0')
			if ok {
				t := ""
				if k < j-i {
					t = "."
				}
				res = append(res, l+t+r)
			}
		}
		return res
	}

	n := len(s)
	ans := []string{}
	for i := 2; i < n-1; i++ {
		for _, x := range f(1, i) {
			for _, y := range f(i, n-1) {
				ans = append(ans, "("+x+", "+y+")")
			}
		}
	}
	return ans
}