Validate IP Address

Validate IP Address - Problem

String Medium

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.

Input & Output

Example 1 — Valid IPv4

$ Input: queryIP = "192.168.1.1"

› Output: "IPv4"

💡 Note: Valid IPv4: 4 segments separated by dots, each segment is 0-255 with no leading zeros

Example 2 — Valid IPv6

$ Input: queryIP = "2001:0db8:85a3:0:0:8A2E:0370:7334"

› Output: "IPv6"

💡 Note: Valid IPv6: 8 segments separated by colons, each segment is 1-4 hexadecimal characters

Example 3 — Invalid Format

$ Input: queryIP = "256.256.256.256"

› Output: "Neither"

💡 Note: Invalid IPv4: segment 256 exceeds maximum value of 255

Constraints

queryIP consists only of English letters, digits and the characters '.' and ':'.

Visualization

Tap to expand

Asked in

f Facebook 35 M Microsoft 28 a Amazon 22

The key insight is to first detect the IP type by checking delimiters, then validate each segment according to format rules. Best approach is Split and Validate for clean code structure. Time: O(n), Space: O(k)

Common Approaches

✓ Brute Force Character-by-Character

⏱️ Time: O(n) Space: O(1)

Iterate through each character, manually tracking segments and validating rules as we go. This approach doesn't use built-in string splitting functions.

Split and Validate

⏱️ Time: O(n) Space: O(k)

First determine the IP type by checking delimiters, then split the string and validate each segment according to the appropriate rules using separate validation functions.

Brute Force Character-by-Character — Algorithm Steps

Step 1: Iterate through each character
Step 2: Track current segment and count
Step 3: Validate rules for each character based on detected type

Visualization

Tap to expand

Step-by-Step Walkthrough

Detect Type

Scan for '.' or ':' to determine IPv4 vs IPv6

Manual Parse

Iterate through each character, build segments

Validate Rules

Check each segment against format rules

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>

char* solution(char* queryIP) {
    static char result[10];
    int n = strlen(queryIP);
    if (n == 0) {
        strcpy(result, "Neither");
        return result;
    }
    
    int hasDot = (strchr(queryIP, '.') != NULL);
    int hasColon = (strchr(queryIP, ':') != NULL);
    
    if (hasDot && hasColon) {
        strcpy(result, "Neither");
        return result;
    }
    
    if (hasDot) {
        int segments = 0;
        char current[10] = "";
        int curLen = 0;
        
        for (int i = 0; i <= n; i++) {
            if (i == n || queryIP[i] == '.') {
                if (curLen == 0 || curLen > 3) {
                    strcpy(result, "Neither");
                    return result;
                }
                if (curLen > 1 && current[0] == '0') {
                    strcpy(result, "Neither");
                    return result;
                }
                for (int j = 0; j < curLen; j++) {
                    if (!isdigit(current[j])) {
                        strcpy(result, "Neither");
                        return result;
                    }
                }
                int num = atoi(current);
                if (num > 255) {
                    strcpy(result, "Neither");
                    return result;
                }
                segments++;
                curLen = 0;
                current[0] = '\0';
            } else {
                current[curLen++] = queryIP[i];
                current[curLen] = '\0';
            }
        }
        
        strcpy(result, segments == 4 ? "IPv4" : "Neither");
        return result;
    }
    
    if (hasColon) {
        int segments = 0;
        char current[10] = "";
        int curLen = 0;
        
        for (int i = 0; i <= n; i++) {
            if (i == n || queryIP[i] == ':') {
                if (curLen == 0 || curLen > 4) {
                    strcpy(result, "Neither");
                    return result;
                }
                for (int j = 0; j < curLen; j++) {
                    char c = current[j];
                    if (!isdigit(c) && (c < 'a' || c > 'f') && (c < 'A' || c > 'F')) {
                        strcpy(result, "Neither");
                        return result;
                    }
                }
                segments++;
                curLen = 0;
                current[0] = '\0';
            } else {
                current[curLen++] = queryIP[i];
                current[curLen] = '\0';
            }
        }
        
        strcpy(result, segments == 8 ? "IPv6" : "Neither");
        return result;
    }
    
    strcpy(result, "Neither");
    return result;
}

int main() {
    char queryIP[100];
    fgets(queryIP, sizeof(queryIP), stdin);
    queryIP[strcspn(queryIP, "\n")] = 0;
    
    char* result = solution(queryIP);
    printf("%s\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string of length n

✓ Linear Growth

Space Complexity

O(1)

Only using variables for tracking state

✓ Linear Space

28.0K Views

Medium Frequency

~15 min Avg. Time

850 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Character-by-Character — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler