0390MediumString

Classify a Host Address

Tracked in this browser only

Trains the technique from

This is an original problem, written from a brief that listed the technique, the difficulty, the topics, the function shape and the input bounds — none of that problem's wording, examples, hints or editorials. The link is there so you can map your practice onto the standard set.

Same function shape, different story and different numbers.

A switch's admin console asks the operator to type a host address and has to say what kind of address it got. Given the typed text address, return "IPv4" if it is a valid version 4 address, "IPv6" if it is a valid version 6 address, and "Neither" if it is neither.

A valid IPv4 address is four decimal chunks joined by single dots. Each chunk is one to three digits long, stands for a value from 0 to 255, and carries no leading zero unless the chunk is the single digit 0. So 10.0.42.7 is valid, while 10.0.42.256, 10.0.007.7 and 10.0.42 are not.

A valid IPv6 address is eight groups joined by single colons. Each group is one to four hexadecimal digits, taken from 0-9, a-f and A-F. Leading zeros inside a group are fine and upper and lower case are both fine, but an empty group is not allowed and the shorthand that collapses a run of zero groups is not accepted by this console.

Nothing else counts: an address that is short a chunk, carries an extra separator or mixes the two forms is "Neither".

Examples

Example 1

Input: address = "10.0.42.7"
Output: "IPv4"

Four digit chunks, each between 0 and 255, none of them with a leading zero.

Example 2

Input: address = "012.4.5.6"
Output: "Neither"

The first chunk is written "012", and a chunk longer than one digit may not start with 0.

Example 3

Input: address = "abcd:1234:0000:0000:9999:aaaa:bbbb:0001"
Output: "IPv6"

Eight groups, each one to four hexadecimal digits long.

Example 4

Input: address = "1:2:3:4:5:6:7"
Output: "Neither"

Only seven groups are present, and this console does not accept a collapsed run.

Constraints

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

The signature

The editor is preloaded with this. It matches the parent problem's shape, so a solution that works here transfers to a judge unchanged.

Python

def valid_i_p_address(address: str) -> str:

Java

public String validIPAddress(String address)

The intended approach

Time O(L)Space O(L) for the split pieces

The separator count decides which form is even a candidate, so split on dots first: exactly four pieces means the text can only be an IPv4 address, and each piece is then checked for length, digits only, no leading zero and a value within 255. A group of an IPv6 address never contains a dot, so if the dotted check fails there is nothing more to try. Otherwise split on colons and require exactly eight pieces, each one to four characters drawn from the hexadecimal digits.

Pythonentry point: valid_i_p_address

def valid_i_p_address(address):
    # Time O(L) -- every character is looked at a constant number of times.
    # Space O(L) for the split pieces.
    chunks = address.split(".")
    if len(chunks) == 4:
        for chunk in chunks:
            if len(chunk) < 1 or len(chunk) > 3:
                return "Neither"
            for ch in chunk:
                if ch < "0" or ch > "9":
                    return "Neither"
            if len(chunk) > 1 and chunk[0] == "0":
                return "Neither"
            if int(chunk) > 255:
                return "Neither"
        return "IPv4"
    groups = address.split(":")
    if len(groups) == 8:
        allowed = "0123456789abcdefABCDEF"
        for group in groups:
            if len(group) < 1 or len(group) > 4:
                return "Neither"
            for ch in group:
                if ch not in allowed:
                    return "Neither"
        return "IPv6"
    return "Neither"

The obvious version

Match the whole text against one anchored regular expression per form, with the 0-255 range spelled out as alternatives so leading zeros cannot slip through. No splitting or per-character work in the author's code at all.

This is not filler. It was written independently of the fast solution and the two were run against thousands of random inputs to confirm they agree — which is how the answer above is known to be right. Read it when the intended approach feels like a rabbit pulled out of a hat.

Python

import re

_V4 = re.compile(r"^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}"
                 r"(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$")
_V6 = re.compile(r"^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$")


def bf_valid_i_p_address(address):
    if _V4.match(address):
        return "IPv4"
    if _V6.match(address):
        return "IPv6"
    return "Neither"

How this problem was checked

Reference solution executed against 17 test cases — 17 passed
4 worked examples confirmed by running the code
0 eight-word sequences shared with the parent problem's text
Agrees with an independent brute-force implementation on random inputs
Test set proven to catch deliberately broken solutions
Reviewed by a separate quality pass
Function arity matches the parent problem's

Create a free account to unlock the solution

See the step-by-step animation, the intuition, and clean code in every language — free, no credit card.

Create a free account Already have an account? Sign in