Validate IP Address - Practice Coding Problems

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 "[email protected]" 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

Understanding the Visualization

Input

String that could be IPv4, IPv6, or invalid

Type Detection

Check delimiters to determine format

Validation

Apply format-specific rules

Key Takeaway

🎯 Key Insight: The delimiter type (. vs :) immediately determines which validation rules to apply

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

Approach	Time	Space	Notes
✓ Split and Validate	O(n)	O(k)	Split by delimiter then validate each segment with helper functions
Brute Force Character-by-Character	O(n)	O(1)	Check every character manually without splitting, tracking state

Split and Validate — Algorithm Steps

Step 1: Check delimiters to determine IP type
Step 2: Split string by appropriate delimiter
Step 3: Validate each segment with type-specific rules

Visualization

Tap to expand

Step-by-Step Walkthrough

Detect & Split

Identify type and split by delimiter

Count Segments

Ensure correct number of parts

Validate Each

Apply format rules to each segment

Code -

solution.c — C

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

int validateIPv4Segment(char* s) {
    int len = strlen(s);
    if (len == 0 || len > 3) return 0;
    if (len > 1 && s[0] == '0') return 0;
    for (int i = 0; i < len; i++) {
        if (!isdigit(s[i])) return 0;
    }
    int num = atoi(s);
    return num >= 0 && num <= 255;
}

int validateIPv6Segment(char* s) {
    int len = strlen(s);
    if (len == 0 || len > 4) return 0;
    for (int i = 0; i < len; i++) {
        char c = s[i];
        if (!isdigit(c) && (c < 'a' || c > 'f') && (c < 'A' || c > 'F')) {
            return 0;
        }
    }
    return 1;
}

char* solution(char* queryIP) {
    static char result[10];
    
    int hasDot = (strchr(queryIP, '.') != NULL);
    int hasColon = (strchr(queryIP, ':') != NULL);
    
    if (hasDot && hasColon) {
        strcpy(result, "Neither");
        return result;
    }
    
    if (hasDot) {
        char* segments[4];
        int count = 0;
        char* token = strtok(queryIP, ".");
        while (token != NULL && count < 4) {
            segments[count++] = token;
            token = strtok(NULL, ".");
        }
        
        if (count != 4 || token != NULL) {
            strcpy(result, "Neither");
            return result;
        }
        
        for (int i = 0; i < 4; i++) {
            if (!validateIPv4Segment(segments[i])) {
                strcpy(result, "Neither");
                return result;
            }
        }
        strcpy(result, "IPv4");
        return result;
    }
    
    if (hasColon) {
        char* segments[8];
        int count = 0;
        char* token = strtok(queryIP, ":");
        while (token != NULL && count < 8) {
            segments[count++] = token;
            token = strtok(NULL, ":");
        }
        
        if (count != 8 || token != NULL) {
            strcpy(result, "Neither");
            return result;
        }
        
        for (int i = 0; i < 8; i++) {
            if (!validateIPv6Segment(segments[i])) {
                strcpy(result, "Neither");
                return result;
            }
        }
        strcpy(result, "IPv6");
        return result;
    }
    
    strcpy(result, "Neither");
    return result;
}

int main() {
    char queryIP[100];
    fgets(queryIP, sizeof(queryIP), stdin);
    queryIP[strcspn(queryIP, "\n")] = 0;
    
    // Make a copy since strtok modifies the string
    char copy[100];
    strcpy(copy, queryIP);
    
    char* result = solution(copy);
    printf("%s\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Linear scan to split string plus validation of each segment

✓ Linear Growth

Space Complexity

O(k)

Storage for k segments after splitting (at most 8 for IPv6)

✓ 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

Split and Validate — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler