Constraints

• start_ip is a valid IPv4 address.
• 0 <= n <= 100000
• Do not produce any address greater than 255.255.255.255.

Examples

Solution

def solution(start_ip, n):
    def ip_to_int(ip):
        a, b, c, d = map(int, ip.split('.'))
        return (a << 24) | (b << 16) | (c << 8) | d

    def int_to_ip(value):
        return '.'.join(str((value >> shift) & 255) for shift in (24, 16, 8, 0))

    if n <= 0:
        return []

    current = ip_to_int(start_ip)
    limit = 0xFFFFFFFF
    steps = min(n, limit - current + 1)

    return [int_to_ip(current + i) for i in range(steps)]

Time complexity: O(k), where k is the number of addresses returned. Space complexity: O(k).

Hints

1. Convert the IPv4 string into a 32-bit integer so incrementing becomes simple.
2. The largest possible IPv4 value is 2^32 - 1.

Constraints

• end_ip is a valid IPv4 address.
• 0 <= n <= 100000
• Do not produce any address smaller than 0.0.0.0.

Examples

Solution

def solution(end_ip, n):
    def ip_to_int(ip):
        a, b, c, d = map(int, ip.split('.'))
        return (a << 24) | (b << 16) | (c << 8) | d

    def int_to_ip(value):
        return '.'.join(str((value >> shift) & 255) for shift in (24, 16, 8, 0))

    if n <= 0:
        return []

    current = ip_to_int(end_ip)
    steps = min(n, current + 1)

    return [int_to_ip(current - i) for i in range(steps)]

Time complexity: O(k), where k is the number of addresses returned. Space complexity: O(k).

Hints

1. Treat the IPv4 address as an unsigned 32-bit integer and subtract 1 at each step.
2. The smallest possible IPv4 value is 0.

Constraints

• cidr is valid and has a prefix length in the range 0 to 32.
• For this problem, the expanded range size will be at most 4096 addresses.
• Use bitwise masking to compute the network and end addresses.

Examples

Solution

def solution(cidr):
    def ip_to_int(ip):
        a, b, c, d = map(int, ip.split('.'))
        return (a << 24) | (b << 16) | (c << 8) | d

    def int_to_ip(value):
        return '.'.join(str((value >> shift) & 255) for shift in (24, 16, 8, 0))

    ip_text, prefix_text = cidr.split('/')
    prefix = int(prefix_text)
    ip_value = ip_to_int(ip_text)

    if prefix == 0:
        mask = 0
    else:
        mask = (0xFFFFFFFF << (32 - prefix)) & 0xFFFFFFFF

    start = ip_value & mask
    end = start | (0xFFFFFFFF ^ mask)
    addresses = [int_to_ip(value) for value in range(start, end + 1)]

    return int_to_ip(start), int_to_ip(end), addresses

Time complexity: O(m), where m is the number of addresses in the CIDR range. Space complexity: O(m).

Hints

1. To get the network address, keep the first prefix_len bits and zero out the rest.
2. To get the highest address in the CIDR block, set all host bits to 1.

Constraints

• cidr is valid and has a prefix length in the range 0 to 32.
• 0 <= k <= 1000
• The CIDR block may be as large as /0, so expanding the full range is not allowed.

Examples

Solution

def solution(cidr, k):
    def ip_to_int(ip):
        a, b, c, d = map(int, ip.split('.'))
        return (a << 24) | (b << 16) | (c << 8) | d

    def int_to_ip(value):
        return '.'.join(str((value >> shift) & 255) for shift in (24, 16, 8, 0))

    ip_text, prefix_text = cidr.split('/')
    prefix = int(prefix_text)
    ip_value = ip_to_int(ip_text)

    if prefix == 0:
        mask = 0
    else:
        mask = (0xFFFFFFFF << (32 - prefix)) & 0xFFFFFFFF

    start = ip_value & mask
    count = 1 << (32 - prefix)
    end = start + count - 1

    if k <= 0:
        first_k = []
        last_k = []
    else:
        take = min(k, count)
        first_k = [int_to_ip(start + i) for i in range(take)]
        last_start = end - take + 1
        last_k = [int_to_ip(last_start + i) for i in range(take)]

    return count, int_to_ip(start), int_to_ip(end), first_k, last_k

Time complexity: O(k). Space complexity: O(k).

Hints

1. A CIDR block with prefix p contains 2^(32 - p) addresses.
2. You can compute the first k and last k addresses directly from the integer start and end values.