LeetCode每日一题(468. Validate IP Address)

Given a string queryIP, 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 while “192.168.01.1”, “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, lowercase 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.

Example 1:

Input: queryIP = “172.16.254.1”
Output: “IPv4”

Explanation: This is a valid IPv4 address, return “IPv4”.

Example 2:

Input: queryIP = “2001:0db8:85a3:0:0:8A2E:0370:7334”
Output: “IPv6”

Explanation: This is a valid IPv6 address, return “IPv6”.

Example 3:

Input: queryIP = “256.256.256.256”
Output: “Neither”

Explanation: This is neither a IPv4 address nor a IPv6 address.

Constraints:

• queryIP consists only of English letters, digits and the characters ‘.’ and ‘:’.

---

基本就是按照题目所说的规则进行检查， ipv4 的情况下注意地址段为 0 的情况

---

impl Solution {
    fn is_valid_ipv4_component(s: &str) -> bool {
        if s.len() > 3 {
            return false;
        }
        if let Ok(mut n) = s.parse::<i32>() {
            if n < 0 || n > 255 {
                return false;
            }
            if n == 0 {
                return s == "0";
            }
            let mut digits = 0;
            while n > 0 {
                n /= 10;
                digits += 1;
            }
            return digits == s.len() as i32;
        }
        return false;
    }

    fn is_valid_ipv6_component(s: &str) -> bool {
        if s.len() == 0 || s.len() > 4 {
            return false;
        }
        for c in s.chars() {
            match c {
                '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' | 'a' | 'b' | 'c'
                | 'd' | 'e' | 'f' | 'A' | 'B' | 'C' | 'D' | 'E' | 'F' => {}
                _ => return false,
            }
        }
        true
    }

    pub fn valid_ip_address(query_ip: String) -> String {
        let mut is_ipv4 = false;
        let mut is_ipv6 = false;
        if query_ip.contains(".") {
            is_ipv4 = true;
        }
        if query_ip.contains(":") {
            is_ipv6 = true;
        }
        if is_ipv4 && is_ipv6 || !is_ipv4 && !is_ipv6 {
            return "Neither".into();
        }
        if is_ipv4 {
            let components: Vec<&str> = query_ip.split(".").collect();
            if components.len() != 4 {
                return "Neither".into();
            }
            if components
                .into_iter()
                .all(|c| Solution::is_valid_ipv4_component(c))
            {
                return "IPv4".into();
            }
            return "Neither".into();
        }
        let components: Vec<&str> = query_ip.split(":").collect();
        if components.len() != 8 {
            return "Neither".into();
        }
        if components
            .into_iter()
            .all(|c| Solution::is_valid_ipv6_component(c))
        {
            return "IPv6".into();
        }
        return "Neither".into();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75