468. Validate IP Address

Given a string IP, return “IPv4” if IP is a valid IPv4 address, “IPv6” if IP is a valid IPv6 address or “Neither” if IP is not a correct IP of any type.

A valid IPv4 address is an IP in the form “x1.x2.x3.x4” where 0 <= xi <= 255 and xi cannot contain leading zeros. For example, “192.168.1.1” and “192.168.1.0” are valid IPv4 addresses but “192.168.01.1”, while “192.168.1.00” and “192.168@1.1” are invalid IPv4 addresses.

A valid IPv6 address is an IP in the form “x1:x2:x3:x4:x5:x6:x7:x8” where:

• 1 <= xi.length <= 4
• xi is a hexadecimal string which may contain digits, lower-case English letter (‘a’ to ‘f’) and upper-case English letters (‘A’ to ‘F’).
• Leading zeros are allowed in xi.

For example, “2001:0db8:85a3:0000:0000:8a2e:0370:7334” and “2001:db8:85a3:0:0:8A2E:0370:7334” are valid IPv6 addresses, while “2001:0db8:85a3::8A2E:037j:7334” and “02001:0db8:85a3:0000:0000:8a2e:0370:7334” are invalid IPv6 addresses.

class Solution {
private:
    const string Neither = "Neither";
    const string IPv4 = "IPv4";
    const string IPv6 = "IPv6";
private:
    vector<string> getAddress(string IP, char symbol) {
        vector<string> res;
        size_t pos = 0, prevPos = 0;
        while((pos = IP.find(symbol, pos)) != std::string::npos) {
            res.push_back(IP.substr(prevPos, pos - prevPos));
            prevPos = ++pos;
        }
        res.push_back(IP.substr(prevPos));

        return res;
    }

    int charToDecimal(char c) {
        return '0' <= c && c <= '9' ? c & 0b1111 : INT_MIN;
    }

    int hexaToDecimal(char c) {
        switch (c) {
            case 'a':
            case 'A':
                return 10;
            case 'b':
            case 'B':
                return 11;
            case 'c':
            case 'C':
                return 12;
            case 'd':
            case 'D':
                return 13;
            case 'e':
            case 'E':
                return 14;
            case 'f':
            case 'F':
                return 15;
            default:
                return charToDecimal(c);
        }
    }

    string isIPv4(string IP) {
        vector<string> addresses = getAddress(IP, '.');

        if(addresses.size() != 4)
            return Neither;

        for(string address : addresses) {
            int val = 0;
            if(address.length() > 3 || address.length() < 1 || (address[0] == '0' && address != "0"))
                return Neither;

            for(int i = 0; i < address.length(); i++) {
                val = val * 10 + charToDecimal(address[i]);
                if(!(0 <= val && val <= 255))
                    return Neither;
            }
        }

        return IPv4;
    }

    string isIPv6(string IP) {
        vector<string> addresses = getAddress(IP, ':');

        if(addresses.size() != 8)
            return Neither;

        for(string address : addresses) {
            int val = 0;

            if(address.length() > 4 || address == "")
                return Neither;

            for(int i = 0; i < address.length(); i++) {
                val = val * 16 + hexaToDecimal(address[i]);
                if(!(0 <= val && val <= 65535))
                    return Neither;
            }
        }

        return IPv6;
    }
public:
    string validIPAddress(string IP) {
        return IP.length() <= 39 ? IP.find(".") != std::string::npos ? isIPv4(IP) : isIPv6(IP) : Neither;
    }
};