IP to CIDR - Practice Coding Problems

IP to CIDR - Problem

Imagine you're a network administrator who needs to efficiently organize IP address ranges using CIDR blocks. This problem challenges you to find the minimum number of CIDR blocks needed to cover a specific range of IP addresses.

Background:
• An IP address is a 32-bit number displayed as four decimal groups separated by dots (e.g., 192.168.1.1)
• A CIDR block like 192.168.1.0/24 represents a range of IP addresses where the first 24 bits are fixed

Your Task:
Given a starting IP address and a count n, find the minimum number of CIDR blocks that cover exactly the range [ip, ip + n - 1]. No other IP addresses should be included.

Example: If you start at 255.0.0.7 and need to cover 10 addresses, you might use blocks like 255.0.0.7/32 (1 address), 255.0.0.8/30 (4 addresses), etc.

Input & Output

example_1.py — Basic Range

$ Input: ip = "255.0.0.7", n = 10

› Output: ["255.0.0.7/32", "255.0.0.8/30", "255.0.0.12/30", "255.0.0.16/32"]

💡 Note: Starting at 255.0.0.7, we need 10 addresses. The optimal solution uses: 1 address (255.0.0.7/32), 4 addresses (255.0.0.8/30), 4 addresses (255.0.0.12/30), and 1 address (255.0.0.16/32).

example_2.py — Power of 2 Alignment

$ Input: ip = "192.168.1.0", n = 8

› Output: ["192.168.1.0/29"]

💡 Note: Since we start at an address ending in .0 and need exactly 8 addresses (2^3), we can use a single /29 block that covers exactly 8 addresses.

example_3.py — Single Address

$ Input: ip = "10.0.0.1", n = 1

› Output: ["10.0.0.1/32"]

💡 Note: For a single address, we use a /32 CIDR block which represents exactly one IP address.

Constraints

1 ≤ n ≤ 1000
The given IP address is valid
ip + n - 1 will not overflow (stays within valid IP range)
IP address format: Each octet is between 0 and 255

Visualization

Tap to expand

Understanding the Visualization

Start with IP Address

Convert the starting IP address to its 32-bit integer representation

Find Maximum Block Size

Analyze the rightmost set bit to determine the largest possible CIDR block

Create Optimal Block

Choose the largest block that doesn't exceed the remaining count

Repeat Until Complete

Continue until all IP addresses are covered

Key Takeaway

🎯 Key Insight: The rightmost set bit in an IP address's binary representation determines the maximum CIDR block size that can start at that address, enabling optimal greedy selection.

Asked in

G Google 25 a Amazon 20 ⊞ Microsoft 15 f Meta 10

The optimal solution uses greedy bit manipulation to create the minimum number of CIDR blocks. The key insight is that the largest CIDR block we can create at any IP address depends on its rightmost set bit in binary representation. By iteratively finding the largest valid block at each step, we minimize the total number of blocks needed to cover the range.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Bit Manipulation (Optimal)	O(log n)	O(log n)	Use bit manipulation to find the largest possible CIDR blocks that fit perfectly

Greedy Bit Manipulation (Optimal) — Algorithm Steps

Convert starting IP to integer representation
While we still have addresses to cover:
Find the rightmost set bit in current IP (determines max block size)
Calculate the largest block size that doesn't exceed remaining count
Create CIDR block with appropriate prefix length
Move to next IP address and update remaining count

Visualization

Tap to expand

Step-by-Step Walkthrough

Analyze Starting IP

Find rightmost set bit to determine maximum possible block size

Calculate Block Size

Choose largest block that fits within remaining count

Create CIDR Block

Generate block with appropriate prefix length

Repeat

Continue until all IPs are covered

Code -

solution.c — C

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

typedef struct {
    char** data;
    int size;
} StringArray;

unsigned int ipToUint(const char* ip) {
    unsigned int a, b, c, d;
    sscanf(ip, "%u.%u.%u.%u", &a, &b, &c, &d);
    return (a << 24) + (b << 16) + (c << 8) + d;
}

void uintToIp(unsigned int ipInt, char* buffer) {
    sprintf(buffer, "%u.%u.%u.%u",
        (ipInt >> 24) & 255, (ipInt >> 16) & 255,
        (ipInt >> 8) & 255, ipInt & 255);
}

int countTrailingZeros(unsigned int x) {
    if (x == 0) return 32;
    int count = 0;
    while ((x & 1) == 0) {
        count++;
        x >>= 1;
    }
    return count;
}

StringArray ipToCIDR(const char* ip, int n) {
    StringArray result;
    result.data = malloc(32 * sizeof(char*)); // max possible blocks
    result.size = 0;
    
    unsigned int startInt = ipToUint(ip);
    
    while (n > 0) {
        int trailingZeros = countTrailingZeros(startInt);
        unsigned int maxBlockSize = 1U << trailingZeros;
        
        unsigned int blockSize = 1;
        while (blockSize <= maxBlockSize && blockSize <= n && blockSize * 2 <= n) {
            blockSize *= 2;
        }
        
        int prefixLen = 32 - (int)log2(blockSize);
        
        result.data[result.size] = malloc(20 * sizeof(char));
        char ipStr[16];
        uintToIp(startInt, ipStr);
        sprintf(result.data[result.size], "%s/%d", ipStr, prefixLen);
        result.size++;
        
        startInt += blockSize;
        n -= blockSize;
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Each iteration potentially doubles the block size, so we need at most log n iterations

⚡ Linearithmic

Space Complexity

O(log n)

The result contains at most log n CIDR blocks in the worst case

⚡ Linearithmic Space

18.5K Views

Medium Frequency

~25 min Avg. Time

580 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

Greedy Bit Manipulation (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler