【Leetcode】468. 验证IP地址

QUESTION

medium

题目描述

编写一个函数来验证输入的字符串是否是有效的 IPv4 或 IPv6 地址。

IPv4 地址

• 由十进制数和点来表示，每个地址包含 4 个十进制数，其范围为 0 - 255， 用 (".") 分割。比如，172.16.254.1；
• 同时，IPv4 地址内的数不会以 0 开头。比如，地址 172.16.254.01 是不合法的。

IPv6 地址

• 由 8 组 16 进制的数字来表示，每组表示 16 比特。这些组数字通过 （":"） 分割。比如, 2001:0db8:85a3:0000:0000:8a2e:0370:7334 是一个有效的地址。而且，我们可以加入一些以 0 开头的数字，字母可以使用大写，也可以是小写。所以， 2001:db8:85a3:0:0:8A2E:0370:7334 也是一个有效的 IPv6 address 地址 (即，忽略 0 开头，忽略大小写)。
• 然而，我们不能因为某个组的值为 0，而使用一个空的组，以至于出现 （::） 的情况。比如，2001:0db8:85a3::8A2E:0370:7334 是无效的 IPv6 地址。
• 同时，在 IPv6 地址中，多余的 0 也是不被允许的。比如， 02001:0db8:85a3:0000:0000:8a2e:0370:7334 是无效的。

示例 1:

输入: "172.16.254.1"
输出: "IPv4"
解释: 这是一个有效的 IPv4 地址, 所以返回 "IPv4"。

示例 2:

输入: "2001:0db8:85a3:0:0:8A2E:0370:7334"
输出: "IPv6"
解释: 这是一个有效的 IPv6 地址, 所以返回 "IPv6"。

示例 3:

输入: "256.256.256.256"
输出: "Neither"
解释: 这个地址既不是 IPv4 也不是 IPv6 地址。

说明

你可以认为给定的字符串里没有空格或者其他特殊字符

---

SOLUTION

这道题可能和标准的地址表示不太一样，我这里简单列出上面的要点

对于 IPv4

• 用 . 分隔
• 一共分为四个部分，每个部分为十进制数，且其范围为 [0, 255]
• 十进制数不能以 0 开头

对于 IPv6

• 用 : 分隔
• 一共分为八个部分，每个部分为十六进制数
• 可以以 0 开头，也可以省略
• 每个部分的字符数 [1, 4]
• 注意这里与 v6 标准不同的是：不可以用 :: 来省略连续的 0 串，如果省略了就不是 v6（例如 2001:0db8:85a3::8A2E:0370:7334 是无效的）

方法一

我这个方法，阅读起来可能有点难看，思路还是很清楚的

• 首先根据 . 和 : 的数量来判断 v4 或 v6
• 大体确定之后，剔除字符串最后有 . 或 : 的情况
• 一个一个字符读取，判断字符符合要求与否，然后添加至 part 字符串，如果读到 . 或 : 则判断 part 是否符合要求

详细代码如下：

class Solution {
public:
    string validIPAddress(string IP) {
        int v4 = count(IP, '.');
        int v6 = count(IP, ':');
        if(v4 == 3 && v6 == 0){ // v4
            if(IP.back() == '.') return "Neither";
            IP += '.';
            string part = "";
            for(char c : IP){
                if(c == '.'){
                    if(part.empty() || (part.size() > 1 && part[0] == '0')) return "Neither";
                    int val = stoi(part);
                    if(val < 0 || val > 255) return "Neither";
                    part.clear();
                    continue;
                }
                if(!isdigit(c)) return "Neither";
                part += c;
                if(part.size() > 3) return "Neither"; //防止数字过大
            }
            return "IPv4";
        }
        else if(v4 == 0 && v6 == 7){ // v6
            if(IP.back() == ':') return "Neither";
            IP += ':';
            string part = "";
            for(char c : IP){
                if(c == ':'){
                    if(part.empty()) return "Neither";
                    part.clear();
                    continue;
                }
                if(!isdigit(c) && !(c >= 'a' && c <= 'f') && !(c >= 'A' && c <= 'F')) return "Neither";
                part += c;
                if(part.size() > 4) return "Neither";
            }
            return "IPv6";
        }
        return "Neither";
    }
    int count(string &IP, char c){
        int cnt = 0;
        for(char e : IP) if(e == c) cnt++;
        return cnt;
    }
};

方法二

转自 Grandyang 的博客，使用了 istringstream 来分割字符串。

class Solution {
public:
    string validIPAddress(string IP) {
        istringstream is(IP);
        string t = "";
        int cnt = 0;
        if (IP.find(':') == string::npos) { // Check IPv4
            while (getline(is, t, '.')) {
                ++cnt;
                if (cnt > 4 || t.empty() || (t.size() > 1 && t[0] == '0') || t.size() > 3) return "Neither";
                for (char c : t) {
                    if (c < '0' || c > '9') return "Neither";
                }
                int val = stoi(t);
                if (val < 0 || val > 255) return "Neither";
            }
            return (cnt == 4 && IP.back() != '.') ? "IPv4" : "Neither";
        } else { // Check IPv6
            while (getline(is, t, ':')) {
                ++cnt;
                if (cnt > 8 || t.empty() || t.size() > 4) return "Neither";
                for (char c : t) {
                    if (!(c >= '0' && c <= '9') && !(c >= 'a' && c <= 'f') && !(c >= 'A' && c <= 'F')) return "Neither";
                }
            }
            return (cnt == 8 && IP.back() != ':') ? "IPv6" : "Neither";
        }
    }
};

方法三

这道题可以正则表达式来解决，我不会用（在这挖个坑），希望有会的看到了能附上这种方法在评论里，感激不尽！