1class Solution {
2    /**
3     * Validates whether a given string is a valid IPv4 or IPv6 address
4     * @param queryIP the input string to validate
5     * @return "IPv4" if valid IPv4, "IPv6" if valid IPv6, "Neither" otherwise
6     */
7    public String validIPAddress(String queryIP) {
8        if (isIPv4(queryIP)) {
9            return "IPv4";
10        }
11        if (isIPv6(queryIP)) {
12            return "IPv6";
13        }
14        return "Neither";
15    }
16
17    /**
18     * Checks if the given string is a valid IPv4 address
19     * IPv4 format: x1.x2.x3.x4 where 0 <= xi <= 255 and xi cannot have leading zeros
20     * @param ipString the string to validate
21     * @return true if valid IPv4, false otherwise
22     */
23    private boolean isIPv4(String ipString) {
24        // IPv4 cannot end with a dot
25        if (ipString.endsWith(".")) {
26            return false;
27        }
28      
29        // Split by dot separator
30        String[] segments = ipString.split("\\.");
31      
32        // IPv4 must have exactly 4 segments
33        if (segments.length != 4) {
34            return false;
35        }
36      
37        // Validate each segment
38        for (String segment : segments) {
39            // Check for empty segment or leading zeros (except single "0")
40            if (segment.length() == 0 || (segment.length() > 1 && segment.charAt(0) == '0')) {
41                return false;
42            }
43          
44            // Convert to integer and validate range [0, 255]
45            int value = convertToInteger(segment);
46            if (value < 0 || value > 255) {
47                return false;
48            }
49        }
50      
51        return true;
52    }
53
54    /**
55     * Checks if the given string is a valid IPv6 address
56     * IPv6 format: x1:x2:x3:x4:x5:x6:x7:x8 where xi is a hexadecimal string (1-4 digits)
57     * @param ipString the string to validate
58     * @return true if valid IPv6, false otherwise
59     */
60    private boolean isIPv6(String ipString) {
61        // IPv6 cannot end with a colon
62        if (ipString.endsWith(":")) {
63            return false;
64        }
65      
66        // Split by colon separator
67        String[] segments = ipString.split(":");
68      
69        // IPv6 must have exactly 8 segments
70        if (segments.length != 8) {
71            return false;
72        }
73      
74        // Validate each segment
75        for (String segment : segments) {
76            // Each segment must be 1-4 characters long
77            if (segment.length() < 1 || segment.length() > 4) {
78                return false;
79            }
80          
81            // Validate each character is a valid hexadecimal digit
82            for (char character : segment.toCharArray()) {
83                if (!Character.isDigit(character) && 
84                    !"0123456789abcdefABCDEF".contains(String.valueOf(character))) {
85                    return false;
86                }
87            }
88        }
89      
90        return true;
91    }
92
93    /**
94     * Converts a string to integer, returns -1 if string contains non-digit characters
95     * @param numberString the string to convert
96     * @return the integer value or -1 if invalid
97     */
98    private int convertToInteger(String numberString) {
99        int result = 0;
100      
101        for (char character : numberString.toCharArray()) {
102            // Return -1 if non-digit character found
103            if (!Character.isDigit(character)) {
104                return -1;
105            }
106          
107            // Build the integer value
108            result = result * 10 + (character - '0');
109          
110            // Early return if value exceeds 255
111            if (result > 255) {
112                return result;
113            }
114        }
115      
116        return result;
117    }
118}
119

1class Solution {
2public:
3    string validIPAddress(string queryIP) {
4        // Check if the input is a valid IPv4 address
5        if (isIPv4(queryIP)) {
6            return "IPv4";
7        }
8        // Check if the input is a valid IPv6 address
9        if (isIPv6(queryIP)) {
10            return "IPv6";
11        }
12        // Neither IPv4 nor IPv6
13        return "Neither";
14    }
15
16private:
17    bool isIPv4(const string& ipString) {
18        // IPv4 cannot be empty or end with a dot
19        if (ipString.empty() || ipString.back() == '.') {
20            return false;
21        }
22      
23        // Split the string by dots
24        vector<string> segments = split(ipString, '.');
25      
26        // IPv4 must have exactly 4 segments
27        if (segments.size() != 4) {
28            return false;
29        }
30      
31        // Validate each segment
32        for (const string& segment : segments) {
33            // Segment cannot be empty or have leading zeros (except for "0" itself)
34            if (segment.empty() || (segment.size() > 1 && segment[0] == '0')) {
35                return false;
36            }
37          
38            // Convert segment to integer and validate range [0, 255]
39            int value = convertToInt(segment);
40            if (value < 0 || value > 255) {
41                return false;
42            }
43        }
44      
45        return true;
46    }
47
48    bool isIPv6(const string& ipString) {
49        // IPv6 cannot be empty or end with a colon
50        if (ipString.empty() || ipString.back() == ':') {
51            return false;
52        }
53      
54        // Split the string by colons
55        vector<string> segments = split(ipString, ':');
56      
57        // IPv6 must have exactly 8 segments
58        if (segments.size() != 8) {
59            return false;
60        }
61      
62        // Validate each segment
63        for (const string& segment : segments) {
64            // Each segment must be 1-4 characters long
65            if (segment.size() < 1 || segment.size() > 4) {
66                return false;
67            }
68          
69            // Each character must be a valid hexadecimal digit
70            for (char ch : segment) {
71                if (!isxdigit(ch)) {
72                    return false;
73                }
74            }
75        }
76      
77        return true;
78    }
79
80    int convertToInt(const string& str) {
81        int result = 0;
82      
83        // Convert string to integer, checking for non-digit characters
84        for (char ch : str) {
85            if (!isdigit(ch)) {
86                return -1;  // Invalid character found
87            }
88          
89            result = result * 10 + (ch - '0');
90          
91            // Early return if value exceeds 255
92            if (result > 255) {
93                return result;
94            }
95        }
96      
97        return result;
98    }
99
100    vector<string> split(const string& str, char delimiter) {
101        vector<string> tokens;
102        string token;
103        istringstream stringStream(str);
104      
105        // Split the string by the delimiter using getline
106        while (getline(stringStream, token, delimiter)) {
107            tokens.push_back(token);
108        }
109      
110        return tokens;
111    }
112};
113

1/**
2 * Validates if a given string is a valid IPv4 or IPv6 address
3 * @param queryIP - The IP address string to validate
4 * @returns 'IPv4' if valid IPv4, 'IPv6' if valid IPv6, 'Neither' otherwise
5 */
6function validIPAddress(queryIP: string): string {
7    if (isIPv4(queryIP)) {
8        return 'IPv4';
9    }
10    if (isIPv6(queryIP)) {
11        return 'IPv6';
12    }
13    return 'Neither';
14}
15
16/**
17 * Checks if a string is a valid IPv4 address
18 * Valid IPv4: four decimal numbers separated by dots, each between 0-255
19 * No leading zeros allowed (except for '0' itself)
20 * @param s - The string to validate as IPv4
21 * @returns true if valid IPv4, false otherwise
22 */
23function isIPv4(s: string): boolean {
24    // IPv4 cannot end with a dot
25    if (s.endsWith('.')) {
26        return false;
27    }
28  
29    // Split by dots and check for exactly 4 segments
30    const segments: string[] = s.split('.');
31    if (segments.length !== 4) {
32        return false;
33    }
34  
35    // Validate each segment
36    for (const segment of segments) {
37        // Empty segments are invalid
38        // Segments with leading zeros (except single '0') are invalid
39        if (segment.length === 0 || (segment.length > 1 && segment[0] === '0')) {
40            return false;
41        }
42      
43        // Convert to number and validate range [0, 255]
44        const num: number = convert(segment);
45        if (num < 0 || num > 255) {
46            return false;
47        }
48    }
49  
50    return true;
51}
52
53/**
54 * Checks if a string is a valid IPv6 address
55 * Valid IPv6: eight hexadecimal groups separated by colons
56 * Each group is 1-4 hexadecimal digits
57 * @param s - The string to validate as IPv6
58 * @returns true if valid IPv6, false otherwise
59 */
60function isIPv6(s: string): boolean {
61    // IPv6 cannot end with a colon
62    if (s.endsWith(':')) {
63        return false;
64    }
65  
66    // Split by colons and check for exactly 8 segments
67    const segments: string[] = s.split(':');
68    if (segments.length !== 8) {
69        return false;
70    }
71  
72    // Validate each segment
73    for (const segment of segments) {
74        // Each segment must be 1-4 characters long
75        if (segment.length < 1 || segment.length > 4) {
76            return false;
77        }
78      
79        // Each character must be a hexadecimal digit
80        for (const char of segment) {
81            if (!isHexDigit(char)) {
82                return false;
83            }
84        }
85    }
86  
87    return true;
88}
89
90/**
91 * Converts a string to a number, validating that all characters are digits
92 * @param s - The string to convert
93 * @returns The numeric value if valid, -1 if invalid
94 */
95function convert(s: string): number {
96    let result: number = 0;
97  
98    for (const char of s) {
99        // Return -1 if any character is not a digit
100        if (!isDigit(char)) {
101            return -1;
102        }
103      
104        // Build the number digit by digit
105        result = result * 10 + (char.charCodeAt(0) - '0'.charCodeAt(0));
106      
107        // Early return if number exceeds 255
108        if (result > 255) {
109            return result;
110        }
111    }
112  
113    return result;
114}
115
116/**
117 * Checks if a character is a decimal digit (0-9)
118 * @param c - The character to check
119 * @returns true if the character is a digit, false otherwise
120 */
121function isDigit(c: string): boolean {
122    return c >= '0' && c <= '9';
123}
124
125/**
126 * Checks if a character is a hexadecimal digit (0-9, a-f, A-F)
127 * @param c - The character to check
128 * @returns true if the character is a hex digit, false otherwise
129 */
130function isHexDigit(c: string): boolean {
131    return (c >= '0' && c <= '9') || 
132           (c >= 'a' && c <= 'f') || 
133           (c >= 'A' && c <= 'F');
134}
135