python 编写一个函数来验证输入的字符串是否是有效的 IPv4 或 IPv6 地址_(Trivial) LeetCode 468—验证 IP 地址

最新推荐文章于 2024-08-27 08:42:09 发布

weixin_39739404

最新推荐文章于 2024-08-27 08:42:09 发布

阅读量875

点赞数

文章标签： python 编写一个函数来验证输入的字符串是否是有效的 IPv4 或 IPv6 地址

关键字：字符串，状态机

归航return：(Trivial) LeetCode 剑指 Offer 64—计算等差数列求和zhuanlan.zhihu.com

归航return：LeetCode 41—缺失的第一个正整数zhuanlan.zhihu.com

Problem

编写一个函数来验证输入的字符串是否是有效的 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 地址 (即，忽略 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 地址。

468. 验证IP地址 - 力扣（LeetCode）leetcode-cn.com

Solution

这道题我首先想到的办法就是进行线性扫描遍历，后来在 LeetCode 官方题解中看到，这个办法被称作“分治法”（我个人不是很认同这个说法，因为分治法通常强调的是有点类似于递归的思路），和这种实际上是线性扫描遍历的过程不是很符合。

另一道和 IP 地址相关的经典 LeetCode 题目是 LeetCode 93，但这道题目要求的是将一个数字字符串变成合法的 IP 地址。我在这道题的解答中，选择的方法是维护了一个长度为 4 的数组 nums，其中 nums[i] 定义为在数字数组的第 nums[i] 个字符之前放 '.'，那么这些 nums[i] 需要满足这样的性质：

1<=nums[i+1]-nums[i]<=3(i=0,1,2)；
str.substr(nums[i],nums[i+1]-nums[i])(i=0,1,2) 和 str.substr(nums[3]) 都是合法的 IPv4 数字字符串。

更详细的解答参考我在知乎专栏上写作的 LeetCode 93 题解。

回到本题。具体来说，一个 IP 地址是合法的 IPv4 地址，当且仅当：

这个 IP 地址包含四个从 0 到 255 的数字，每个数字 不含前导零（换言之：当且仅当数字是 0 的时候，数字的最高位是 0），数字之间必须使用 '.' 进行分割， '.' 之间不能相邻， '.' 刚好有 3 个。

一个 IP 地址是合法的 IPv6 地址，当且仅当：

这个 IP 地址包含八个不超过 4 位的十六进制数字（字母可以是大写或者是小写）， 可以含有前导零（这一点在题干中并没有指出，是我通过这个测试用例得到的— "2001:0db8:85a3:0:010:8A2E:0370:7334"，其中 '010' 就含有多余的前导零，而且长度并不是 4），数字之间必须使用 ':' 进行分割， ':' 之间不能相邻， ":" 刚好有 7 个。

然后结合一些状态机的思想，将状态进行分类：当前是符号还是数字，（合法的）符号定义为状态 0（如果不是合法的字符或者数字，直接返回 false），数字则定义为 1，那么就总共有四种状态。如果是 0 到 0，那么一定是不合法的，因为任何一种情况下都不可能是有两个连续的符号出现，无论是 IPv4 还是 IPv6 地址；如果是 0 到 1 或者 1 到 1，那么直接将存储数字对应的字符串加上当前这个数字；

如果是 1 到 0，那么就要对数字进行合法性检验，如果无法通过合法性检验，就直接返回不合法，

否则将存储出现过的标点的计数器加上 1，如果加上 1 之后已经超过了允许的最大值，直接返回 false，

否则将存储数字的字符串清空并继续，这种情况是最复杂的。

结合合法 IP 地址的要求，我们还要求，遍历完毕之后，state 是 1（因为 IP 地址必须用数字结尾），然后最后一个数字必须是合法数字，并且标点的计数刚好是对应上述的要求。当然，在我们最终的代码实现中，省略了对 state==1 的判定，因为我们对于合法数字的定义中，包含了对于空字符串的判定，如果 state 以 0 结尾（这意味着最后一位的前一位一定是数字，否则在遍历完毕之前就直接返回 false 了），那么这个时候意味着存储数字的字符串是空的。

最后，判定函数中的变量初始化问题。初始状态下，存储数字的字符串是空的，已经出现过的标点的个数都初始化为 0，这两者是显然的，而 state 应当初始化为 0，这样如果字符串中第 0 个字符不是数字就可以直接返回 false 了，和上述状态机定义是符合的。

综上所述，代码如下：

class Solution {
public:
    string validIPAddress(string IP) {
        if (IP.size() == 0)
            return "Neither";
        for (const char& ch : IP){
            switch (ch){
                case '.':{
                    return IPV4check(IP) ? "IPv4" : "Neither";
                    break;
                }
                case ':':{
                    return IPV6check(IP) ? "IPv6" : "Neither";
                    break;
                }
                default:{
                    if (!isHexNumbers(ch))
                        return "Neither";
                    continue;
                }
            }
        }
        return "Neither";
    }
private:
    bool isHexNumbers(const char& ch){
        return isdigit(ch) || (tolower(ch) >= 'a' && tolower(ch) <= 'f');
    }
    bool IPV4check(const string &x){
        int dotCount = 0;
        string curNumber = "";
        int state = 0;
        for (const char& ch : x){
            if (isdigit(ch)){
                curNumber += ch;
                state = 1;
            }
            else if (ch == '.'){
                if (state){
                    if (!IPV4NumberCheck(curNumber))
                        return false;
                    ++dotCount;
                    if (dotCount > 3)
                        return false;
                    curNumber.clear();
                }
                else{
                    return false;
                }
                state = 0;
            }
            else{
                return false;
            }
        }
        return dotCount == 3 && IPV4NumberCheck(curNumber);
    }
    bool IPV4NumberCheck(const string &x){
        if (x.size() == 0 || x.size() > 3)
            return false;
        if (x.size() == 1)
            return true;
        int xInNumber = stoi(x);
        if (x.size() == 2)
            return xInNumber >= 10;
        return xInNumber >= 100 && xInNumber <= 255;
    }
    bool IPV6check(const string &x){
        int dotCount = 0;
        string curNumber = "";
        int state = 0;
        for (const char& ch : x){
            if (isHexNumbers(ch)){
                curNumber += ch;
                state = 1;
            }
            else if (ch == ':'){
                if (state){
                    if (!IPV6NumberCheck(curNumber))
                        return false;
                    ++dotCount;
                    if (dotCount > 7)
                        return false;
                    curNumber.clear();
                }
                else{
                    return false;
                }
                state = 0;
            }
            else{
                return false;
            }
        }
        return dotCount == 7 && IPV6NumberCheck(curNumber);
    }
    bool IPV6NumberCheck(const string &x){
        return (x.size() > 0 && x.size() <= 4);
    }
};