Chapter 3

IP Addressing and Subnetting

CompTIA Network+ (N10-009) Study GuideBased on the CompTIA Network+ N10-009 exam objectives

IP addressing is the single most tested topic on the Network+ exam. Ask any Network+ holder what they remember from test day and the answer is almost always the same: subnetting questions. This chapter turns that from your greatest fear into your greatest advantage. We're going to build the whole thing from the ground up — why addresses exist, how IPv4 works, how subnet masks carve networks into pieces, and then we'll do real subnetting calculations, step by step, with the binary math shown so you can see exactly where every number comes from.

Why IP Addressing Exists At All

Before we touch a single number, let's get the "why" right, because the exam tests the concept, not just the arithmetic.

Every device on a network needs a way to be found. On your home network, your router hands out addresses like a hotel front desk handing out room numbers — 192.168.1.101, 192.168.1.102, and so on. But the internet isn't one network. It's millions of networks stitched together, and a packet leaving your laptop in Toronto has to find a server in Sydney, Australia. That requires an addressing scheme that's routable — one where routers can look at an address and know, without a global map of every device, roughly which direction to send the packet.

IP addresses solve this the same way postal addresses do. A letter addressed to "42 Pine Street, Portland, Oregon" gets routed by country, then state, then city, then street — each level narrowing the search. An IP address works the same way: part of it identifies the network, and part identifies the host (device) on that network. Routers read the network portion to decide where to forward; only the final router needs to care about the host portion.

This network/host split is the entire foundation of everything in this chapter. Subnetting is just the art of choosing where to draw that dividing line.

IPv4: The Classic Address System

An IPv4 address is 32 bits long — 32 ones and zeros. We write it as four octets (groups of 8 bits), converted to decimal numbers separated by dots: 192.168.1.10. This dotted-decimal notation exists purely for human convenience; on the wire, it's binary.

Each octet holds values 0–255. That's not arbitrary — 8 bits gives 2^8 = 256 possible values, numbered 0 through 255. Memorize this relationship between bits and values now, because it recurs constantly:

Also memorize the powers of 2 up to 2^16 at minimum: 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536. You'll use these constantly in subnetting.

Classful Addressing (Legacy, Still Tested)

The original IPv4 design divided all addresses into classes based on the leading bits:

Classful addressing is obsolete in practice — nobody assigns networks by class anymore — but CompTIA keeps it on the exam because the terminology survives. When someone says "a Class C network," they mean a /24. You'll also need to recognize which class an address belongs to by looking at the first octet.

Public vs. Private Addresses

Not all IPv4 addresses are usable on the public internet. Three ranges are reserved as private — they can be used inside any organization's internal network but are never routed across the internet:

Your home router gives you a 192.168.x.x address. Your company probably uses 10.x.x.x. When your internal traffic reaches the internet, the router's NAT (Network Address Translation) rewrites your private source address to its own public address — that's why millions of homes can all use 192.168.1.0/24 simultaneously without conflicting. This is also the only reason IPv4 hasn't completely run out: NAT lets thousands of private addresses hide behind one public one.

Special-Purpose Addresses You Must Know

The exam tests these as "what is this address for" questions:

• Loopback (127.0.0.0/8): Traffic sent here never leaves the device. ping 127.0.0.1 tests whether your own TCP/IP stack is working — the very first troubleshooting step when a machine can't reach the network.
• APIPA (169.254.0.0/16): Automatic Private IP Addressing. When a Windows machine can't reach a DHCP server, it assigns itself an address in this range. Seeing a 169.254.x.x address is an instant diagnosis: DHCP is broken or unreachable.
• 0.0.0.0/0: The default route — "everything else." It's also the source address a DHCP client uses before it has an address.
• Broadcast addresses: 255.255.255.255 is the limited broadcast (this network only). Every network also has its own directed broadcast — the last address in its range.
• Link-local (fe80::/10 in IPv6): Covered below, but note the IPv4 APIPA range is the IPv4 equivalent of link-local addressing.

