Validate IP Address - Practice Coding Problems

Validate IP Address - Problem

String Medium

In today's interconnected world, every device on the internet needs a unique address - an IP address. Your task is to build a smart validator that can distinguish between different IP address formats!

Given a string queryIP, you need to determine if it represents a valid IPv4 address, a valid IPv6 address, or neither.

IPv4 Rules:

Format: "x₁.x₂.x₃.x₄" (exactly 4 parts separated by dots)
Each part must be a number between 0 and 255
No leading zeros allowed (except for "0" itself)
Example: "192.168.1.1" ✅, "192.168.01.1" ❌

IPv6 Rules:

Format: "x₁:x₂:x₃:x₄:x₅:x₆:x₇:x₈" (exactly 8 parts separated by colons)
Each part is 1-4 hexadecimal characters (0-9, a-f, A-F)
Leading zeros are allowed
Example: "2001:0db8:85a3:0000:0000:8a2e:0370:7334" ✅

Return: "IPv4", "IPv6", or "Neither"

Input & Output

example_1.py — Valid IPv4 Address

$ Input: queryIP = "192.168.1.1"

› Output: "IPv4"

💡 Note: This is a valid IPv4 address with 4 parts separated by dots, each part is between 0-255 with no leading zeros.

example_2.py — Valid IPv6 Address

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

› Output: "IPv6"

💡 Note: This is a valid IPv6 address with 8 parts separated by colons, each part contains 1-4 hexadecimal characters.

example_3.py — Invalid Address

$ Input: queryIP = "256.256.256.256"

› Output: "Neither"

💡 Note: Although this has the IPv4 format, each part exceeds 255, making it invalid.

Visualization

Tap to expand

Understanding the Visualization

Type Detection

Check for '.' (IPv4) or ':' (IPv6) separators

Component Splitting

Split the string into parts using the detected separator

Count Validation

Verify we have exactly 4 parts (IPv4) or 8 parts (IPv6)

Component Validation

Apply type-specific rules to each component

Key Takeaway

🎯 Key Insight: Separate concerns by first identifying the IP type, then applying type-specific validation rules. This makes the code cleaner and easier to debug.

Time & Space Complexity

Time Complexity

⏱️

O(n)

We still need to examine each character once, but with more overhead

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track state

✓ Linear Space

Constraints

queryIP consists only of English letters, digits and the characters '.' and ':'
1 ≤ queryIP.length ≤ 100

Asked in

a Amazon 25 ⊞ Microsoft 18 G Google 15 f Facebook 12

The optimal approach is to identify the IP type first by checking for dots or colons, then split the string into components and validate each component according to the specific rules for that IP type. This gives us O(n) time complexity with clean, maintainable code.

Common Approaches

Approach	Time	Space	Notes
✓ Character-by-Character Validation	O(n)	O(1)	Manually parse and validate each character without using built-in string methods

Character-by-Character Validation — Algorithm Steps

Iterate through each character in the string
Build components manually by detecting separators
Apply validation rules character by character
Track state and component counts manually

Visualization

Tap to expand

Step-by-Step Walkthrough

Character Scanning

Scan each character to identify separators and build components

Component Building

Accumulate characters into IP address components

Type Detection

Determine IP type based on separator character

Validation

Apply type-specific validation rules to each component

Code -

solution.c — C

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

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

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

char* validIPAddress(char* queryIP) {
    char* result = malloc(8);
    char* ip_copy = malloc(strlen(queryIP) + 1);
    strcpy(ip_copy, queryIP);
    
    if (strchr(queryIP, '.') != NULL) {
        char* parts[4];
        int count = 0;
        char* token = strtok(ip_copy, ".");
        
        while (token != NULL && count < 4) {
            parts[count++] = token;
            token = strtok(NULL, ".");
        }
        
        if (count == 4 && token == NULL) {
            int valid = 1;
            for (int i = 0; i < 4; i++) {
                if (!isValidIPv4Part(parts[i])) {
                    valid = 0;
                    break;
                }
            }
            if (valid) {
                strcpy(result, "IPv4");
                free(ip_copy);
                return result;
            }
        }
    } else if (strchr(queryIP, ':') != NULL) {
        strcpy(ip_copy, queryIP);
        char* parts[8];
        int count = 0;
        char* token = strtok(ip_copy, ":");
        
        while (token != NULL && count < 8) {
            parts[count++] = token;
            token = strtok(NULL, ":");
        }
        
        if (count == 8 && token == NULL) {
            int valid = 1;
            for (int i = 0; i < 8; i++) {
                if (!isValidIPv6Part(parts[i])) {
                    valid = 0;
                    break;
                }
            }
            if (valid) {
                strcpy(result, "IPv6");
                free(ip_copy);
                return result;
            }
        }
    }
    
    strcpy(result, "Neither");
    free(ip_copy);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We still need to examine each character once, but with more overhead

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track state

✓ Linear Space

Constraints

queryIP consists only of English letters, digits and the characters '.' and ':'
1 ≤ queryIP.length ≤ 100

23.5K Views

Medium Frequency

~15 min Avg. Time

892 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Character-by-Character Validation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler