g0101_0200.s0165_compare_version_numbers.Solution Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of leetcode-in-java21 Show documentation
Java-based LeetCode algorithm problem solutions, regularly updated
There is a newer version: 1.38
package g0101_0200.s0165_compare_version_numbers;

// #Medium #String #Two_Pointers #2022_06_25_Time_1_ms_(88.88%)_Space_41.8_MB_(66.14%)

/**
 * 165 - Compare Version Numbers\.
 *
 * Medium
 *
 * Given two version numbers, `version1` and `version2`, compare them.
 *
 * Version numbers consist of **one or more revisions** joined by a dot `'.'`. Each revision consists of **digits** and may contain leading **zeros**. Every revision contains **at least one character**. Revisions are **0-indexed from left to right** , with the leftmost revision being revision 0, the next revision being revision 1, and so on. For example `2.5.33` and `0.1` are valid version numbers.
 *
 * To compare version numbers, compare their revisions in **left-to-right order**. Revisions are compared using their **integer value ignoring any leading zeros**. This means that revisions `1` and `001` are considered **equal**. If a version number does not specify a revision at an index, then **treat the revision as `0` **. For example, version `1.0` is less than version `1.1` because their revision 0s are the same, but their revision 1s are `0` and `1` respectively, and `0 < 1`.
 *
 * _Return the following:_
 *
 * *   If `version1 < version2`, return `-1`.
 * *   If `version1 > version2`, return `1`.
 * *   Otherwise, return `0`.
 *
 * **Example 1:**
 *
 * **Input:** version1 = "1.01", version2 = "1.001"
 *
 * **Output:** 0
 *
 * **Explanation:** Ignoring leading zeroes, both "01" and "001" represent the same integer "1". 
 *
 * **Example 2:**
 *
 * **Input:** version1 = "1.0", version2 = "1.0.0"
 *
 * **Output:** 0
 *
 * **Explanation:** version1 does not specify revision 2, which means it is treated as "0". 
 *
 * **Example 3:**
 *
 * **Input:** version1 = "0.1", version2 = "1.1"
 *
 * **Output:** -1
 *
 * **Explanation:** version1's revision 0 is "0", while version2's revision 0 is "1". 0 < 1, so version1 < version2. 
 *
 * **Example 4:**
 *
 * **Input:** version1 = "1.0.1", version2 = "1"
 *
 * **Output:** 1 
 *
 * **Example 5:**
 *
 * **Input:** version1 = "7.5.2.4", version2 = "7.5.3"
 *
 * **Output:** -1 
 *
 * **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**.
**/
public class Solution {
    public int compareVersion(String version1, String version2) {
        // acquire first number
        int numA = 0;
        int i;
        for (i = 0; i < version1.length(); i++) {
            char c = version1.charAt(i);
            if (c == '.') {
                break;
            } else {
                numA = numA * 10 + (c - 48);
            }
        }
        // acquire second number
        int numB = 0;
        int j;
        for (j = 0; j < version2.length(); j++) {
            char c = version2.charAt(j);
            if (c == '.') {
                break;
            } else {
                numB = numB * 10 + (c - 48);
            }
        }
        // compare
        if (numA > numB) {
            return 1;
        } else if (numA < numB) {
            return -1;
        } else {
            // equal
            String v1 = "";
            String v2 = "";
            if (i != version1.length()) {
                v1 = version1.substring(i + 1);
            }
            if (j != version2.length()) {
                v2 = version2.substring(j + 1);
            }
            // if both versions end here, they are equal
            if (v1.equals("") && v2.equals("")) {
                return 0;
            } else {
                return compareVersion(v1, v2);
            }
        }
    }
}