Write a method that compares two semantic version strings such as `1.2.10` and `1.3.0`.

• Only numeric major, minor, and patch core parts are supported.
• Prerelease and build metadata suffixes are ignored for this exercise.
• Missing minor or patch values are treated as zero.
• More than three numeric parts is invalid.
• Invalid numeric parts throw ArgumentException.

I would remove any prerelease or build metadata suffix, parse the remaining version into exactly three integers, and fill missing parts with zero. Then I compare major, minor, and patch in order. I would not compare version strings lexicographically, because 1.10.0 would incorrectly sort before 1.2.0. I would also clarify that real semantic versioning has more detailed prerelease ordering rules; this exercise intentionally ignores them.

public static int CompareVersions(string left, string right)
{
    var leftParts = ParseVersion(left);
    var rightParts = ParseVersion(right);

    for (var i = 0; i < 3; i++)
    {
        var comparison = leftParts[i].CompareTo(rightParts[i]);
        if (comparison != 0)
        {
            return Math.Sign(comparison);
        }
    }

    return 0;
}

private static int[] ParseVersion(string version)
{
    if (string.IsNullOrWhiteSpace(version))
    {
        throw new ArgumentException("Version is required.", nameof(version));
    }

    var coreVersion = version.Split('+', 2)[0].Split('-', 2)[0];
    var rawParts = coreVersion.Split('.');
    if (rawParts.Length > 3)
    {
        throw new ArgumentException("Version cannot have more than three parts.", nameof(version));
    }

    var parts = new[] { 0, 0, 0 };
    for (var i = 0; i < rawParts.Length; i++)
    {
        if (!int.TryParse(rawParts[i], out var value) || value < 0)
        {
            throw new ArgumentException($"Invalid version part '{rawParts[i]}'.", nameof(version));
        }

        parts[i] = value;
    }

    return parts;
}

Parsing and comparison are O(1) because the method allows at most three numeric parts. Space is also O(1).

• Missing patch or minor values.
• 1.10.0 versus 1.2.0.
• 1.2.3-alpha compared as 1.2.3 for this exercise.
• Blank version string.
• Negative or non-numeric part.
• Too many parts.

• Use lexicographic traps such as 1.10 versus 1.2.
• Use 2, 2.0, and 2.0.0 to verify missing parts.
• Use 1.0.0-beta to confirm the suffix is ignored here.
• Use invalid values to verify validation, not silent zero.

• Comparing strings instead of numeric parts.
• Treating missing parts inconsistently.
• Silently accepting invalid versions.
• Claiming this fully implements semantic version prerelease rules.