LeetCode 468: Validate IP Address Solution in Python – A Step-by-Step Guide

What Is LeetCode 468: Validate IP Address?

In LeetCode 468: Validate IP Address, you’re given a string queryIP, and your task is to determine if it’s a valid IPv4 address, IPv6 address, or neither, returning "IPv4", "IPv6", or "Neither". IPv4 uses four decimal numbers (0-255) separated by dots (e.g., "192.168.0.1"), while IPv6 uses eight hexadecimal groups (0-ffff) separated by colons (e.g., "2001:0db8::1"). For example, "172.16.254.1" is IPv4, "2001:db8::" is IPv6, but "1.2.3.4.5" is neither. It’s like inspecting a network ID badge to see if it passes muster.

Problem Statement

• Input: queryIP (str)—IP address string.
• Output: str—"IPv4", "IPv6", or "Neither".
• Rules:
• IPv4: 4 decimal numbers (0-255), dot-separated, no leading zeros unless 0.
• IPv6: 8 hex groups (0-ffff), colon-separated, case-insensitive, no extra zeros.

Constraints

• 1 <= queryIP.length <= 5000.
• queryIP consists of digits, letters 'A' to 'F' (or 'a' to 'f'), dots, and colons.

Examples to Get Us Started

• Input: queryIP = "172.16.254.1"
• Output: "IPv4" (Valid IPv4).
• Input: queryIP = "2001:0db8:85a3:0:0:8A2E:0370:7334"
• Output: "IPv6" (Valid IPv6).
• Input: queryIP = "256.256.256.256"
• Output: "Neither" (Numbers > 255).

Understanding the Problem: Cracking the Code

To solve LeetCode 468: Validate IP Address in Python, we need to classify a string as IPv4, IPv6, or neither by checking its format and values against strict rules. A naive approach—manual char-by-char parsing—could work but is error-prone. The key? Split the string by delimiters (dots or colons) and validate each part systematically. We’ll explore:

• Best Solution (String Splitting with Rule Checking): O(n) time, O(n) space—fast and clear.
• Alternative Solution (Regular Expression): O(n) time, O(1) space—concise but complex.

Let’s dive into the splitting solution—it’s the detective’s trusty magnifying glass we need.

Best Solution: String Splitting with Rule Checking

Why This Is the Best Solution

The string splitting with rule checking approach is the top pick because it’s O(n) time (n = string length) and O(n) space, offering a straightforward, readable way to validate IPs by splitting on delimiters and applying precise rules for IPv4 and IPv6. It avoids regex complexity while maintaining efficiency, making it ideal for understanding and maintenance. It’s like breaking a code into pieces and inspecting each shard—simple and effective!

How It Works

Here’s the strategy:

• Step 1: Define validation functions:
• isIPv4: Split by '.', check 4 parts, each 0-255, no leading zeros unless "0".
• isIPv6: Split by ':', check 8 parts, each 1-4 hex digits (0-ffff).
• Step 2: Check string:
• If '.' present, test IPv4.
• If ':' present, test IPv6.
• Else, "Neither".
• Step 3: Return result.
• Why It Works:
• Splitting isolates parts for rule checks.
• Strict validation ensures compliance.

Step-by-Step Example

Example: queryIP = "172.16.254.1"

• Split: ["172", "16", "254", "1"].
• IPv4 Check:
• Length = 4 ✓.
• "172": 1-3 digits, no leading 0, 172 ≤ 255 ✓.
• "16": ✓, "254": ✓, "1": ✓.
• Result: "IPv4".

Example: queryIP = "2001:0db8:85a3:0:0:8a2e:0370:7334"

• Split: ["2001", "0db8", "85a3", "0", "0", "8a2e", "0370", "7334"].
• IPv6 Check:
• Length = 8 ✓.
• Each: 1-4 hex digits (0-ffff) ✓.
• Result: "IPv6".

Example: queryIP = "1.2.3.4.5"

• IPv4: 5 parts > 4, "Neither".
• Result: "Neither".

Code with Detailed Line-by-Line Explanation

Here’s the Python code, broken down clearly:

Copy codeclass Solution:
    def validIPAddress(self, queryIP: str) -> str:
        # IPv4 validation
        def isIPv4(s):
            parts = s.split('.')
            if len(parts) != 4:
                return False
            for part in parts:
                if not part or len(part) > 3 or (len(part) > 1 and part[0] == '0'):
                    return False
                if not part.isdigit():
                    return False
                if not 0 <= int(part) <= 255:
                    return False
            return True

        # IPv6 validation
        def isIPv6(s):
            parts = s.split(':')
            if len(parts) != 8:
                return False
            for part in parts:
                if not part or len(part) > 4:
                    return False
                for char in part:
                    if char not in "0123456789abcdefABCDEF":
                        return False
            return True

        # Step 2: Check type and validate
        if '.' in queryIP:
            return "IPv4" if isIPv4(queryIP) else "Neither"
        if ':' in queryIP:
            return "IPv6" if isIPv6(queryIP) else "Neither"
        return "Neither"

• Line 4-15: isIPv4:
• Split by '.', check 4 parts.
• Each part: 1-3 digits, no leading 0 unless "0", 0-255.
• Line 18-27: isIPv6:
• Split by ':', check 8 parts.
• Each part: 1-4 hex digits (0-ffff).
• Line 30-33: Check delimiter, call validator, return result.
• Time Complexity: O(n)—string splitting and checking.
• Space Complexity: O(n)—split parts.

It’s like an IP address decoder ring!

Alternative Solution: Regular Expression Matching

Why an Alternative Approach?

The regular expression (regex) method uses patterns—O(n) time, O(1) space—to match IPv4 and IPv6 formats in a concise but less readable way. It’s fast but requires regex mastery, like using a cryptic codebook to crack the address. Good for brevity or regex fans!

How It Works

• Step 1: Define regex patterns:
• IPv4: 4 groups of 0-255 with dots.
• IPv6: 8 groups of 0-ffff with colons.
• Step 2: Match queryIP against patterns.
• Step 3: Return type or "Neither".

Step-by-Step Example

Example: queryIP = "172.16.254.1"

• IPv4 Regex: ^((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$
• Matches: "172", "16", "254", "1" → "IPv4".
• Result: "IPv4".

Code for Regex

Copy codeimport re

class Solution:
    def validIPAddress(self, queryIP: str) -> str:
        # IPv4 pattern
        ipv4_pattern = r'^((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$'
        # IPv6 pattern
        ipv6_pattern = r'^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$'

        if re.match(ipv4_pattern, queryIP):
            return "IPv4"
        if re.match(ipv6_pattern, queryIP):
            return "IPv6"
        return "Neither"

• Line 6: IPv4 regex: 4 groups of 0-255.
• Line 8: IPv6 regex: 8 groups of 1-4 hex digits.
• Line 10-13: Match and return type.
• Time Complexity: O(n)—regex matching.
• Space Complexity: O(1)—fixed patterns.

It’s a regex codebreaker!

Comparing the Two Solutions

• String Splitting (Best):
• Pros: O(n), clear, maintainable.
• Cons: Slightly more code.
• Regex (Alternative):
• Pros: O(n), concise.
• Cons: Harder to read/debug.

Splitting wins for clarity.

Edge Cases and Examples

• Input: "" → "Neither".
• Input: "1.2.3" → "Neither".
• Input: "2001:db8::1" → "Neither" (invalid shorthand).

Splitting handles all well.

Complexity Recap

• Splitting: Time O(n), Space O(n).
• Regex: Time O(n), Space O(1).

Splitting’s the champ for readability.

Key Takeaways

• Splitting: Break and check.
• Regex: Pattern power.
• Python Tip: Split simplifies—see [Python Basics](/python/basics).

Final Thoughts: Crack Those IPs

LeetCode 468: Validate IP Address in Python is a network detective’s delight. String splitting is your clear magnifying glass, while regex is a swift cipher. Want more string parsing? Try LeetCode 125: Valid Palindrome or LeetCode 271: Encode and Decode Strings. Ready to validate some IPs? Head to Solve LeetCode 468 on LeetCode and decode it today—your coding skills are network-ready!