Semantic Version Comparison and Constraints

PracticalmediumPremium

45:00

Desktop only

Coding Challenges are optimized for Desktop

Come back on a wider screen - the live editor needs room to breathe. You can still read the problem brief above.

Problem

Package managers resolve require declarations by comparing version strings - whether requests>=2.28 is satisfied by 2.28.1 requires numeric comparison, not lexicographic. Python's packaging, npm's semver, and Cargo all implement these primitives. You will build them: parse dotted versions into integers, compare them, binary-search for the earliest supporting version, and evaluate constraint expressions.

Level 1 - Parse and compare

parse_version("1.10.0") returns (1, 10, 0). A version with an empty or non-numeric segment ("1..2", "1.x", "") is invalid and raises ValueError.
compare_versions("1.10.0", "1.9.0") returns 1 because 10 > 9, not -1 from lexicographic compare.
Versions of differing length pad with zeros: "1.2" == "1.2.0".

Example:

parse_version("1.10.0")              # -> (1, 10, 0)
compare_versions("1.10.0", "1.9.0") # -> 1  (10 > 9 numerically)
# Lexicographic compare returns -1 because "10" < "9" as strings!
compare_versions("1.2", "1.2.0")    # -> 0  (pad shorter with zeros)

Level 2 - Find earliest supporting version

def find_earliest_supporting(versions, feature_test) -> str | None:
    """`feature_test(version)` returns True iff that version supports the feature.
    Assume the test is monotonic (once-supported = always-supported).
    Return the earliest version, or None if no version supports it."""

Sort the versions by parsed tuple and find the earliest one where feature_test returns True. Return None if none qualifies.

Example:

versions = ["1.10.0", "1.9.0", "1.0.0"]   # intentionally unsorted
find_earliest_supporting(
    versions,
    lambda v: parse_version(v) >= (1, 10, 0)
)
# -> "1.10.0"  (not "1.9.0" - must sort numerically first)

Level 3 - Constraint satisfaction

def satisfies_constraint(version: str, constraint: str) -> bool: ...

Supported constraint forms:

Constraint	Meaning
`>=1.2.3`, `<=`, `>`, `<`, `==`	comparison against the target
`^1.2.3`	`>= 1.2.3` and `< 2.0.0` (compatible-major)
`~1.2.3`	`>= 1.2.3` and `< 1.3.0` (compatible-minor)
`1.x`	any version with major `1`

Whitespace inside the constraint is allowed (">= 1.2.3"). Unknown operators raise ValueError.

Example:

satisfies_constraint("1.9.0", "^1.2.3")  # -> True  (>=1.2.3 and <2.0.0)
satisfies_constraint("2.0.0", "^1.2.3")  # -> False (next major)
satisfies_constraint("1.2.9", "~1.2.3")  # -> True  (>=1.2.3 and <1.3.0)
satisfies_constraint("1.3.0", "~1.2.3")  # -> False (next minor)
satisfies_constraint("1.9.9", "1.x")     # -> True  (any version with major 1)

Mastery checklist

Check	Why it matters
Parse to ints before comparing	`"1.10" < "1.9"` lexicographically; `parse_version` makes it `(1, 10) > (1, 9)`
Pad with zeros for differing length	`"1.2" == "1.2.0"` keeps comparison total-ordered
Operators are matched longest-first	`>=` must match before `>` or you'll mis-parse
`^X.Y.Z` upper bound is `<(X+1).0.0`, not `<X.Y+1.0`	The whole point of caret is compatible-major
Unknown constraint -> `ValueError`	Don't silently return False; the caller has a bug

Loading editor…

Premium content

The live editor for this challenge unlocks with Premium.

0/0 passed