Subnet Masks and CIDR Notation

A subnet mask tells a device which part of an IP address is the network and which part is the host. It's written as 32 bits where the network portion is all 1s and the host portion is all 0s. For example, 255.255.255.0 in binary is:

11111111.11111111.11111111.00000000

The first 24 bits are 1s (network), the last 8 are 0s (hosts). We abbreviate this as /24 — CIDR (Classless Inter-Domain Routing) notation, which just counts the 1-bits. The exam uses both notations interchangeably, so you must be fluent in converting.

Memorize this octet conversion table — it's the single highest-value thing to memorize in all of Network+:

The pattern: each bit adds half the remaining distance to 255. 128, then +64 = 192, then +32 = 224, then +16 = 240, then +8 = 248, then +4 = 252, then +2 = 254, then +1 = 255.

A subnet mask never has a 1 after a 0 — it's always a solid block of 1s followed by a solid block of 0s. If you ever see something like 255.0.255.0, it's invalid. This "contiguous ones" rule is how you spot bad masks on the exam.

To find how many host bits (and thus hosts) a mask gives you: 32 minus the CIDR number = host bits. A /26 has 6 host bits, giving 2^6 = 64 addresses, minus 2 (network ID and broadcast, which can't be assigned to hosts) = 62 usable hosts.

The Two Golden Formulas

Write these on your scratch paper the moment the exam starts:

1. Number of subnets = 2^n, where n = number of bits borrowed from the host portion.
2. Usable hosts per subnet = 2^h − 2, where h = number of host bits remaining.

Everything in subnetting flows from these two formulas plus binary AND logic.

Binary Fluency Drills

Before the next worked example, let's build speed. On the exam you won't have time to count bits on your fingers — these conversions should be reflexes. Cover the answers and test yourself.

Drill 1: Mask octet → CIDR bits. What prefix length does each octet represent?

• 240 → /4 (128+64+32+16 = four 1-bits)
• 248 → /5
• 252 → /6
• 224 → /3
• 192 → /2

Drill 2: CIDR → mask octet. What decimal value is this octet?

• /26 mask's interesting octet → the /26 means 2 bits into the fourth octet: 128+64 = 192
• /19 mask's interesting octet → 3 bits into the third octet: 128+64+32 = 224
• /28 mask's interesting octet → 4 bits into the fourth octet: 240

Drill 3: Block sizes. What's the increment?

• 255.255.255.240 → 256 − 240 = 16
• 255.255.248.0 → 256 − 248 = 8 (in the third octet)
• 255.255.255.192 → 256 − 192 = 64

Drill 4: Hosts per subnet. How many usable?

• /25 → 7 host bits → 2^7 − 2 = 126
• /29 → 3 host bits → 2^3 − 2 = 6
• /20 → 12 host bits → 2^12 − 2 = 4,094

Subnetting Calculations: Worked Examples

This is where we get our hands dirty. Every example shows the full step-by-step process. Follow along with your own binary — the muscle memory matters more than the answers.

Worked Example 1: Find the Network ID and Broadcast Address

Given: IP 192.168.10.75, subnet mask 255.255.255.192 (/26).

Step 1: Convert the interesting octet to binary. The first three octets of the mask are 255 (all network bits), so the only "interesting" octet — the one that's neither 255 nor 0 — is the fourth: 192.

192 in binary: 128 + 64 = 192, so 11000000.

Step 2: Convert the matching IP octet to binary. 75 in binary: 64 + 8 + 2 + 1 = 75, so 01001011.

Step 3: AND the IP octet with the mask octet. The network ID is the bitwise AND of the address and the mask — a bit is 1 in the result only if it's 1 in both:

  192 = 1 1 0 0 0 0 0 0   (mask)
   75 = 0 1 0 0 1 0 1 1   (IP)
AND   = 0 1 0 0 0 0 0 0 = 64

Step 4: Assemble the network ID. The first three octets are unchanged (mask is 255 there): 192.168.10.64.

Step 5: Find the broadcast address. The broadcast is the network ID with all host bits set to 1. The mask's last octet is 192 (11000000), so there are 6 host bits. Setting them all to 1: 01111111 = 127. Broadcast = 192.168.10.127.

Step 6: Usable range. Usable hosts run from network ID + 1 to broadcast − 1: 192.168.10.65 through 192.168.10.126 — 62 usable addresses (2^6 − 2 = 62). ✓

Worked Example 2: How Many Subnets? How Many Hosts?

Given: You need to divide 172.16.0.0/16 into subnets that each support at least 400 hosts.

Step 1: Find the host bits needed. We need 2^h − 2 ≥ 400. 2^8 = 256 (too small), 2^9 = 512. So h = 9 host bits. 512 − 2 = 510 usable hosts per subnet — that covers 400.

Step 2: Determine the new CIDR. 32 − 9 = /23. The new mask is 255.255.254.0.

Step 3: Count the subnets. We borrowed from the original /16 to get /23: borrowed bits = 23 − 16 = 7. Number of subnets = 2^7 = 128 subnets.

Step 4: Find the subnet increment (block size). The interesting octet is the third (254 = 11111110). The increment is 256 − 254 = 2. Subnets are: 172.16.0.0/23, 172.16.2.0/23, 172.16.4.0/23, 172.16.6.0/23, and so on — each stepping by 2 in the third octet.

Worked Example 3: Which Subnet Does This Host Belong To?

Given: IP 10.20.30.45, mask 255.255.240.0 (/20). Which subnet is it in?

Step 1: Identify the interesting octet. Mask octets: 255, 255, 240, 0. Interesting = third octet (240).

Step 2: Calculate the block size. 256 − 240 = 16. Subnet boundaries in the third octet: 0, 16, 32, 48, 64...

Step 3: Find where 30 falls. 30 is between 16 and 32, so the subnet starts at 16. Network ID = 10.20.16.0/20.

Step 4 (bonus): Broadcast and range. Broadcast = next subnet minus 1 = 10.20.32.0 − 1 = 10.20.31.255. Usable range: 10.20.16.1 through 10.20.31.254. Hosts per subnet: /20 means 12 host bits → 2^12 − 2 = 4,094 usable hosts.

Notice we never touched binary in this example. The block-size method handles "which subnet" questions purely in decimal. Use binary only when you need the network ID of an address where the interesting octet requires it — and even then, the block-size method usually gets you there faster.

Worked Example 4: Subnetting a /24 Into Equal Pieces

Given: Divide 192.168.5.0/24 into 8 equal subnets.

Step 1: Borrow bits. 8 subnets = 2^3, so borrow 3 bits. New CIDR: /24 + 3 = /27. New mask: 255.255.255.224.

Step 2: Block size. 256 − 224 = 32.

Step 3: List the subnets.

Each subnet has 30 usable hosts (2^5 − 2). 8 × 32 = 256 total addresses — the full /24, nothing wasted, nothing overlapping. That's the signature of correct subnetting: the pieces tile the original space exactly.

VLSM: Variable Length Subnet Masks

Everything above used one mask size for all subnets. Real networks are messier: you might need one subnet for 200 users, another for a point-to-point WAN link that needs exactly 2 addresses, and a third for 12 servers. Giving the WAN link a /24 would waste 252 addresses.

VLSM lets each subnet use a different mask size, sized to its actual need. The technique: always allocate the largest requirement first, then carve the remainder.

Worked Example 5: Reverse-Engineering from a Host Count

Given: A branch office needs 14 subnets, each with at least 20 hosts, carved from 172.20.0.0/16.

Step 1: Satisfy the subnet count first. 14 subnets need 2^n ≥ 14 → n = 4 (16 subnets). Borrow 4 bits: /16 + 4 = /20.

Step 2: Check the host requirement. /20 leaves 12 host bits → 2^12 − 2 = 4,094 usable hosts per subnet. That's far more than 20 — fine, the requirement is a minimum. (If hosts were the tighter constraint, you'd size for hosts first and verify subnets second. Always check both.)

