Exercises — IPv4 — address format, classes, subnetting, CIDR notation

WHAT we want: turn a prefix length into 32 mask bits, then read them as four decimal octets. WHY: the mask is defined as $n$ ones followed by $32-n$ zeros.

• $n=20$ ones, then $12$ zeros: $\underset{255}{\underbrace{11111111}}.\underset{255}{\underbrace{11111111}}.\underset{?}{\underbrace{11110000}}.\underset{0}{\underbrace{00000000}}$
• Third octet 11110000 $=128+64+32+16=240$.
• Answer: 255.255.240.0.

WHAT: classify by the first octet, because the class is literally decided by the leading bits of that octet — and the leading bits pin down a decimal range. WHY the ranges are what they are: the first octet is 8 bits $b_7{b}_6{b}_5\dots b_0$, with place values $128,64,32,\dots ,1$.

• Class A starts with 0: so $b_7=0$. The largest such octet is 01111111 $=127$, smallest 00000000 $=0$ → range 0–127 (usable 1–126, since 0 and 127 are reserved).
• Class B starts with 10: so $b_7=1,b_6=0$. Smallest 10000000 $=128$, largest 10111111 $=191$ → range 128–191.
• Class C starts with 110: so $b_7=1,b_6=1,b_5=0$. Smallest 11000000 $=192$, largest 11011111 $=223$ → range 192–223. Now apply it: first octet $=172$. Since $128\le 172\le 191$, its top two bits are 10 ⇒ Class B.
• Class B default: 10 leading bits, 16 network bits ⇒ default prefix /16.
• Answer: Class B, /16.

WHAT: count host patterns, then remove the two reserved ones. WHY subtract 2: the all-zeros host pattern is the network address and the all-ones host pattern is the broadcast address — neither is assignable to a machine.

• $h=32-29=3$ host bits ⇒ $2^3=8$ total patterns.
• Subtract 2 (network + broadcast).
• Answer: $8-2=6$ usable hosts.

WHAT: write each octet as a sum of powers of 2, then read the on/off bits. WHY greedy works: at each step the largest power of 2 that fits must be present (if it weren't, all smaller powers together still couldn't reach the value), so subtracting it and repeating reconstructs the exact bit pattern (see Binary and Positional Number Systems).

• $192=128+64=\text{11000000}$
• $168=128+32+8=\text{10101000}$
• $5=4+1=\text{00000101}$
• $130=128+2=\text{10000010}$
• Answer: 11000000.10101000.00000101.10000010.

WHAT: only the last octet is interesting because $27=24+3$, so the mask breaks inside the 4th octet. WHY only the last octet: the first 24 mask bits fully cover octets 1–3, fixing them; the interesting variation lives entirely in octet 4.

