LeetCode

Compare Version Numbers

2015.1.23 15:27

Compare two version numbers version1 and version1.
If version1 > version2 return 1, if version1 < version2 return -1, otherwise return 0.

You may assume that the version strings are non-empty and contain only digits and the . character.
The . character does not represent a decimal point and is used to separate number sequences.
For instance, 2.5 is not "two and a half" or "half way to version three", it is the fifth second-level revision of the second first-level revision.

Here is an example of version numbers ordering:

0.1 < 1.1 < 1.2 < 13.37

Solution:

　　Seems this kind of questions is closest to real problems you have to deal with: trivial, dull and sometimes complicated. But don't take it that way, otherwise you would be overconfident and soon enough shocked by how bad you handled it.

　　"0" would be the first edge case, "0.0" or "0.0.0" may be illegal, for it should be equal to "0", resulting in ambiguity.

　　Here're the few occasions I thought about:

　　　　0 < 1

　　　　0 < 0.2

　　　　1.2 < 3.1

　　　　1.234 < 1.235

　　　　1.1 < 1.1.3

　　　　0.2.0? Illegal! That trailing zero shouldn't be there.

　　Split the version numbers, and do what you have to do then.

Accepted code:

// 1CE, 3WA, 1AC, so boring.
class Solution {
public:
    int compareVersion(string version1, string version2) {
        splitNumber(version1, s1);
        splitNumber(version2, s2);
        normalize(s1);
        normalize(s2);
        
        int n1, n2, nm;
        
        n1 = (int)s1.size();
        n2 = (int)s2.size();
        nm = n1 < n2 ? n1 : n2;
        
        int i;
        int res;
        for (i = 0; i < nm; ++i) {
            res = compare(s1[i], s2[i]);
            if (res != 0) {
                return res;
            }
        }
        if (n1 > n2) {
            return 1;
        } else if (n1 < n2) {
            return -1;
        } else {
            return 0;
        }
    }
private:
    vector<string> s1, s2;
    
    void splitNumber(const string &s, vector<string> &ss) {
        int len = (int)s.length();
        int i, j, k;
        
        ss.clear();
        
        ss.push_back(string());
        i = 0;
        j = 0;
        k = 0;
        while (i < len) {
            if (s[i] == '.') {
                ss.push_back(string());
                ++k;
                j = 0;
            } else {
                ss[k].push_back(s[i]);
                ++j;
            }
            ++i;
        }
    }
    
    int compare(const string &n1, const string &n2) {
        if (n1.length() > n2.length()) {
            return 1;
        } else if (n1.length() < n2.length()) {
            return -1;
        }
        
        int i;
        int len = (int)n1.length();
        
        for (i = 0; i < len; ++i) {
            if (n1[i] > n2[i]) {
                return 1;
            } else if (n1[i] < n2[i]) {
                return -1;
            }
        }
        
        return 0;
    }
    
    string trimZero(const string &s) {
        int i, len;
        string s1;
        
        len = (int)s.length();
        i = 0;
        while (i < len - 1 && s[i] == '0') {
            ++i;
        }
        while (i < len) {
            s1.push_back(s[i]);
            ++i;
        }
        
        return s1;
    }
    
    void normalize(vector<string> &ss) {
        int i;
        int n = (int)ss.size();
        
        for (i = 0; i < n; ++i) {
            ss[i] = trimZero(ss[i]);
        }
        while (ss.size() > 1u && ss[ss.size() - 1] == "0") {
            ss.pop_back();
        }
    }
};