Step 3: Block size and first three subnets. Interesting octet: third (240). Block size = 256 − 240 = 16.

• Subnet 1: 172.20.0.0/20 (usable .0.1–.15.254, broadcast 172.20.15.255)
• Subnet 2: 172.20.16.0/20 (usable .16.1–.31.254, broadcast 172.20.31.255)
• Subnet 3: 172.20.32.0/20 (usable .32.1–.47.254, broadcast 172.20.47.255)

Step 4: Sanity check. 16 subnets × 4,096 addresses = 65,536 = the full /16. ✓ Nothing wasted, nothing overlapping.

Worked Example 6: VLSM Allocation

Given: 192.168.1.0/24. Requirements: Subnet A = 100 hosts, Subnet B = 50 hosts, Subnet C = 25 hosts, Subnet D = 2 hosts (WAN link).

Subnet A (100 hosts): Need 2^h − 2 ≥ 100 → h = 7 (126 usable). Mask /25. Block size 128. → 192.168.1.0/25 (range .1–.126, broadcast .127).

Subnet B (50 hosts): Start where A ended: 192.168.1.128. Need 2^h − 2 ≥ 50 → h = 6 (62 usable). Mask /26. Block size 64. → 192.168.1.128/26 (range .129–.190, broadcast .191).

Subnet C (25 hosts): Start at 192.168.1.192. Need 2^h − 2 ≥ 25 → h = 5 (30 usable). Mask /27. Block size 32. → 192.168.1.192/27 (range .193–.222, broadcast .223).

Subnet D (2 hosts): Start at 192.168.1.224. Need 2^h − 2 ≥ 2 → h = 2 (2 usable). Mask /30. Block size 4. → 192.168.1.224/30 (usable .225–.226, broadcast .227).

Total consumed: 128 + 64 + 32 + 4 = 228 of 256 addresses. The remaining 28 (192.168.1.228–.255) stay free for future growth.

Supernetting: The Reverse Operation

Subnetting divides; supernetting (route summarization) combines. If you have 192.168.0.0/24, 192.168.1.0/24, 192.168.2.0/24, and 192.168.3.0/24, you can advertise them to other routers as a single route: 192.168.0.0/22. This shrinks routing tables — critical for internet-scale routing.

To summarize: find the common bits. All four /24s share the first 22 bits (192.168.0–3 differ only in the last two bits of the third octet: 00, 01, 10, 11). So the summary is /22 — one route instead of four.

Let's verify with binary, because the exam sometimes gives you networks that don't summarize cleanly and expects you to catch it:

192.168.8.0  = 11000000.10101000.000010|00.00000000
192.168.9.0  = 11000000.10101000.000010|01.00000000
192.168.10.0 = 11000000.10101000.000010|10.00000000
192.168.11.0 = 11000000.10101000.000010|11.00000000

Everything left of the | is identical across all four — that's 22 bits. The summary route is 192.168.8.0/22. Now the trap version: what if the networks were 192.168.9.0/24 through 192.168.12.0/24? The common bits only extend to /21 (9 = 00001001, 12 = 00001100 — they share 21 bits), and a /21 summary (192.168.8.0/21) would also swallow 192.168.8.0/24 and 192.168.13–15.0/24, which you don't own. Advertising a summary for networks you don't have is called a black hole risk — traffic for those phantom networks gets dropped at your router. The exam tests this with "which summary is most specific" wording: always choose the longest summary that still covers exactly the listed networks, no more.

Why Classless Replaced Classful

It's worth understanding why CIDR exists, because the exam frames several questions around the motivation. Under classful addressing, an organization needing 300 hosts had to take a full Class B (65,534 addresses) — wasting over 65,000. There was no in-between: Class C gave 254, Class B gave 65,534. The internet was burning through address space at a terrifying rate in the early 1990s.

CIDR (1993) fixed this by making the network/host boundary arbitrary — any prefix length, not just /8, /16, /24. Combined with VLSM, NAT, and eventually IPv6, it bought IPv4 decades of extra life. When the exam asks "what problem did CIDR solve," the answer is address-space exhaustion caused by classful allocation waste.

IPv6: The 128-Bit Future (That's Already Here)

IPv4's 4.3 billion addresses sounded infinite in 1981. It wasn't. IPv6 uses 128-bit addresses — 340 undecillion of them, enough for every grain of sand on Earth to have its own network. The exam doesn't require IPv6 subnetting math at the depth of IPv4, but it absolutely tests the concepts.

Address Format and Shortening Rules

An IPv6 address is 8 groups of 4 hexadecimal digits: 2001:0db8:0000:0000:0000:ff00:0042:8329. Each group is 16 bits (a hextet), and hex digits 0–9 plus a–f give 16 values per digit.

Two shortening rules (and only these two — the exam tests them precisely):

1. Drop leading zeros in each hextet: 0db8 → db8, 0042 → 42.
2. Replace one run of consecutive all-zero hextets with :: — but only once per address.

So 2001:0db8:0000:0000:0000:ff00:0042:8329 becomes 2001:db8::ff00:42:8329.

IPv6 Address Types

Link-local (fe80::/10) deserves special attention: every IPv6 interface automatically gets one, and it's used for neighbor discovery, router advertisements, and DHCPv6 bootstrapping — the same jobs APIPA does in IPv4, but as a designed feature rather than a fallback.

EUI-64 is how hosts often build the second half of their address: take the 48-bit MAC address, split it in half, insert fffe in the middle, and flip the 7th bit (the universal/local bit). MAC 00:1A:2B:3C:4D:5E becomes interface ID 021a:2bff:fe3c:4d5e. Combined with a /64 network prefix from the router, the host has a full global address — no DHCP required. This is SLAAC (Stateless Address Autoconfiguration).

Neighbor Discovery: IPv6's Replacement for ARP

IPv4 uses ARP (broadcast-based) to map IP addresses to MAC addresses. IPv6 has no broadcast at all — instead it uses Neighbor Discovery Protocol (NDP), which runs over ICMPv6 using multicast. Five message types do the work:

• Router Solicitation / Router Advertisement: Hosts ask "any routers here?" and routers reply with the network prefix, MTU, and flags indicating whether to use SLAAC, stateless DHCPv6, or stateful DHCPv6. This is how a host learns its /64 without any configuration.
• Neighbor Solicitation / Neighbor Advertisement: The ARP replacement — "who has this IPv6 address?" answered with "I do, here's my MAC." It uses solicited-node multicast (a special multicast group derived from the target's address) instead of broadcast, so only the target is disturbed.
• Redirect: A router telling a host "use this other router for that destination" — same concept as ICMP redirects in IPv4.

Why does the exam care? Because NDP questions test whether you understand that IPv6 eliminated broadcast entirely. Any answer choice involving "ARP" or "broadcast" in an IPv6 context is wrong. Duplicate Address Detection (DAD) — a host checking that its chosen address isn't already in use — is also an NDP function (neighbor solicitation to its own tentative address; silence means it's free).

IPv6 Transition Mechanisms

Since IPv4 and IPv6 must coexist during the long transition, several tunneling and translation methods exist:

• Dual stack: Running both protocols simultaneously. The device and network speak whichever the destination supports. This is the most common real-world approach.
• Tunneling (6to4, Teredo, ISATAP): Encapsulating IPv6 packets inside IPv4 packets to cross IPv4-only infrastructure.
• NAT64: Translating between IPv6-only clients and IPv4-only servers.

Putting It Together: Address Planning Scenario

Let's do what a real network admin does. Scenario: A small business with 3 departments needs a network plan from the private range 10.10.0.0/16.

Requirements:

• Engineering: 400 hosts
• Sales: 180 hosts
• Management: 60 hosts
• Server farm: 25 hosts
• Two WAN links to branch offices: 2 hosts each

Step 1: Size each subnet (largest first).

Step 2: Allocate sequentially from 10.10.0.0.

• Engineering: 10.10.0.0/23 → range 10.10.0.1–10.10.1.254, broadcast 10.10.1.255
• Sales: 10.10.2.0/24 → range 10.10.2.1–10.10.2.254, broadcast 10.10.2.255
• Management: 10.10.3.0/26 → range 10.10.3.1–10.10.3.62, broadcast 10.10.3.63
• Servers: 10.10.3.64/27 → range 10.10.3.65–10.10.3.94, broadcast 10.10.3.95
• WAN 1: 10.10.3.96/30 → usable 10.10.3.97–.98, broadcast 10.10.3.99
• WAN 2: 10.10.3.100/30 → usable 10.10.3.101–.102, broadcast 10.10.3.103

Step 3: Document. A real plan also records the gateway address for each subnet (conventionally the first usable: .1), the DNS servers, and which VLAN each subnet maps to. On the exam, "first usable address" is the standard answer for "what should the default gateway be" — though any usable address works in practice.

The Subnetting Traps Hall of Fame

Before the practice questions, let's collect every trap the exam sets in this topic — the greatest-hits list of wrong answers that look right:

1. Forgetting the minus 2. "How many usable hosts in a /28?" The answer is 14, not 16. The network ID and broadcast are never assignable. This single trap accounts for more wrong answers than any other.
2. The 127 trap. 127.0.0.1 looks like a Class A address. It's loopback — never a valid host assignment on a network interface for production traffic.
3. The 172.16–31 trap. 172.32.0.1 is not private. The private Class B range stops at 172.31.255.255.
4. Counting subnets wrong. Borrowing 3 bits gives 8 subnets (2^3), not 6, not 7. The exam offers "6 subnets from 3 borrowed bits" as a distractor — subnet counts are always powers of 2.
5. Mixing up network ID and first usable. The network ID (e.g., 192.168.1.0/26) is not assignable to a host. The first usable is network ID + 1 (.1). "Assign 192.168.1.64 to a workstation in the 192.168.1.64/26 subnet" is an invalid configuration.
6. Double :: in IPv6. Only one :: per address, ever.
7. Broadcast confusion. 255.255.255.255 is the limited broadcast (local link only). A directed broadcast targets a specific remote network's broadcast address — routers typically block these by default as a smurf-attack defense.
8. VLSM out of order. Allocating small subnets first fragments the space. Largest requirement first, always.
9. Supernet vs. subnet direction. Summarizing shortens the mask (/24s → /22); subnetting lengthens it (/24 → /26). If your "summary" has a longer prefix than the components, you've gone the wrong way.
10. APIPA means DHCP. 169.254.x.x is never the goal — it's the symptom. The fix is always on the DHCP side.

---

End-of-Chapter Test

1. A host has the IP address 192.168.20.150 with subnet mask 255.255.255.128. What is the network ID?

• A. 192.168.20.0
• B. 192.168.20.128
• C. 192.168.20.64
• D. 192.168.20.192

2. How many usable host addresses are available in a /27 subnet?

• A. 32
• B. 30
• C. 28
• D. 62

3. Which of the following is a valid private IPv4 address?

• A. 172.45.10.5
• B. 172.20.15.100
• C. 192.169.1.10
• D. 11.0.0.5

4. A network administrator needs to divide 10.0.0.0/8 into subnets supporting 1,000 hosts each. What is the correct new subnet mask?

• A. 255.255.252.0
• B. 255.255.254.0
• C. 255.255.0.0
• D. 255.254.0.0

5. What is the broadcast address for the subnet containing host 172.16.45.10/20?

• A. 172.16.47.255
• B. 172.16.45.255
• C. 172.16.48.255
• D. 172.16.63.255

6. Which IPv6 address is INVALID?

• A. 2001:db8::ff00:42:8329
• B. fe80::1
• C. 2001:db8::1::2
• D. ::1

7. A technician sees that a workstation has the IP address 169.254.23.10. What is the most likely cause?

• A. The subnet mask is misconfigured
• B. The DHCP server is unreachable
• C. The DNS server is down
• D. The default gateway is incorrect

8. You need 6 subnets from 192.168.100.0/24. What subnet mask should you use?

• A. 255.255.255.192
• B. 255.255.255.224
• C. 255.255.255.240
• D. 255.255.255.248

9. What is the purpose of the EUI-64 process in IPv6?

• A. To encrypt IPv6 traffic between hosts
• B. To automatically generate the 64-bit interface ID from the MAC address
• C. To compress IPv6 headers for faster routing
• D. To translate IPv6 addresses to IPv4 addresses

10. Which single summarized route covers 192.168.8.0/24, 192.168.9.0/24, 192.168.10.0/24, and 192.168.11.0/24?

• A. 192.168.8.0/21
• B. 192.168.8.0/22
• C. 192.168.0.0/20
• D. 192.168.8.0/23

11. A point-to-point WAN link connects two routers. Which subnet mask wastes the fewest addresses while providing enough usable addresses?

• A. 255.255.255.0
• B. 255.255.255.252
• C. 255.255.255.248
• D. 255.255.255.128

12. A host with IPv6 address fe80::a1b2:c3ff:fe44:5566 is communicating on the local network. What type of address is this?

• A. Global unicast
• B. Link-local
• C. Unique local
• D. Multicast

---

Answer Key

1. B — Mask /25: interesting octet is the fourth (128). Block size = 256 − 128 = 128. Subnets: .0 and .128. Host 150 falls in .128–.255, so the network ID is 192.168.20.128.

2. B — /27 leaves 5 host bits. 2^5 = 32 total addresses, minus 2 (network ID and broadcast) = 30 usable hosts.

3. B — 172.20.15.100 falls in the private 172.16.0.0/12 range (172.16–172.31). A (172.45) and D (11.x) are public; C (192.169.x) is not in the 192.168.0.0/16 private range.

4. A — Need 2^h − 2 ≥ 1000 → h = 10 (1022 usable). New CIDR = 32 − 10 = /22. /22 = 255.255.252.0.

5. A — /20: interesting octet is the third (240). Block size = 256 − 240 = 16. Subnets: 172.16.0.0, 172.16.16.0, 172.16.32.0, 172.16.48.0... Host .45 falls in 172.16.32.0/20. Broadcast = next subnet (172.16.48.0) minus 1 = 172.16.47.255.

6. C — The double colon :: may appear only once per address. Two occurrences make the address ambiguous and invalid.

7. B — 169.254.x.x is APIPA, which Windows assigns when no DHCP server can be reached. Always a DHCP problem.

8. B — 6 subnets need 2^3 = 8 (3 borrowed bits, since 2^2 = 4 is too few). /24 + 3 = /27 = 255.255.255.224.

9. B — EUI-64 builds the 64-bit interface identifier from the 48-bit MAC address by inserting fffe and flipping the universal/local bit, enabling SLAAC.

10. B — Four consecutive /24s starting at a multiple of 4 (8, 9, 10, 11) summarize to /22. The third octet values 8–11 share the first 6 bits (000010xx), so 22 network bits cover all four.

11. B — A point-to-point link needs exactly 2 usable addresses. /30 (255.255.255.252) provides 2^2 − 2 = 2 usable hosts — the standard choice with zero waste.

12. B — fe80::/10 is the link-local prefix. This address is auto-configured and valid only on the local link.