检查给定的字符串是 IPv4 或 IPv6 还是无效的

给定一个由N个字符组成的字符串S ，任务是检查给定的字符串S是 IPv4 还是 IPv6 还是无效的。如果给定的字符串S是有效的IPv4 ，则打印“IPv4” ，如果字符串S是有效的IPv6 ，则打印“IPv4” 。否则，打印“-1” 。

A valid IPv4 address is an IP in the form “x₁.x₂.x₃.x₄” where 0 ≤ x_i ≤ 255 and x_i cannot contain leading zeros.

A valid IPv6 address is an IP in the form “x₁ : x₂ : x₃ : x₄ : x₅ : x₆ : x₇ : x₈” where:

1 ≤ x_i.length ≤ 4
x_i 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 x_i.

编程需要懂一点英语

例子：

Input: S = “192.168.0.1”
Output: IPv4
Explanation:
The given string S is a valid IPv4 address as it is of the form “x₁.x₂.x₃.x₄” where 0 ≤ x_i ≤ 255.

Input: S = “2001:0db8:85a3:0000:0000:8a2e:0370:7334”
Output: IPv6

编程需要懂一点英语

方法：给定的问题可以通过拆分字符串来解决。检查IPv4地址和':'同时检查 IPv6 地址并检查字符串的条件是否为 IPv4 或 IPv6 或无效。

请按照以下步骤检查字符串是否为 IPv4：

初始化一个布尔变量，将其设置为true以检查字符串是否为 IPv4。
存储'.'的出现次数在给定的字符串中，变量cnt中的S 。
如果cnt的值不等于3 ，则将ans的值更新为false 。否则，将字符串, S相对于字符'.'标记化。并将标记化的字符串存储在数组V中。
检查V的大小是否等于4 。如果不相等，则将ans的值更新为false 。
否则，遍历数组V和每个字符串， str in V检查它是否位于[0, 255]范围内并且不包含前导 0。如果不是，则将ans的值更新为false 。
如果ans的值为 true，则该字符串是有效的 IPv4 地址，否则，它不是有效的 IPv4 地址。

请按照以下步骤检查字符串是否为 IPv6：

初始化一个布尔变量，将其设置为true以检查字符串是否为 IPv6。
将给定字符串S中':'的出现次数存储在变量cnt中。
如果cnt的值不等于7 ，则将ans更新为false 。否则，对字符串S wrt字符':'进行标记，并将标记化的字符串存储在数组V中。
检查V的大小是否等于8 。如果不相等，则将ans更新为false 。
否则，遍历数组V并且对于每个字符串， str in V检查其长度是否在[1, 4]范围内，并且它是有效的十六进制数。如果不是，则将ans的值更新为false 。
如果ans的值为 true，则该字符串是有效的 IPv6 地址。否则，它不是有效的 IPv6 地址。

下面是上述方法的实现：

C++

// C++ program for the above approach
  
#include 
using namespace std;
  
// Function to check if the given string
// S is IPv4 or not
bool checkIPv4(string s)
{
    // Store the count of occurrence
    // of '.' in the given string
    int cnt = 0;
  
    // Traverse the string s
    for (int i = 0; i < s.size(); i++) {
        if (s[i] == '.')
            cnt++;
    }
  
    // Not a valid IP address
    if (cnt != 3)
        return false;
  
    // Stores the tokens
    vector tokens;
  
    // stringstream class check1
    stringstream check1(s);
    string intermediate;
  
    // Tokenizing w.r.t. '.'
    while (getline(check1,
                   intermediate, '.')) {
        tokens.push_back(intermediate);
    }
  
    if (tokens.size() != 4)
        return false;
  
    // Check if all the tokenized strings
    // lies in the range [0, 255]
    for (int i = 0; i < tokens.size(); i++) {
        int num = 0;
  
        // Base Case
        if (tokens[i] == "0")
            continue;
  
        if (tokens[i].size() == 0)
            return false;
  
        for (int j = 0;
             j < tokens[i].size();
             j++) {
            if (tokens[i][j] > '9'
                || tokens[i][j] < '0')
                return false;
  
            num *= 10;
            num += tokens[i][j] - '0';
  
            if (num == 0)
                return false;
        }
  
        // Range check for num
        if (num > 255 || num < 0)
            return false;
    }
  
    return true;
}
  
// Function to check if the string
// represents a hexadecimal number
bool checkHex(string s)
{
    // Size of string s
    int n = s.length();
  
    // Iterate over string
    for (int i = 0; i < n; i++) {
        char ch = s[i];
  
        // Check if the character
        // is invalid
        if ((ch < '0' || ch > '9')
            && (ch < 'A' || ch > 'F')
            && (ch < 'a' || ch > 'f')) {
            return false;
        }
    }
  
    return true;
}
  
// Function to check if the given
// string S is IPv6 or not
bool checkIPv6(string s)
{
    // Store the count of occurrence
    // of ':' in the given string
    int cnt = 0;
  
    for (int i = 0; i < s.size();
         i++) {
        if (s[i] == ':')
            cnt++;
    }
  
    // Not a valid IP Address
    if (cnt != 7)
        return false;
  
    // Stores the tokens
    vector tokens;
  
    // stringstream class check1
    stringstream check1(s);
    string intermediate;
  
    // Tokenizing w.r.t. ':'
    while (getline(
        check1,
        intermediate, ':')) {
        tokens.push_back(intermediate);
    }
  
    if (tokens.size() != 8)
        return false;
  
    // Check if all the tokenized strings
    // are in hexadecimal format
    for (int i = 0;
         i < tokens.size(); i++) {
  
        int len = tokens[i].size();
  
        if (!checkHex(tokens[i])
            || len > 4 || len < 1) {
            return false;
        }
    }
    return true;
}
  
// Function to check if the string
// S is IPv4 or IPv6 or Invalid
void checkIPAddress(string s)
{
    // Check if the string is IPv4
    if (checkIPv4(s))
        cout << "IPv4";
  
    // Check if the string is IPv6
    else if (checkIPv6(s))
        cout << "IPv6";
  
    // Otherwise, print "Invalid"
    else
        cout << "Invalid";
}
  
// Driver Code
int main()
{
    string S = "192.168.0.1";
    checkIPAddress(S);
    return 0;
}

输出：

IPv4

时间复杂度： O(N)
辅助空间： O(N)