Compare Version Numbers - Practice Coding Problems

Compare Version Numbers - Problem

Version Number Comparison

Imagine you're a software developer managing version releases for your application. You need to determine which version is newer when comparing version strings like "1.01" vs "1.001" or "1.0" vs "1.0.0".

Given two version strings version1 and version2, compare them to determine their relative ordering. Each version string consists of revisions separated by dots ('.'). The value of each revision is its integer conversion ignoring leading zeros.

To compare version strings, compare their revision values in left-to-right order. If one version string has fewer revisions, treat the missing revision values as 0.

Return:
• -1 if version1 < version2
• 1 if version1 > version2
• 0 if they are equal

Examples:
• "1.01" vs "1.001" → Both have revisions [1, 1], so they're equal
• "1.0" vs "1.0.0" → [1, 0] vs [1, 0, 0], treating missing as 0 makes them equal
• "0.1" vs "1.1" → First revision differs: 0 < 1

Input & Output

example_1.py — Basic Comparison

$ Input: version1 = "1.01", version2 = "1.001"

› Output: 0

💡 Note: Both versions have revisions [1, 1] after converting "01" and "001" to integer 1, ignoring leading zeros. Since 1 == 1 for both revisions, the versions are equal.

example_2.py — Different Lengths

$ Input: version1 = "1.0", version2 = "1.0.0"

› Output: 0

💡 Note: version1 has revisions [1, 0] while version2 has [1, 0, 0]. We treat missing revisions as 0, so version1 becomes [1, 0, 0]. All revisions match, so they're equal.

example_3.py — Clear Difference

$ Input: version1 = "0.1", version2 = "1.1"

› Output: -1

💡 Note: First revision comparison: 0 < 1, so version1 is less than version2. We return -1 immediately without checking further revisions.

Constraints

1 ≤ version1.length, version2.length ≤ 500
version1 and version2 only contain digits and '.'
version1 and version2 are valid version numbers
All the given revisions in version1 and version2 can be stored in a 32-bit integer

Visualization

Tap to expand

Understanding the Visualization

Setup

Initialize pointers at the start of both version strings

Extract

Parse current revision from both strings until we hit a dot or end

Convert

Convert revision strings to integers (removes leading zeros)

Compare

Compare the two integers - return result if different

Continue

If equal, advance pointers and repeat until both strings are exhausted

Key Takeaway

🎯 Key Insight: Use two pointers to parse both versions simultaneously, comparing revisions one at a time without storing all values in memory. This achieves optimal O(1) space complexity while maintaining O(n+m) time complexity.

Asked in

🍎 Apple 45 ⊞ Microsoft 38 a Amazon 32 G Google 28

The optimal approach uses two pointers to parse both version strings simultaneously in O(n+m) time and O(1) space. Instead of splitting and storing all revisions, we extract and compare one revision at a time, treating missing revisions as 0. This avoids unnecessary memory allocation and allows for early termination when a difference is found.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n + m)	O(1)	Use two pointers to parse both versions simultaneously without extra space
Split and Pad Approach	O(n + m)	O(n + m)	Split both versions, pad with zeros, then compare arrays

Two Pointers (Optimal) — Algorithm Steps

Initialize two pointers, one for each version string
Extract current revision from both versions simultaneously
Convert extracted revision strings to integers
Compare the two revision values
If different, return comparison result immediately
If same, advance both pointers past the dot and continue
Handle end-of-string cases by treating missing revisions as 0

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Set i=0 for version1, j=0 for version2

Extract Revisions

Parse current revision from both versions

Compare Values

Compare extracted integer values

Advance Pointers

Move pointers past dots to next revision

Code -

solution.c — C

#include <stdio.h>
#include <string.h>

int compareVersion(char* version1, char* version2) {
    int i = 0, j = 0;
    int n1 = strlen(version1), n2 = strlen(version2);
    
    while (i < n1 || j < n2) {
        // Extract next revision from version1
        int num1 = 0;
        while (i < n1 && version1[i] != '.') {
            num1 = num1 * 10 + (version1[i] - '0');
            i++;
        }
        
        // Extract next revision from version2
        int num2 = 0;
        while (j < n2 && version2[j] != '.') {
            num2 = num2 * 10 + (version2[j] - '0');
            j++;
        }
        
        // Compare current revisions
        if (num1 < num2) return -1;
        if (num1 > num2) return 1;
        
        // Move past the dots
        i++; j++;
    }
    
    return 0;
}

int main() {
    char version1[1000], version2[1000];
    fgets(version1, sizeof(version1), stdin);
    fgets(version2, sizeof(version2), stdin);
    
    // Remove newlines
    version1[strcspn(version1, "\n")] = 0;
    version2[strcspn(version2, "\n")] = 0;
    
    printf("%d\n", compareVersion(version1, version2));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Where n and m are the lengths of version1 and version2. We process each character at most once.

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for pointers and current revision values, constant extra space.

✓ Linear Space

52.3K Views

Medium Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler