Compare Version Numbers

Compare Version Numbers - Problem

Given two version strings version1 and version2, compare them.

A version string consists of revisions separated by dots '.'. The value of the revision is its integer conversion ignoring leading zeros.

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

Return the following:

If version1 < version2, return -1
If version1 > version2, return 1
Otherwise, return 0

Input & Output

Example 1 — Basic Comparison

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

› Output: 0

💡 Note: Both versions have revisions [1, 1] after removing leading zeros from "01" and "001", so they are equal

Example 2 — Missing Revision

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

› Output: 0

💡 Note: version1 has revisions [1, 0] and version2 has [1, 0, 0]. Missing revisions are treated as 0, so they are equal

Example 3 — Clear Difference

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

› Output: -1

💡 Note: First revision: 0 < 1, so version1 is smaller than version2

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

Asked in

Apple 15 M Microsoft 12 a Amazon 8

The key insight is to compare version strings by parsing revisions numerically while treating missing revisions as 0 and ignoring leading zeros. The optimal approach uses two pointers to parse revisions on-the-fly without extra space. Time: O(n + m), Space: O(1).

Common Approaches

✓ Dp 1d

⏱️ Time: N/A Space: N/A

Heap

⏱️ Time: N/A Space: N/A

Split and Pad Approach

⏱️ Time: O(n + m) Space: O(n + m)

Split both version strings by dots to get revision arrays. Pad the shorter array with zeros to make them equal length. Compare each revision numerically from left to right.

Two Pointers Approach

⏱️ Time: O(n + m) Space: O(1)

Use two pointers to scan through both version strings simultaneously. Parse each revision on-the-fly by extracting numbers between dots. Compare revisions as we encounter them, treating missing revisions as 0.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

int solution(int* nums, int n, int k) {
    int* dp = (int*)malloc(n * sizeof(int));
    dp[0] = nums[0];
    
    for (int i = 1; i < n; i++) {
        dp[i] = nums[i]; // Start new subsequence
        int start = i - k > 0 ? i - k : 0;
        for (int j = start; j < i; j++) {
            dp[i] = max(dp[i], dp[j] + nums[i]);
        }
    }
    
    int result = dp[0];
    for (int i = 1; i < n; i++) {
        result = max(result, dp[i]);
    }
    
    free(dp);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

892 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