• Host bits $h=32-27=5$. Block size in last octet $=2^5=32$.
• Boundaries (multiples of 32): $0,32,64,96,\dots$
• $45$ falls in $[32,64)$ ⇒ network octet = 32.
• Network: 10.20.30.32.
• Broadcast = next boundary $-1=64-1=63$ ⇒ 10.20.30.63.
• Usable hosts: .33 through .62 (that's $2^5-2=30$ addresses).

WHAT: borrow the fewest host bits that still gives $\ge 6$ subnets, so each subnet stays as large as possible. WHY fewest bits: every bit borrowed for subnetting is one fewer host bit, so over-borrowing needlessly shrinks each subnet.

• Need $2^s\ge 6$. $2^2=4$ (too few), $2^3=8\ge 6$ ✓ ⇒ borrow $s=3$.
• New prefix $=24+3=/27$.
• Host bits $h=32-27=5$ ⇒ hosts per subnet $=2^5-2=30$.
• (You get 8 subnets total, use 6, keep 2 spare — that's fine.)

WHAT: two hosts are in the same subnet iff their network addresses match. Find each network address using the /26 block. WHY the iff: direct delivery only happens inside one subnet; if network addresses differ, the source must hand the packet to a router.

• $n=26\Rightarrow h=6\Rightarrow$ block size $=2^6=64$. Boundaries: $0,64,128,192$.
• $66$ is in $[64,128)$ ⇒ network 192.168.10.64.
• $130$ is in $[128,192)$ ⇒ network 192.168.10.128.
• $64\ne 128$ ⇒ different subnets.
• Answer: No — they need a router/gateway. Their packets must be routed, they cannot ARP each other directly.

WHAT: find the longest bit-prefix common to all four third octets; that becomes the aggregate. WHY: a single CIDR block is a fixed prefix plus every combination of the remaining bits — so the aggregate prefix is exactly the shared leading bits. The figure below stacks the four third octets in binary so you can literally see where they agree and where they split.

• Third octets in binary (also shown teal = shared, orange = varying in the figure):
  • $4=\text{00000100}$
  • $5=\text{00000101}$
  • $6=\text{00000110}$
  • $7=\text{00000111}$
• They agree on the top 6 bits (000001) and vary only in the low 2 bits ($00,01,10,11$ = all of $\mathrm{4..7}$).
• Common prefix length $=16$ (first two octets) $+6=22$.
• Answer: 192.168.4.0/22. It covers exactly $4,5,6,7$ in the third octet — no more, no less.
• Check the range: a /22 spans a block of $2^{(8-(22\mathrm{mod}8))}=2^2=4$ in the third octet, starting at a multiple of 4 → starts at $4$, covers $4,5,6,7$. ✓

WHAT: routers use longest prefix match — among all routes whose network contains the destination, pick the one with the largest prefix (most specific). WHY most-specific wins: a longer prefix names a smaller, more precisely targeted network, which is more likely the correct next hop than a broad catch-all.

• Does 10.0.0.0/8 contain it? First octet $10=10$ ✓ — match.
• Does 10.1.128.0/18 contain it? $n=18$ ⇒ mask covers the first 2 bits of the third octet; block in 3rd octet $=2^{(8-(18\mathrm{mod}8))}=2^6=64$, starting at $128$ ⇒ covers $\mathrm{128..191}$. $130\in [128,192)$ ✓ — match.
• Does 10.1.128.0/20 contain it? $n=20$ ⇒ block in 3rd octet $=2^{(8-4)}=2^4=16$, starting at $128$ ⇒ covers $\mathrm{128..143}$. $130\in [128,144)$ ✓ — match.
• All three match. Longest prefix wins: $20>18>8$.
• Answer: route 10.1.128.0/20 is used.

WHAT: with VLSM we size each subnet independently — allocate the largest block first so it lands on a clean boundary, then carve smaller blocks from what's left. WHY largest-first: a big block must begin on a boundary that is a multiple of its own size; placing small blocks first can leave only misaligned gaps too small for the big one. For each need, pick the smallest $h$ with $2^h-2\ge$ required hosts.

Dept A — 500 hosts: need $2^h-2\ge 500$. $2^9-2=510\ge 500$ ✓ ($2^8-2=254$ too small). $h=9\Rightarrow n=32-9=23$. → 172.20.0.0/23 (covers 172.20.0.0–172.20.1.255, 510 hosts).

Dept B — 200 hosts: $2^8-2=254\ge 200$ ✓. $h=8\Rightarrow /24$. Next free address is 172.20.2.0. → 172.20.2.0/24 (254 hosts).

Dept C — 50 hosts: $2^6-2=62\ge 50$ ✓ ($2^5-2=30$ too small). $h=6\Rightarrow /26$. Next free is 172.20.3.0, block size $2^6=64$. → 172.20.3.0/26 (62 hosts, 172.20.3.0–172.20.3.63).

Link P2P — 2 hosts: $2^2-2=2\ge 2$ ✓. $h=2\Rightarrow /30$. Next free is 172.20.3.64, block size $2^2=4$. → 172.20.3.64/30 (2 hosts, .65 and .66; net .64, broadcast .67).

Answer table:

Everything fits inside the original /16 with room to spare.

WHAT: the network address is (address AND mask), bit by bit — this is exactly Subnet Mask and ANDing. WHY AND: a mask bit of 1 keeps the address bit (network part), a mask bit of 0 forces it to 0 (host part cleared), which is precisely what "network address" means. Only the last octet differs from the mask's all-ones octets, so only it needs work.

• Mask last octet $192=\text{11000000}$ ⇒ 2 network bits in that octet ⇒ prefix $=24+2=/26$.
• Address last octet $37=\text{00100101}$.
• AND with 11000000: $\text{00100101}\text{AND}\text{11000000}=\text{00000000}=0$
• Answer: network 192.168.100.0/26. (Block size $64$; $37\in [0,64)$ confirms it.)

WHAT: count consumed addresses per link, multiply by 1000, compare. WHY /31 is allowed here: on a link with exactly two endpoints there is no need for a broadcast address, so the usual "$-2$" rule is waived — both addresses become usable.

• /30: $h=2\Rightarrow 2^2=4$ addresses per link. $1000\times 4=4000$.
• /31: $h=1\Rightarrow 2^1=2$ addresses per link (both usable, special-cased). $1000\times 2=2000$.
• Saved: $4000-2000=2000$ addresses.
• Answer: /30 uses 4000, /31 uses 2000, saving 2000 addresses across the backbone.

WHAT (Part A) — aggregate all eight: find the longest shared bit-prefix of the third octets. WHY: identical reasoning to 3.2 — a CIDR block is a shared prefix plus all combinations of the free bits.

• Third octets $16$ to $23$. In binary: $16=\text{00010000}$, $23=\text{00010111}$.
• They agree on the top 5 bits (00010) and vary in the low 3 bits ($000$ through $111$ = all of $\mathrm{16..23}$).
• Prefix $=16+5=21$.
• Answer: 10.6.16.0/21 (block of $2^3=8$ in the third octet, starting at a multiple of 8 → $16$, covers $\mathrm{16..23}$). ✓

WHAT (Part B) — why 16–22 (seven) can't be one clean block: WHY: a single CIDR block must contain a power-of-two count of /24s, and it must start on a matching boundary.

• Seven is not a power of two. Any single prefix that covers $16$ through $22$ would be /21 (block of 8) — but that block is $\mathrm{16..23}$, which includes 23, an address you might not own/want.
• A /22 block (size 4) covers only $\mathrm{16..19}$; another /22 covers $\mathrm{20..23}$. You cannot straddle these two /22 groups with one prefix except by going up to /21 (all 8).
• Conclusion: with exactly $\mathrm{16..22}$ you need multiple blocks, e.g. 10.6.16.0/22 (16–19) + 10.6.20.0/23 (20–21) + 10.6.22.0/24 (22). No single aggregate exists.

Usable hosts in /n ::: $2^{32-n}-2$ Same-subnet test for two hosts ::: their network addresses (address AND mask) are equal Router picks which matching route ::: the longest prefix (most specific) Two conditions for a valid CIDR aggregate ::: power-of-two count AND aligned start Smallest $s$ to make $k$ subnets ::: smallest $s$ with $2^s\ge k$