# Hi there!

First things first – thanks for purchasing this eBook! I know you’ll find it helpful in conquering any anxiety you may feel about working with binary math and subnetting.
The methods you’ll learn in this book have helped thousands of students around the world pass computer certification exams – and just as importantly, prepared them for real-world networking success.
Right now, I’ll zip my lip so we can get started!
Chris Bryant
“The Computer Certification Bulldog:
Udemy: https://www.udemy.com/u/chrisbryant
(Over 30,000 happy students and growing every day!)
(Over 325 free training videos!)
(New look and easier-to-find tutorials in Dec. 2013!
See you there -- Chris B.

All rights reserved. This book or any portion thereof may not be reproduced or used in any manner whatsoever without the express written permission of the publisher except for the use of brief quotations in a book review.
No part of this publication may be stored in a retrieval system, transmitted, or reproduced in any way, including but not limited to photocopy, photograph, magnetic, or other record, without the prior agreement and written permission of the publisher.
The Bryant Advantage, Inc., has attempted throughout this book to distinguish proprietary trademarks from descriptive terms by following the capitalization style used by the manufacturer. Copyrights and trademarks of all products and services listed or described herein are property of their respective owners and companies. All rules and laws pertaining to said copyrights and trademarks are inferred.
Printed in the United States of America
First Printing, 2013
9975 Revolutionary Place
Mechanicsville, VA 23116

Converting Decimals to Binary Strings
Converting Binary Strings to Decimals
Determining The Number Of Valid Subnets
Determining The Number Of Valid Hosts
Determining The Subnet Of A Given IP Address
Subnetting From Scratch (Just called "Subnetting" in the header)

Success Skill #1Converting Decimals to Binary Strings
Let’s get right to it!
One quick warning: This is one of those processes that seems complicated when you read about it, but once you’re doing it, you realize how simple it is.
Let’s start with the decimal 217 and our grid. Can you subtract 128 from 217? Sure, with a remainder of 89. Put a “1” under the 128.

128
64
32
16
8
4
2
1

1
1

Can you subtract 64 from 89? Yes, with a remainder of 25. Put a “1” under the 64.

128
64
32
16
8
4
2
1

1
1
1

Can you subtract 32 from 25? No, so that’s a zero under the 32. Moving to the right, can you subtract 16 from 25? Sure, with a remainder of 9. Put a “1” under the 16.

128
64
32
16
8
4
2
1

1
1
1
0
1

Can you subtract 8 from 9? Certainly, and that leaves one. We’ll put a “1” under the 8, and then a zero under both the 4 and 2, since we can’t subtract those from 1.

128
64
32
16
8
4
2
1

1
1
1
0
1
1
0
0

We have a remainder of 1. Subtract 1 from 1, and we’re done with our first conversion!

128
64
32
16
8
4
2
1

1
1
1
0
1
1
0
0
1

The decimal 217 converts to the binary string 11011001. That’s all there is to it – and this skill is the foundation of solving every binary and subnetting question you’ll see in this book and on your certification exams!
When it comes to full dotted decimal addresses, you just repeat the process four times, once for each octet.

128
64
32
16
8
4
2
1

1

2

3

4

Speed on these questions (and the others we’ll tackle in this book) comes with practice, so I’ve included extra practice questions for you. Best of all, you can write your own practice exam questions, wherever you are. Just write down the first decimal that pops into your head, and then convert it to binary (and hex, if you like). That’s a great way to get extra practice, and that few minutes you spend here and there really adds up on exam day!
Let’s hit some more practice questions, and then we’ll head to the next section, which contains another vital subnetting skill.
Convert the dotted decimal 100.10.1.200 to a binary string.

128
64
32
16
8
4
2
1

1
0
1
1
0
0
1
0
0

2
0
0
0
0
1
0
1
0

3
0
0
0
0
0
0
0
1

4
1
1
0
0
1
0
0
0

Convert 190.4.89.23 to a binary string.

128
64
32
16
8
4
2
1

1
1
0
1
1
1
1
1
0

2
0
0
0
0
0
1
0
0

3
0
1
0
1
1
0
0
1

4
0
0
0
1
0
1
1
1

Convert 10.255.18.244 to a binary string.

128
64
32
16
8
4
2
1

1
0
0
0
0
1
0
1
0

2
1
1
1
1
1
1
1
1

3
0
0
0
1
0
0
1
0

4
1
1
1
1
0
1
0
0

Convert 240.17.23.239 to a binary string.

128
64
32
16
8
4
2
1

1
1
1
1
1
0
0
0
0

2
0
0
0
1
0
0
0
1

3
0
0
0
1
0
1
1
1

4
1
1
1
0
1
1
1
1

Convert 217.34.32.214 to a binary string.

128
64
32
16
8
4
2
1

1
1
1
0
1
1
0
0
1

2
0
0
1
0
0
0
1
0

3
0
0
1
0
0
0
0
0

4
1
1
0
1
0
1
1
0

Convert 20.244.182.69 to a binary string.

128
64
32
16
8
4
2
1

1
0
0
0
1
0
1
0
0

2
1
1
1
1
0
1
0
0

3
1
0
1
1
0
1
1
0

4
0
1
0
0
0
1
0
1

Convert 145.17.206.89 to a binary string.

128
64
32
16
8
4
2
1

1
1
0
0
1
0
0
0
1

2
0
0
0
1
0
0
0
1

3
1
1
0
0
1
1
1
0

4
0
1
0
1
1
0
0
1

Convert 198.3.148.245 to a binary string.

128
64
32
16
8
4
2
1

1
1
1
0
0
0
1
1
0

2
0
0
0
0
0
0
1
1

3
1
0
0
1
0
1
0
0

4
1
1
1
1
0
1
0
1

Convert 14.204.71.250 to a binary string.

128
64
32
16
8
4
2
1

1
0
0
0
0
1
1
1
0

2
1
1
0
0
1
1
0
0

3
0
1
0
0
0
1
1
1

4
1
1
1
1
1
0
1
0

Convert 7.209.18.47 to a binary string.

128
64
32
16
8
4
2
1

1
0
0
0
0
0
1
1
1

2
1
1
0
1
0
0
0
1

3
0
0
0
1
0
0
1
0

4
0
0
1
0
1
1
1
1

Convert 184.61.80.9 to a binary string.

128
64
32
16
8
4
2
1

1
1
0
1
1
1
0
0
0

2
0
0
1
1
1
1
0
1

3
0
1
0
1
0
0
0
0

4
0
0
0
0
1
0
0
1

Convert 249.74.65.43 to a binary string.

128
64
32
16
8
4
2
1

1
1
1
1
1
1
0
0
1

2
0
1
0
0
1
0
1
0

3
0
1
0
0
0
0
0
1

4
0
0
1
0
1
0
1
1

Convert 150.50.5.55 to a binary string.

128
64
32
16
8
4
2
1

1
1
0
0
1
0
1
1
0

2
0
0
1
1
0
0
1
0

3
0
0
0
0
0
1
0
1

4
0
0
1
1
0
1
1
1

Convert 19.201.45.194 to a binary string.

128
64
32
16
8
4
2
1

1
0
0
0
1
0
0
1
1

2
1
1
0
0
1
0
0
1

3
0
0
1
0
1
1
0
1

4
1
1
0
0
0
0
1
0

Convert 43.251.199.207 to a binary string.

128
64
32
16
8
4
2
1

1
0
0
1
0
1
0
1
1

2
1
1
1
1
1
0
1
1

3
1
1
0
0
0
1
1
1

4
1
1
0
0
1
1
1
1

Convert 42.108.93.224 to a binary string.

128
64
32
16
8
4
2
1

1
0
0
1
0
1
0
1
0

2
0
1
1
0
1
1
0
0

3
0
1
0
1
1
1
0
1

4
1
1
1
0
0
0
0
0

Convert 180.9.34.238 to a binary string.

128
64
32
16
8
4
2
1

1
1
0
1
1
0
1
0
0

2
0
0
0
0
1
0
0
1

3
0
0
1
0
0
0
1
0

4
1
1
1
0
1
1
1
0

Convert 21.249.250.5 to a binary string.

128
64
32
16
8
4
2
1

1
0
0
0
1
0
1
0
1

2
1
1
1
1
1
0
0
1

3
1
1
1
1
1
0
1
0

4
0
0
0
0
0
1
0
1

Convert 243.79.68.30 to a binary string.

128
64
32
16
8
4
2
1

1
1
1
1
1
0
0
1
1

2
0
1
0
0
1
1
1
1

3
0
1
0
0
0
1
0
0

4
0
0
0
1
1
1
1
0

Great work!
Let’s move forward to the next fundamental subnetting success skill – converting binary strings to decimals.
Success Skill #2:Converting Binary Strings to Decimals
This one’s even simpler than the previous section – with solid practice, of course!
For this conversion, all we’re doing is plugging the binary string of 1s and 0s into the same grid we used in the first section. Add the columns with a 1, and you’re done. It’s that simple!
Let’s work with the binary string 01100010. Just plug that into our grid…

128
64
32
16
8
4
2
1

1
0
1
1
0
0
0
1
0

2

3

4

… add up the columns with a 1, and you’re done. The total is 98.
Let’s tackle a full 32-bit binary string: 01100010 00111100 11111100 01010101.

128
64
32
16
8
4
2
1

1
0
1
1
0
0
0
1
0

2
0
0
1
1
1
1
0
0

3
1
1
1
1
1
1
0
0

4
0
1
0
1
0
1
0
1

Add up each row and you have 98.60.252.85.
Speed on these questions increases with practice, so let’s get some serious practice in!
Convert 11110000 00110101 00110011 11111110 to dotted decimal.

128
64
32
16
8
4
2
1

1
1
1
1
1
0
0
0
0

2
0
0
1
1
0
1
0
1

3
0
0
1
1
0
0
1
1

4
1
1
1
1
1
1
1
0

Convert 00001111 01101111 00011100 00110001 to dotted decimal.

128
64
32
16
8
4
2
1

1
0
0
0
0
1
1
1
1

2
0
1
1
0
1
1
1
1

3
0
0
0
1
1
1
0
0

4
0
0
1
1
0
0
0
1

Convert 11100010 00000001 11001010 01110110 to dotted decimal.

128
64
32
16
8
4
2
1

1
1
1
1
0
0
0
1
0

2
0
0
0
0
0
0
0
1

3
1
1
0
0
1
0
1
0

4
0
1
1
1
0
1
1
0

Convert 01010101 11111101 11110010 00010101 to dotted decimal.

128
64
32
16
8
4
2
1

1
0
1
0
1
0
1
0
1

2
1
1
1
1
1
1
0
1

3
1
1
1
1
0
0
1
0

4
0
0
0
1
0
1
0
1

Convert 00000010 11111001 00110111 00111111 to dotted decimal.

128
64
32
16
8
4
2
1

1
0
0
0
0
0
0
1
0

2
1
1
1
1
1
0
0
1

3
0
0
1
1
0
1
1
1

4
0
0
1
1
1
1
1
1

Convert 11001001 01011111 01111111 11111110 to dotted decimal.

128
64
32
16
8
4
2
1

1
1
1
0
0
1
0
0
1

2
0
1
0
1
1
1
1
1

3
0
1
1
1
1
1
1
1

4
1
1
1
1
1
1
1
0

Convert 11111000 00000011 11111001 01100110 to dotted decimal.

128
64
32
16
8
4
2
1

1
1
1
1
1
1
0
0
0

2
0
0
0
0
0
0
1
1

3
1
1
1
1
1
0
0
1

4
0
1
1
0
0
1
1
0

Convert 00111110 11110000 01011010 01111110 to dotted decimal.

128
64
32
16
8
4
2
1

1
0
0
1
1
1
1
1
0

2
1
1
1
1
0
0
0
0

3
0
1
0
1
1
0
1
0

4
0
1
1
1
1
1
1
0

Convert 11001101 11110000 00001111 10111111 to dotted decimal.

128
64
32
16
8
4
2
1

1
1
1
0
0
1
1
0
1

2
1
1
1
1
0
0
0
0

3
0
0
0
0
1
1
1
1

4
1
0
1
1
1
1
1
1

Convert 10011001 11110000 01111111 00100101 to dotted decimal.

128
64
32
16
8
4
2
1

1
1
0
0
1
1
0
0
1

2
1
1
1
1
0
0
0
0

3
0
1
1
1
1
1
1
1

4
0
0
1
0
0
1
0
1

Convert 11011111 01110110 11000011 00111111 to dotted decimal.

128
64
32
16
8
4
2
1

1
1
1
0
1
1
1
1
1

2
0
1
1
1
0
1
1
0

3
1
1
0
0
0
0
1
1

4
0
0
1
1
1
1
1
1

Convert 00000100 00000111 00001111 00000001 to dotted decimal.

128
64
32
16
8
4
2
1

1
0
0
0
0
0
1
0
0

2
0
0
0
0
0
1
1
1

3
0
0
0
0
1
1
1
1

4
0
0
0
0
0
0
0
1

Convert 11100000 00000111 10001111 00000100 to dotted decimal.

128
64
32
16
8
4
2
1

1
1
1
1
0
0
0
0
0

2
0
0
0
0
0
1
1
1

3
1
0
0
0
1
1
1
1

4
0
0
0
0
0
1
0
0

Convert 11000000 00000011 11011011 00100101 to dotted decimal.

128
64
32
16
8
4
2
1

1
1
1
0
0
0
0
0
0

2
0
0
0
0
0
0
1
1

3
1
1
0
1
1
0
1
1

4
0
0
1
0
0
1
0
1

Convert 10000000 01111111 00110011 10000011 to dotted decimal.

128
64
32
16
8
4
2
1

1
1
0
0
0
0
0
0
0

2
0
1
1
1
1
1
1
1

3
0
0
1
1
0
0
1
1

4
1
0
0
0
0
0
1
1

Convert 11111011 11110111 11111100 11111000 to dotted decimal.

128
64
32
16
8
4
2
1

1
1
1
1
1
1
0
1
1

2
1
1
1
1
0
1
1
1

3
1
1
1
1
1
1
0
0

4
1
1
1
1
1
0
0
0

Great work! Let’s head to the next section, where we’re coming in after the subnetting’s been done – and we’re asked a very important question that we must be able to answer accurately!
Success Skill #3:Determining The Number Of Valid Subnets
The odd thing about this type of question is that we’re coming in after the subnetting’s actually been done, and we have to figure out how many valid subnets we have as a result of the subnetting.
Of course, it’s a good idea to figure this out BEFORE you do the subnetting. “Measure twice, cut once!” With this question type, Cisco’s figuring out if you really know what you’re doing – and after this section, you’ll be ready to answer any “valid subnets” question they ask you in a rapid and efficient manner.
We’ll work with these examples:
“How many valid subnets are there on the 10.0.0.0 /12 network?”
“How many valid subnets exist on the 10.0.0.0 255.240.0.0 network?
These two questions are actually asking you the same thing, just in different formats. The number/slash combination is prefix notation, and of these two it’s the most common method of expressing a subnet.
On your certification exams, you should be ready to work with the mask expressed in dotted decimal and prefix notation. To get you ready for that, I’ll use both formats throughout this book.
To solve “valid subnets” questions, you must have the network masks, ranges, and number of host and network bits in each one down cold. Here’s the info:

Class A
Class B
Class C

1st Octet Range
1 – 126
128-191
191-223

255.0.0.0 (/8)
255.255.0.0 (/16)
255.255.255.0 (/24)

# Network Bits
8
16
24

# Host Bits
24
16
8

We don’t get to say “never” often in networking, and here’s one of those rare opportunities: The number of network bits never changes. Subnetting always borrows from the host bits – always!
All we need to do is determine the number of subnet bits. With a great deal of solid practice, you’ll be able to answer this question type in seconds, in an efficient and accurate manner.
Once you know the number of subnet bits, just plug that value into this simple formula:
Number of Valid Subnets = 2 to the nth power, with n=number of subnet bits.
Don’t let the “nth power” thing intimidate you – it’s easy, you’ll see!
To get the number of subnet bits, just compare the subnet mask with the network mask. The subnet bits are where the subnet mask has a “1” and the network mask has a “0”.
I’m going to write out the full masks in this example, but once you see that the subnet mask and network mask have zeroes in the same place, you can stop writing them out.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
00000000
00000000
00000000

11111111
11110000
00000000
00000000

The subnet bits are bolded, and since we have four of them, that means that 2 to the 4th power is our number of subnets. 2 × 2 × 2 × 2 = 16. And that’s it!
I’m showing you this method so you can see exactly what’s going on, bit by bit. There is a faster way to determine the number of subnet bits, and there’s no trick to it. Just subtract the number of network bits from the mask, and you have your number of subnet bits.
For example, in the previous walkthrough we worked with a Class A network. We know that has a network mask of /8. The subnet mask we were given was /12, so just subtract 8 from 12 and you have your number of subnet bits … 4 of them. Then just calculate 2 to the 4th power and you’re done!
For each of the following practice questions, I’ll show you how to get the answer both ways. Be sure to use the first method until you’re totally comfortable with it, and then feel free to use the second method.
I’m also going to list the networks first, without the answers, and the answers follow. Let’s get started!
Determine the number of valid subnets in each of the following networks:
15.0.0.0 /13
222.10.1.0 /30
145.45.0.0 / 25
20.0.0.0 255.192.0.0
130.30.0.0 255.255.224.0
128.10.0.0 /19
99.0.0.0 /17
222.10.8.0 /28
30.0.0.0 255.254.0.0
210.17.90.0 /29
130.45.0.0 /26
190.1.1.0 /26
45.0.0.0 255.240.0.0
222.33.44.0 255.255.255.248
23.0.0.0 255.255.224.0
111.11.0.0 /15
130.45.0.0 /19
99.0.0.0 /16
34.0.0.0 /18
200.10.56.0 /29
128.10.0.0 /18
15.0.0.0 /13
Method 1: Compare the NW and SN masks to determine the number of subnet bits, then bring 2 to the power of that number.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
00000000
00000000
00000000

11111111
11111000
00000000
00000000

5 subnet bits = 2 to the 5th power = 32.
Method 2: Class A network, /8 mask, subtract 8 from 13, that gives us 5. 2 to the 5th power = 32.
222.10.1.0 /30
Method 1: Compare the NW and SN masks to determine number of subnet bits.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
11111111
00000000

11111111
11111111
11111111
11111100

We have six subnet bits, and 2 to the 6th power is 64.
Method 2: Class C network, NW mask of /24, subtract 24 from 30, that gives us 6. 2 to the 6th power is 64.
145.45.0.0 /25
Method 1: Compare the NW and SN masks to determine the number of subnet bits, then bring 2 to the power of that number.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
00000000
00000000

11111111
11111111
11111111
10000000

We have 9 subnet bits. 2 to the 9th power is 512.
Method 2: Class B network, mask of /16, subtract 16 from 25, gives us 9. 2 to the 9th power is 512.
20.0.0.0 255.192.0.0
Method 1: Compare the NW and SN masks, calculate number of subnet bits, bring 2 to the power of that number.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
00000000
00000000
00000000

11111111
11000000
00000000
00000000

We have two subnet bits, and 2 to the 2nd power is 4.
Method 2: Class A network, NW mask of /8, subtract 8 from 10, result is 2. 2 to the 2nd power is 4.
130.30.0.0 255.255.224.0
Method 1: Compare the NW and SN masks to calculate the number of subnet bits, then bring 2 to that power.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
00000000
00000000

11111111
11111111
11100000
00000000

We have three subnet bits, and 2 to the third power is 8.
Method 2: Class B network, NW mask of /16, subtract 16 from 19, result is 3. 2 to the 3rd power is 8.
128.10.0.0 /19
Method 1: You know the drill.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
00000000
00000000

11111111
11111111
11100000
00000000

We have three subnet bits, and 2 to the 3rd power is 8.
Method 2: Class B network, NW mask /16, subtract 16 from 19, result is 3. 2 to the 3rd power is 8.
99.0.0.0 /17
Method 1: Compare, calculate, subtract, succeed.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
00000000
00000000
00000000

11111111
11111111
10000000
00000000

We have nine subnet bits, and 2 to the 9th power is 512.
Method 2: Class A network, NW mask /8, subtract 8 from 17, result is 9. 2 to the 9th power is 512.
222.10.8.0 /28
Method 1: Compare, calculate, subtract, succeed!

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
11111111
00000000

11111111
11111111
11111111
11110000

We have 4 subnet bits, and 2 to the 4th power is 16.
Method 2: Class C network, NW mask /24, subtract 24 from 28, result is 4. Two to the 4th power is 16.
30.0.0.0 255.254.0.0
Method 1: Figure out how many subnet bits we have…..

Octet 1
Octet 2
Octet 3
Octet 4

11111111
00000000
00000000
00000000

11111111
11111110
00000000
00000000

We have 7 subnet bits, and 2 to the 7th power is 128.
Method 2: Class A network, mask /8, 15 − 8 = 7, 2 to the 7th power = 128.
210.17.90.0 /29
Method 1: Calculate the number of subnet bits, and bring 2 to that power.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
11111111
00000000

11111111
11111111
11111111
11111000

We have 5 subnet bits, and 2 to the 5th power is 32.
Method 2: Class C network, 24 NW bits, 29 − 24 = 5, 2 to the 5th power = 32.
130.45.0.0 /26
Method 1: You know the drill!

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
00000000
00000000

11111111
11111111
11111111
11000000

We have 10 subnet bits, and 2 to the 10th power is 1024.
Method 2: Class B network, 16 NW bits, 26 − 16 = 10, 2 to the tenth power = 1024.
200.1.1.0 /26
Method 1: 2 to the power of the number of subnet bits:

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
11111111
00000000

11111111
11111111
11111111
11000000

We have 2 subnet bits, and 2 to the 2nd power equals 4.
Method 2: Class C network, 24-bit mask, 26 − 24 = 2, 2 to the 2nd power = 4.
45.0.0.0 255.240.0.0
Method 1: Break both masks down to binary, then compare, calculate, succeed!

Octet 1
Octet 2
Octet 3
Octet 4

11111111
00000000
00000000
00000000

11111111
11110000
00000000
00000000

We have four subnet bits, and 2 to the 4th power equals 16.
Method 2: Class A network, 8-bit mask, 12 − 8 = 4, 2 to the 4th power = 16.
222.33.44.0 255.255.255.248
Method 1: Break it down, calculate it, subtract it, nail it!

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
11111111
00000000

11111111
11111111
11111111
11111000

We have five subnet bits, and 2 to the 5th power is 32.
Method 2: Class C network, 24-bit mask, 29 − 24 = 5, 2 to the 5th power = 32.
111.11.0.0 /15
Method 1: Calculate it and nail it!

Octet 1
Octet 2
Octet 3
Octet 4

11111111
00000000
00000000
00000000

11111111
11111110
00000000
00000000

We have 7 subnet bits, and 2 to the 7th power equals 128.
Method 2: Class A, 8-bit mask, 15 − 8 = 7, 2 to the 7th power = 128.
130.45.0.0 /19
Method 1: Calculate the number of subnet bits, and then power 2 by that value.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
00000000
00000000

11111111
11111111
11100000
00000000

We have three subnet bits, and 2 to the third power is 8.
Method 2: Class B, 16-bit mask, 19 − 16 = 3, 2 to the third power = 8.
99.0.0.0 /16

Octet 1
Octet 2
Octet 3
Octet 4

11111111
00000000
00000000
00000000

11111111
11111111
00000000
00000000

We have 8 subnet bits, and 2 to the 8th power is 256.
Method 2: Class A network, 8-bit mask, 16 − 8 = 8, 2 to the 8th power = 256.
34.0.0.0 /18
Method 1: Write out the masks and identify the subnet bits.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
00000000
00000000
00000000

11111111
11111111
11000000
00000000

We have 10 subnet bits, and 2 to the 10th power = 1024.
Method 2: Class A with 8-bit NW mask, 18 − 8 = 10, 2 to the 10th power = 1024.
200.10.56.0 /29
Method 1:

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
11111111
00000000

11111111
11111111
11111111
11111000

We have 5 subnet bits, and 2 to the 5th power = 32.
Method 2: Class C with 24-bit mask, 29 − 24 = 5, 2 to the 5th power = 32.
128.10.0.0 /18
Method 1:

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
00000000
00000000

11111111
11111111
11000000
00000000

We have 2 subnet bits, and 2 to the 2nd power = 4.
Method 2: Class B with 16-bit mask, 18 − 16 = 2, 2 to the 2nd power = 4.
All riiiiiiiiight!
With this skill mastered, let’s figure out how many hosts we have on each of these subnets – coming up next!
Success Skill #4:Determining The Number Of Valid Host Addresses On Our Subnets
The method for determining the number of valid hosts on a subnet is similar to the method for determining the number of overall valid subnets. Similar, but not identical!
We’re going to compare the network and subnet masks again, but this time we’re identifying the host bits, and those are where the NW mask and SN mask both have zeroes. We’ll bring two to the power of the number of host bits.
THEN – and this merits all caps for just a word or two – THEN we’re going to subtract two from the result. That’s to compensate for two unusable addresses in each subnet:
Let’s tackle a “valid hosts” question and you’ll see what I mean!
How many valid hosts are there on the 150.10.0.0 /23 subnet?

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
00000000
00000000

11111111
11111111
11111110
00000000

The bits where each mask has a zero are the host bits, and we have nine of those. 2 to the 9th power is 512. Subtract two from that and you have 510 valid hosts on each of the subnets.
Now that you see exactly what’s going on with this operation, let me show you a really quick way of calculating the number of valid hosts.
Just subtract the number of 1s in the subnet mask from 32, and you have the number of host bits. Take 2 to the power of that number, subtract 2, and you’re done.
In the previous example, we had a mask of /23. You can just subtract that 23 from 32, which gives you nine… and 2 to the 9th power is 512. Subtract 2 and you have 510, and you’re done in well under a minute.
Practice makes perfect, so let’s dive right into some serious practice. I’ll break each question down into the NW and SN masks so you can get a bit-by-bit picture of what’s going on, and in the exam room you should feel more than free to use the second method.
I’ll give you the full list of subnets first, and they’re listed again with the answers after the first list. Let’s hit it!
Determine the number of valid host addresses on each of these subnets:
220.11.10.0 /26
129.15.0.0 /21
50.0.0.0 /20
222.22.2.0 /30
212.10.3.0 /28
221.10.78.0 255.255.255.224
143.34.0.0 255.255.255.192
128.12.0.0 255.255.255.240
125.0.0.0 /24
221.10.89.0 255.255.255.248
134.45.0.0 /22
220.11.10.0 /26
Method 1: Identify the host bits, bring 2 to that power, subtract 2.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
11111111
00000000

11111111
11111111
11111111
11000000

We have six host bits, and 2 to the 6th power is 64. Subtract 2 and you have 62 valid hosts in this subnet.
Method 2: 32 − 26 = 6, 2 to the 6th power = 64, 64 − 2 = 62.
129.15.0.0 /21
Method 1: Get the host bits number and bring 2 to that power, then subtract 2.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
00000000
00000000

11111111
11111111
11111000
00000000

We have 11 host bits. 2 to the 11th power equals 2048. 2048 − 2 = 2046.
Method 2: 32 − 21 = 11, 2 to the 11th power = 2048, 2048 − 2 = 2046.
50.0.0.0 /20

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
00000000
00000000

11111111
11111111
11110000
00000000

We have 12 host bits. 2 to the 12th power = 4096, and 4096 − 2 – 4094.
Method 2: 32 − 20 = 12, 2 to the 12th power = 4096, 4096 − 2 = 4094.
(It’s unlikely your exams will make you go to the 11th or 12th power of 2, but it certainly doesn’t hurt to prepare for it.)
222.22.2.0 /30
Method 1:

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
11111111
00000000

11111111
11111111
11111111
11111100

We have two host bits. 2 to the 2nd power is 4; subtract 2 and we have 2 valid host addresses!
Method 2: 32 − 30 = 2, 2 to the 2nd power = 4, 4 − 2 = 2.
212.10.3.0 /28
Method 1:

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
11111111
00000000

11111111
11111111
11111111
11110000

We have four host bits. 2 to the 4th power = 16; subtract 2 and we have 14 valid host addresses.
Method 2: 32 − 28 = 4, 2 to the 4th power = 16, 16 − 2 = 14.
221.10.78.0 255.255.255.224
Method 1:

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
11111111
00000000

11111111
11111111
11111111
11100000

We have five host bits. 2 to the 5th power = 32; subtract 2 and we have 30 valid hosts.
Method 2: 32 − 27 = 5, 2 to the 5th power = 32, 32 − 2 = 30 valid hosts.
143.34.0.0 255.255.255.192
Method 1:

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
00000000
00000000

11111111
11111111
11111111
11000000

We have six host bits, and 2 to the 6th power = 64. Subtract 2 and you have 62 valid host addresses.
Method 2: 32 − 26 = 6, 2 to the 6th power = 64, 64 − 2 = 62.
128.12.0.0 255.255.255.240
Method 1:

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
00000000
00000000

11111111
11111111
11111111
11110000

We have 4 host bits. 2 to the 4th power = 16, and 16 − 2 = 14 valid addresses!
Method 2: 32 − 28 = 4, 2 to the 4th power = 16, 16 − 2 = 14.
125.0.0.0 /24
Method 1:

Octet 1
Octet 2
Octet 3
Octet 4

11111111
00000000
00000000
00000000

11111111
11111111
11111111
00000000

We have 8 host bits, and 2 to the 8th power is 256. Subtract two from that and we have 254 valid host addresses.
Method 2: 32 − 24 = 8, 2 to the 8th power = 256, 256 − 2 = 254.
221.10.89.0 255.255.255.248
Method 1:

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
11111111
00000000

11111111
11111111
11111111
11111000

We have three host bits, and 2 to the 3rd power equals 8. Subtract 2 and you have 6 valid host addresses.
Method 2: 32 − 29 = 3, 2 to the 3rd power = 8, 8 − 2 = 6.
134.45.0.0 /22
Method 1:

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
00000000
00000000

11111111
11111111
11111100
00000000

We have 10 host bits, and 2 to the 10th power is 1024. Subtract 2 and we have 1022 valid host addresses!
Method 2: 32 − 22 = 10, 2 to the 10th power = 1024, 1024 − 2 = 1022.
And that’s it! We’ll now take the skills we’ve perfected in the first four sections and apply them to questions that some certification candidates don’t know how to approach or solve – but you will!
Let’s go!
Success Skill #5:Determining The Subnet Of A Given IP Address
Of all the skills you’re going to learn in this book, the one we’re about to concentrate on is the one you’ll use most in the real world. Quite a few troubleshooting scenarios arise in production networks when a host is thought to be on one subnet and it’s actually on another. In turn, that can lead to some serious communications issues.
I’m going to share a lightning-fast way for you to determine the exact subnet that you’ll find a given IP address on – and this skill will serve you VERY well on your certification exams!
Let’s say you’re given the IP address 100.17.48.200 /23, and you’re asked to give the subnet upon which that address resides.
All you have to do is break the address down into binary, and from left to right convert thebits in the subnet mask back to decimal. You’re done!
Here’s what I mean:
100.17.49.200 = 01100100 00010001 00110001 11001000
Then convert the first 23 bits back to binary.
01100100 00010001 0011000x xxxxxxxx = 100.17.48.0 /23
That’s all there is to it! Even better, you don’t even have to convert the entire address if you don’t want to (it is good practice, though). Just convert the number of bits represented by the subnet mask and add ‘em up!
Let’s do another one here and then we’ll hit the practice exam questions.
On what subnet can the 10.17.2.14 255.255.192.0 address be found?
This question has a dotted decimal mask, but that’s no problem for us. That mask converts to /18 in prefix notation.
To determine the subnet containing this address, we just need to convert the address to binary and then convert the first 18 bits back to binary.
10.17.2.14 = 00001010 00010001 00xxxxxx xxxxxxxx
Add up those numbers and you have 10.16.0.0 /18. That’s it!
Let’s get to the practice exam questions and get ready to smack this exam in the mouth. I’ll list the addresses first, and then again with the answers, which follow at the end of this section.
Identify the subnet where you’ll find each of these IP addresses.
210.17.23.200 /27
24.194.34.12 /10
190.17.69.175 /22
111.11.126.5 255.255.128.0
210.12.23.45 255.255.255.248
222.22.11.199 / 28
111.9.100.7 /17
122.240.19.23 /10
184.25.245.89 /20
210.67.39.5 / 30
99.140.23.143
10.191.1.1 /10
187.23.191.95 /27
222.17.32.244 /28
210.17.23.200 /27
Convert the address to binary and add up the first 27 bits.
210.17.23.200 = 11010010 00010001 00010111 110xxxxx
24.194.34.12 /10
Convert the address to binary and add up the first 10 bits.
24.194.34.12 = 00011000 11xxxxxx xxxxxxxx xxxxxxxx
Add up the first 10 bits and you have 24.192.0.0 /10.
190.17.69.175 /22
Convert that address to binary and add up the first 22 bits!
190.17.69.175 = 10111110 00010001 010001xx xxxxxxxx
Add up those first 22 bits and you have 190.17.68.0 /22. That’s your subnet!
111.11.126.5 255.255.128.0
Convert to binary and add up the first 17 bits, as that mask converts to /17.
111.11.126.5 = 01101111 00001011 0xxxxxxx xxxxxxxx
Add up those 17 bits and you have 111.11.0.0 255.255.128.0, also expressed as 111.11.0.0 /17.
210.12.23.45 255.255.255.248
Convert to binary, add up the first 29 bits, and you’re done.
210.12.23.40 = 11010010 00001100 00010111 00101xxx
Add up the first 29 bits and you have 210.12.23.40 255.255.255.248, also expressed as 210.12.23.40 /29.
222.22.11.199 / 28
Convert to binary, add up the first 28 bits, and you’re done!
222.22.11.199 = 11011110 00010110 00001011 11000111
The subnet is 222.22.11.192 /28, also expressed as 222.22.11.192 255.255.255.240.
111.9.100.7 /17
Convert the address to binary, convert the first 17 bits back to decimal, and you’re done.
111.9.100.7 = 01101111 00001001 0xxxxxxx xxxxxxxx
The first 17 bits add up to 111.9.0.0, with a /17 mask (255.255.128.0).
122.240.19.23 /10
Convert the address, add up the first 10 bits, and you’re done!
122.240.19.23 = 01111010 11xxxxxx xxxxxxxx xxxxxxxx
The first 10 bits add up to 122.192.0.0, with a /10 mask (255.192.0.0).
184.25.245.89 /20
184.25.245.89 = 10111000 00011001 1111xxxx xxxxxxxx
Add the first 20 bits and you have 184.25.240.0, mask /20 (255.255.240.0).
210.67.39.5 / 30
210.67.39.5 = 11010010 01000011 00100111 000001xx
Add the first 30 bits and you have 210.67.39.4 /30 (255.255.255.252).
99.140.23.143 /10
Convert the address and add the first 10 bits to get the subnet.
99.140.23.143 = 01100011 10xxxxxx xxxxxxxx xxxxxxxx
Add the first 10 bits and you have 99.128.0.0 /10.
10.191.1.1 /10
Convert the address and add the first 10 bits to get the subnet.
10.191.1.1 = 00001010 10xxxxxx xxxxxxxx xxxxxxxx
Add the first 10 bits and you have 10.128.0.0 /10.
187.23.191.95 /27
Convert it, add the first 27 bits, you have the subnet!
187.23.191.95 = 10111011 00010111 10111111 010xxxxx
Add the first 27 bits and you have 187.23.191.64 /27 (255.255.255.224).
222.17.32.244 /28
222.17.32.244 = 11011110 00010001 00100000 1111xxxx
The first 28 bits add up to 222.17.32.240 /28 (255.255.255.240).
Let’s head to the next section, where you’ll learn how to slay two subnetting dragons with one stone!
Success Skills 6 & 7:Determining The Broadcast Address Of A SubnetDetermining The Range Of Valid IP Addresses Of A Subnet
I know you enjoyed that last section and seeing how easily you can find the subnet any IP address is a part of, and you’ll enjoy this section twice as much!
I’m saying that with confidence, because I’m going to show you exactly how to solve two different questions with one simple, quick operation.
The questions:
What’s the valid host address range for this subnet?
Answering those two questions is a vital skill to have in networking, as well as your exam prep, so let’s get right to it!
We know we have two unusable addresses per subnet:
The subnet number itself (the “All-Zeroes” address)
Not sure why we call those the “all-zeroes” and “all-ones” addresses? No worries, I’m about to clear that up for you.
When you need to determine the range of valid IP addresses for a subnet, or for the broadcast address of a subnet, you’re going to perform the exact same operation, and it’s a familiar one – convert the address to binary and identify the host bits.
To pull this off even faster, you don’t have to write out the entire IP address you’re converting. If you want to, that’s fine, but the only octets that need to be written out are the octet where the subnet mask goes from 1s to 0s AND any following octets.
That will be much clearer after we walk through an example and you solve the practice questions in this section.
Let’s work with the 150.10.64.0 /18 network. That mask ends in the 3rd octet, so we only have to write that one out and the one that follows it. Since the subnet mask covers the first and second octet completely, those values will stay the same and there’s no need to convert them.
Convert those two octets to binary and then identify the host bits. With that mask, we know the last 14 bits are the host bits, which are bolded.

150
10
01000000
00000000

150
10

That address is the subnet number, and it’s called the “all-zeroes” address because the host bits are all set to zeroes. That’s the first address we can’t assign to hosts.
To determine the broadcast address, just change every host bit to a 1. You can quickly just erase those zeroes on your board in the exam room and change them to ones.

150
10
01000000
00000000

150
10
01111111
11111111

Our subnet address is 150.10.64.0, and the broadcast address is 150.10.127.255. Every address between those two are your valid addresses, and in this case it’s the range 150.10.64.1 – 150.10.127.254. That’s all there is to it!
With your solid foundation of binary conversion skills, you’ll easily and rapidly solve this question type. Let’s get in some practice right now, and for each subnet given, we’ll determine both the broadcast address and the range of valid host addresses.
I’ll list the subnets first, followed by the answers. Let’s go!
The subnets:
222.23.48.64 /26
140.10.10.0 /23
10.200.0.0 /17
198.27.35.128 /27
132.12.224.0 /27
211.18.39.16 /28
10.1.2.20 /30
10.10.128.0 255.255.192.0
221.18.248.224 /28
222.23.48.64 /26
The mask goes from 1s to 0s in the 4th octet, so we only have to work with that octet, since we know 222.23.48 will remain the same. (If you’re more comfortable writing the entire mask out, that’s fine!)
Convert the 4th octet to binary. For the broadcast address, change the six host bits in that octet to 1. Everything between those two addresses is a valid IP address for this subnet!

222
10
48
01000000

222
10
48
01111111

Range of valid addresses: 222.23.48.65 – 222.23.48.126 /26
140.10.10.0 /23
That mask goes from 1s to 0s in the 3rd octet, so we only need to convert that one and the one that follows it. We know that 140 and 10 will remain the same.
To get the broadcast address, change the 9 host bits to 1. Everything between these two addresses is a valid IP host address.

140
10
00001010
00000000

140
10
00001010
00000000

Range of valid addresses: 140.10.10.1 – 140.10.11.254 /23
10.200.0.0 /17
The mask goes from 1s to 0s in the third octet, so we only have to convert the last two octets. 10 and 200 will remain the same. To get the broadcast address, change the 15 host bits to 1s.

10
200
00000000
00000000

10
200
01111111
11111111

Range of valid addresses: 10.200.0.1 – 10.200.127.254 /17.
198.27.35.128 /27
The mask goes from 1s to 0s in the 4th octet, so that’s the only octet we need to convert. 198, 27, and 35 will remain the same. To get the broadcast address, change the five host bits to 1s.

198
27
35
10000000

198
27
35
10011111

Range of valid addresses: 198.27.35.129 – 198.27.35.158 /27.
132.12.224.0 /27
The mask goes from 1s to 0s in the 4th octet, so that’s the only octet we need to convert. To get the broadcast address, change the five host bits to 1s.

132
12
224
00000000

132
12
224
00011111

Range of valid addresses = 132.12.224.1 – 132.12.224.30 /27.
211.18.39.16 /28
The mask goes from 1s to 0s in the 4th octet, so we’ll just convert that octet. 211, 18, and 39 remain the same. For the broadcast address, change the four host bits to ones.

211
18
39
00010000

211
18
39
00011111

Range of valid addresses = 211.18.39.17 – 211.18.39.30 /28.
10.1.2.20 /30
The mask goes from 1s to 0s in the 4th octet, making that octet the only one we need to convert. For the broadcast address, change the two host bits to ones and you’re done!

10
1
2
00010100

10
1
2
00010111

The two addresses between those two, 10.1.2.21 /30 and 10.1.2.22 /30, are the sole valid IP addresses on that subnet.
10.10.128.0 255.255.192.0
The mask transitions from ones to zeroes in the third octet, so we only have to convert the third and fourth octets. To determine the broadcast address, change the 14 host bits to ones.

10
10
10000000
00000000

10
10
10111111
11111111

Range of valid addresses: 10.10.128.1 – 10.10.191.254 255.255.192.0
221.18.248.224 /28
The mask transitions from zeroes to ones in the 4th octet, so that’s the only one we have to convert. For the broadcast network, change the four host bits to ones.

221
18
248
11100000

221
18
248
11101111

Range of valid addresses: 221.18.248.225 – 221.18.248.238 /28
Let’s head to the next section and do some real-world subnetting!
Success Skill #8:Subnetting!
Hey, we finally get to do some subnetting on our own instead of answering questions about someone else’s subnetting!
A typical question:
Using 150.50.0.0, you must design a subnetting scheme that allows for at least 200 subnets, but no more than 150 hosts per subnet. What subnet mask is the best choice for these requirements?
We have to watch a few things…

Watch “minimum” vs. “maximum”. The number of subnets is a “minimum” in this question, and the number of hosts is a “maximum”. Some questions will have two minimums, others may have two maximums.
If you’re given choices for such a question, you could be asked to give the mask in either dotted decimal or prefix notation, which is no problem for you.
If you’re given choices, watch masks that meet one requirement but not the other, because both requirements have to be met by the mask you choose.

We also need to be able to immediately identify the network class and remember how to calculate the number of valid host addresses and subnets, and that’s no problem for you. All the work you’ve done in previous sections will now pay off big time.
We know this is a Class B network, and those networks have a 255.255.0.0 network mask. We have 16 bits we can borrow for subnetting.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111

Subnet Bits

Host Bits

00000000
00000000

Quickly reviewing the formulas for our number of subnets and number of hosts:
No. of valid subnets = (2 to the power of subnet bits)
No. of valid hosts = (2 to the power of host bits) − 2
To get more than 200 subnets, we need to borrow at least 8 host bits, so we’ll start there. 2 to the 8th power = 256 valid subnets, and that would leave 8 host bits.
Proposed Solution: 255.255.255.0

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111

Subnet Bits

11111111

Host Bits

00000000

That meets one requirement, but what about the other? With 8 host bits remaining, we have 254 valid hosts (2 to the 8th power, then subtract 2). That’s too many hosts.
To reduce the number of hosts, we’ll borrow one more subnet bit.
Proposed Solution: 255.255.255.128

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111

Subnet Bits

11111111
1

Host Bits

0000000

With 9 subnet bits, we have 512 valid subnets.
With 7 host bits, we have 126 valid hosts. Both requirements are met!
Subnetting is easy with the fundamental skills you’ve perfected in this book. You just have to be careful and meet all the requirements you’re given, not just one!
Let’s hit another example.
Using network 220.10.10.0, develop a subnetting scheme that allows for at least 25 subnets, but no subnet should have more than four hosts.
We have a Class C network here, so we only have eight host bits to borrow for subnetting.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
11111111

Subnet Bits

Host Bits

00000000

The first number of subnet bits that gives us at least 25 subnets is five, so let’s start with that. We’d have three host bits left:

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
11111111

Subnet Bits

11111

Host Bits

000

5 subnet bits = 2 to the 5th power = 32 valid subnets
3 host bits = 2 to the 3rd power – 2 = 6 valid hosts per subnet
That’s too many hosts. We’ll need another subnet bit, which gives us ….
6 subnet bits = 64 valid subnets
2 host bits = 2 to the 2nd power – 2 = 2 valid host addresses
Done and done! The mask we need is 255.255.252.0, or /30.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
11111111

Subnet Bits

111111

Host Bits

00

Let’s get some more practice in …
Using the network 140.10.0.0, come up with a mask that allows for at least 250 subnets and allows at least 250 valid host addresses per subnet.
With a Class B network, we have 16 network bits and 16 host bits, and only the latter can be borrowed for subnetting.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111

Subnet Bits

Host Bits

00000000
00000000

The first number of subnet bits that gives us at least 250 subnets is eight, so we’ll start there.
8 subnet bits = 256 valid subnets
8 host bits = 254 valid hosts per subnet
That meets both requirements, so the mask is 255.255.255.0 (/24).

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111

Subnet Bits

11111111

Host Bits

00000000

Given the network number 200.10.10.0, what mask will allow at least 15 subnets, and will allow no more than six hosts per subnet?
It’s a Class C network, so we have only eight host bits to borrow for subnetting.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
11111111

Subnet Bits

Host Bits

00000000

The first number of subnet bits that gives us at least 15 subnets is four, so we’ll start there.
4 subnet bits = 16 valid subnets
4 host bits = 16 − 2 = 14 valid hosts per subnet, too many for the requirement.
To reduce the number of valid hosts, we’ll borrow another subnet bit.
5 subnet bits = 32 valid subnets
3 host bits = 8 − 2 = 6 valid hosts per subnet.
That mask of 255.255.255.248 (/29) works!

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
11111111

Subnet Bits

11111

Host Bits

000

Given the network number 134.100.0.0, what mask will allow at least 500 subnets while limiting the subnets to no more than 120 hosts per subnet?
With this Class B network, we have 16 network bits, and 16 host bits just waiting for us to subnet!

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111

Subnet Bits

Host Bits

00000000
00000000

The first number that gives us 500+ subnets is 9, so let’s start there.
9 subnet bits = 512 valid subnets
7 host bits = 128 − 2 = 126 valid hosts, too many for these requirements.
To bring the number of hosts down, we’ll borrow one more subnet bit.
10 subnet bits = 1024 valid subnets
6 subnet bits = 64 − 2 = 62 valid hosts
The mask of /26 works for us! (255.255.255.192)

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111

Subnet Bits

11111111
11

Host Bits

000000

Using the network 202.10.40.0, what mask gives us at least 10 subnets but will allow no more than 10 hosts on a subnet?
This Class C network gives us 8 host bits to borrow from.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
11111111

Subnet Bits

Host Bits

00000000

The first number of subnet bits that gives us at least 10 subnets is four. Let’s start there!
4 subnet bits = 16 valid subnets
4 host bits = 16 − 2 = 14 valid hosts, too many for these requirements. Let’s borrow one more subnet bit to lower the number of hosts.
5 subnet bits = 32 valid subnets
3 host bits = 8 − 2 = 6 valid hosts
That’ll do it! The resulting mask is /29, or 255.255.255.248.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
11111111

Subnet Bits

11111

Host Bits

000

Given the network 157.200.0.0, come up with a mask that will allow no more than 150 valid subnets and will allow at least 200 hosts per subnet.
This Class B network gives us 16 host bits to borrow from:

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111

Subnet Bits

Host Bits

00000000
00000000

The lowest number of subnet bits that gives us no more than 150 subnets is 7, so we’ll start there.
7 subnet bits = 128 valid subnets
9 host bits = 512 − 2 = 510 valid host addresses
That works! The resulting mask is 255.255.254.0, or /23.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111

Subnet Bits

1111111

Host Bits

0
00000000

Given the network 130.245.0.0, what subnet mask will give us between 60 and 70 subnets while allowing at least than 250 valid hosts per subnet?
Class B, you know the drill!

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111

Subnet Bits

Host Bits

00000000
00000000

The only number that gives us 60 – 70 valid subnets is six, so that better do the job!
6 subnet bits = 64 valid subnets
10 host bits = 1024 − 2 = 1022 valid hosts per subnet
That’s it! Our mask is 255.255.248.0, or /22.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111

Subnet Bits

111111

Host Bits

00
00000000

Let’s head to the Final Exam section and review all of our binary and subnetting topics!
Here are some additional practice exam questions to strengthen your binary and subnetting skills, and get you ready for exam-room and real-world success! Let’s jump right in – and if you have trouble with any of these questions, just head back in the book and review that section. Practice does indeed make perfect!
Converting Binary to Dotted Decimal
Convert 01010101 11100010 01101010 01001010 to dotted decimal.

128
64
32
16
8
4
2
1

1
0
1
0
1
0
1
0
1

2
1
1
1
0
0
0
1
0

3
0
1
1
0
1
0
1
0

4
0
1
0
0
1
0
1
0

Convert 11110000 00001111 01111111 1000000 to dotted decimal.

128
64
32
16
8
4
2
1

1
1
1
1
1
0
0
0
0

2
0
0
0
0
1
1
1
1

3
0
1
1
1
1
1
1
1

4
1
0
0
0
0
0
0
0

Convert 11001101 00000011 11110010 00100101 to dotted decimal.

128
64
32
16
8
4
2
1

1
1
1
0
0
1
1
0
1

2
0
0
0
0
0
0
1
1

3
1
1
1
1
0
0
1
0

4
0
0
1
0
0
1
0
1

Convert 00110010 00100011 11110011 00100111 to dotted decimal.

128
64
32
16
8
4
2
1

1
0
0
1
1
0
0
1
0

2
0
0
1
0
0
0
1
1

3
1
1
1
1
0
0
1
1

4
0
0
1
0
0
1
1
1

Convert 10000111 00111111 01011111 00110010 to dotted decimal.

128
64
32
16
8
4
2
1

1
1
0
0
0
0
1
1
1

2
0
0
1
1
1
1
1
1

3
0
1
0
1
1
1
1
1

4
0
0
1
1
0
0
1
0

Converting Decimal to Binary
Convert 195.29.37.126 to a binary string.

128
64
32
16
8
4
2
1

1
1
1
0
0
0
0
1
1

2
0
0
0
1
1
1
0
1

3
0
0
1
0
0
1
0
1

4
0
1
1
1
1
1
1
0

Convert 207.93.49.189 to a binary string.

128
64
32
16
8
4
2
1

1
1
1
0
0
1
1
1
1

2
0
1
0
1
1
1
0
1

3
0
0
1
1
0
0
0
1

4
1
0
1
1
1
1
0
1

Convert 21.200.80.245 to a binary string.

128
64
32
16
8
4
2
1

1
0
0
0
1
0
1
0
1

2
1
1
0
0
1
0
0
0

3
0
1
0
1
0
0
0
0

4
1
1
1
1
0
1
0
1

Convert 105.83.219.91 to a binary string.

128
64
32
16
8
4
2
1

1
0
1
1
0
1
0
0
1

2
0
1
0
1
0
0
1
1

3
1
1
0
1
1
0
1
1

4
0
1
0
1
1
0
1
1

Convert 123.54.217.4 to a binary string.

128
64
32
16
8
4
2
1

1
0
1
1
1
1
0
1
1

2
0
0
1
1
0
1
1
0

3
1
1
0
1
1
0
0
1

4
0
0
0
0
0
1
0
0

Determining The Number Of Valid Subnets:
How many valid subnets on the 222.12.240.0 /27 network?
Method 1: Compare the NW and SN masks, calculate the number of subnet bits, then bring 2 to the power of that number.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
11111111
00000000

11111111
11111111
11111111
11100000

We have three subnet bits, and 2 to the 3rd power is 8.
Method 2: Class C network, with a NW mask of /24, 27 − 24 = 3, 2 to the 3rd power = 8.
How many valid subnets on the 15.1.0.0 /17 network?
Method 1: Compare the masks, identify number of subnet bits, bring 2 to the power of the number of subnet bits.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
00000000
00000000
00000000

11111111
11111111
10000000
00000000

We have 9 subnet bits, and 2 to the 9th power = 512.
Method 2: Class A network, /8 mask, 17 − 8 = 9, 2 to the 9th power = 512.
How many valid subnets on the 111.0.0.0 /14 network?
Method 1: Compare the NW and SN masks, calculate number of subnet bits, and bring 2 to the power of that number.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
00000000
00000000
00000000

11111111
11111100
00000000
00000000

We have six subnet bits, and 2 to the 6th power is 64.
Method 2: Class A network, /8 NW mask, 14 − 8 = 6, 2 to the 6th power = 64.
How many valid subnets on the 172.12.0.0 /19 network?
Method 1: Compare the NW and SN masks of this Class B network and identify the number of subnet bits. Bring 2 to that power and you’re done.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
00000000
00000000

11111111
11111111
11100000
00000000

We have three subnet bits, and 2 to the 3rd power = 8.
Method 2: Class B network, /16 mask, 19 − 16 = 3, 2 to the 3rd power = 8.
How many valid subnets on the 221.23.19.0 /30 network?
Method 1: Compare the NW and SN masks, calculate the number of subnet bits, and power 2 by that value.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
11111111
00000000

11111111
11111111
11111111
11111100

We have six subnet bits, and 2 to the 6th power is 64.
Method 2: Class C network, /24 NW mask, 30 − 24 = 6, 2 to the 6th power = 64.
How many valid subnets on the 17.0.0.0 255.240.0.0 network?
Method 1: Compare the NW and SN masks to get the number of subnet bits, then power 2 by that number.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
00000000
00000000
00000000

11111111
11110000
00000000
00000000

We have four subnet bits, and 2 to the 4th power = 16.
Method 2: Class A network, /8 NW mask, 12 − 8 = 4, 2 to the 4th power = 16.
(255.240.0.0 = /12)
How many valid subnets on the 210.12.200.0 255.255.255.248 network?
Method 1: You know the drill by now!

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
11111111
00000000

11111111
11111111
11111111
11111000

We have five subnet bits, and 2 to the 5th power = 32.
Method 2: Class C network, /24 NW mask, 29 − 24 = 5, 2 to the 5th power = 32.
How many valid subnets on the 155.200.0.0 255.255.255.128 network?
Method 1: Here we go!

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
00000000
00000000

11111111
11111111
11111111
10000000

We have nine subnet bits, and 2 to the 9th power = 512.
Method 2: Class B network, NW mask /16, 25 − 16 = 9, 2 to the 9th power = 512.
Determining The Number Of Valid Hosts
How many valid host addresses on the 211.254.12.0 /27 subnet?
Method 1: Identify the number of host bits, bring 2 to that power, subtract 2.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
11111111
00000000

11111111
11111111
11111111
11100000

We have five host bits. 2 to the 5th power is 32; subtract two and you have 30 valid hosts per subnet.
Method 2: 32 − 27 = 5, 2 to the 5th power is 32, 32 − 2 = 30 valid hosts per subnet.
How many valid addresses on the 178.34.0.0 /28 subnet?
Method 1: Identify the number of host bits by comparing the masks, bring 2 to that power, and subtract 2.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
00000000
00000000

11111111
11111111
11111111
11110000

We have four host bits, and 2 to the 4th power is 16. Subtract 2 to account for the all-zeroes and all-ones addresses on that subnet, and you’re all set with 14 valid host addresses.
Method 2: 32 − 28 = 4, 2 to the 4th power = 16, 16 − 2 = 14 valid hosts.
How many valid host addresses on the 211.12.45.0 /30 subnet?
Method 1: Compare the SN and NW masks, calculate the number of host bits, and bring 2 to that power. Subtract 2 from the result.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
11111111
00000000

11111111
11111111
11111111
11111100

2 to the 2nd power equals 4, and we subtract 2 to arrive at two valid host addresses.
Method 2: 32 − 30 = 2, 2 to the 2nd power = 4, 4 − 2 = 2.
How many valid host addresses on the 210.34.34.0 255.255.255.248 subnet?
Method 1: Compare the NW and SN masks, calculate the number of host bits, and bring 2 to that power. Subtract 2 from the result. Done!

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
11111111
00000000

11111111
11111111
11111111
11111000

We have 3 host bits, and 2 to the 3rd power = 8. Subtract 2 and you have 6 valid host addresses.
Method 2: 32 − 29 = 3. 2 to the 3rd power = 8. 8 − 2 = 6 valid host addresses.
How many valid host addresses on the 145.100.0.0 255.255.254.0 subnet?
Method 1: Compare the NW and SN masks, determine the number of host bits, and power 2 to that value. Then subtract 2 and you’re done!

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
00000000
00000000

11111111
11111111
11111110
00000000

We have nine host bits, and 2 to the 9th power equals 512. Subtract those two nasty addresses and you have 510 valid host addresses!
Method 2: 32 − 23 = 9. 2 to the 9th power = 512. 512 − 2 = 510.
Determining The Subnet Number Of A Given IP Address
On what subnet can the IP address 142.12.38.189 /25 be found?
To get the subnet, convert the address to binary, and add up the first 25 bits. It’s all yours!
Subnet = 10001110 00001100 00100110 1xxxxxxx = 142.12.38.128 /25.
On what subnet can the IP address 170.17.209.36 /19 be found?
Convert the address to binary and add up the first 19 bits.
Subnet = 10101010 00010001 110xxxxx xxxxxxxx = 170.17.192.0 /19.
On what subnet can the IP address 10.178.39.205 /29 be found?
Convert the address to binary, add up the first 29 bits, and you have it!
Subnet = 00001010 10110010 00100111 11001xxx = 10.178.39.200 /29.
On what subnet can the IP address 190.34.9.173 /22 be found?
Convert the address to binary, add up the first 22 bits, and you’re done.
Subnet = 10111110 00100010 000010xx xxxxxxxx = 190.34.8.0 /22.
On what subnet can the IP address 203.23.189.205 255.255.255.240 be found?
Convert the address to binary, add up the first 28 bits, and you’re done!
Subnet = 11001011 00010111 10111101 1100xxxx = 203.23.189.192 255.255.255.240.
On what subnet can the IP address 109.89.45.204 255.255.224.0 be found?
Convert the address to binary, add up the first 19 bits, and you’re done!
Subnet = 01101101 01011001 001xxxxx xxxxxxxx = 109.89.32.0 255.255.224.0.
On what subnet can the IP address 31.189.234.245 /17 be found?
Convert the address to binary, add up the first 17 bits, and you’re gold.
Subnet = 00011111 10111101 1xxxxxxx xxxxxxxx = 31.189.128.0 /17.
On what subnet can the IP address 100.10.13.176 /21 be found?
Convert to binary, add up the first 21 bits, and you’re done!
Subnet = 01100100 00001010 00001xxx xxxxxxxx = 100.10.8.0 /21.
On what subnet can the IP address 190.98.35.17 /27 be found?
Convert to binary, add up the first 27 bits, and you’re done.
Subnet = 10111110 01100010 00100011 000xxxxx = 190.98.35.0 /27.
The subnet is 100.100.45.32 /28.
The mask goes from 1s to 0s in the 4th octet, so that’s the only one we really have to write in binary. The first three octets will remain the same.

100
100
45
00100000

100
100
45
00101111

Valid addresses: 100.100.45.33 – 100.100.45.46 /28.
The subnet is 208.72.109.8 /29.
The mask ends in the 4th octet, so again we only have to write out the last octet. The first three will remain the same.

208
72
109
00001000

208
72
109
00001111

Valid addresses: 208.72.109.9 – 208.72.109.14 / 29
The subnet is 190.89.192.0 255.255.240.0.
The mask ends in the third octet, so we only have to write out the last two octets.

190
89
11000000
00000000

190
89
11001111
11111111

Range of valid addresses: 190.89.192.1 – 190.89.207.254 255.255.240.0.
The subnet is 101.45.210.52 /30.
The mask ends in the 4th octet, so that’s the only one we have to write out in binary.

101
45
210
00110100

101
45
210
11111111

Valid addresses: 101.45.210.53 and 101.45.210.54 /30.
The subnet is 90.34.128.0 /18.
The mask ends in the 3rd octet, so those are the only two we need to write in binary.

90
34
10000000
00000000

90
34
10111111
11111111

Range of valid addresses: 90.34.128.1 – 90.34.191.254 /18.
The subnet is 205.186.34.64 /27.
The mask ends in the 4th octet, so that’s the only one we have to write in binary.

205
186
34
01000000

205
186
34
01011111

Range of valid addresses: 205.186.34.65 – 205.186.34.94 /27.
The subnet is 175.24.36.0 255.255.252.0.
The mask ends in the 3rd octet, so we’ll write that one and the 4th octet in binary.

175
24
00100100
00000000

175
24
00100111
11111111

Range of valid addresses: 175.24.36.1 – 175.24.39.254 /22.
The subnet: 10.10.44.0 /25.
The mask ends in the 4th octet, so that’s the only one that you need to write out in binary.

10
10
44
00000000

10
10
44
01111111

Range of valid addresses: 10.10.44.1 – 10.10.44.126 /25.
The subnet: 120.20.240.0 /21.
The mask ends in the 3rd octet, so we’ll write that one in binary as well as the octet that follows it.

120
20
11110000
00000000

120
20
11110111
11111111

Range of valid addresses: 120.20.240.1 - 120.20.247.254 /21.
Meeting Requirements
Using the network number 135.13.0.0, determine the best network mask to use when you want at least 500 subnets, and each subnet should contain as many hosts as possible while not exceeding 100 hosts.
We have a Class B network, so there are 16 network bits and then 16 host bits we can borrow subnet bits from.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111

Subnet Bits

Host Bits

00000000
00000000

What’s the largest number of host bits we can have without exceeding 100 hosts? Six of them, which results in 62 valid host addresses. To get to that point, we’d need to borrow 10 subnet bits, which gives us 1024 valid subnets, which meets the other requirement.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111

Subnet Bits

11111111
11

Host Bits

000000

The resulting mask: 255.255.255.192, or /26.
Working with the network number 223.12.23.0, you need to determine the mask that will give you at least 30 valid hosts per subnet, while still giving you the maximum number of subnets. What’s the best mask to use?
We’re starting with a Class C network, which means we have only eight host bits to borrow for subnetting.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111
11111111

Subnet Bits

Host Bits

00000000

This question’s a little different from the others, since we’re asked to come up with a minimum number of valid hosts per subnet while still maximizing the number of subnets. What’s the least number of host bits we can have that will allow at least 30 valid hosts?
Five host bits will give us exactly 30 valid host addresses. We could borrow another bit to give us more host addresses, but we were asked to have as many subnets as possible while meeting the host address requirement. If we keep five host bits, we’re borrowing 3 subnet bits, resulting in a mask of 255.255.255.224, or /27.

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111

Subnet Bits

111

Host Bits

00000

Using the network number 131.10.0.0, come up with a subnet mask that will give us at least 50 subnets, while ensuring that no single subnet can contain over 1000 host addresses.
We have a Class B network, so we know the drill by now…

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111

Subnet Bits

Host Bits

00000000
00000000

The lowest number of subnet bits that give us 50 subnets is 6, so we’ll start there.
That gives us 64 subnets, and leaves 10 host bits, which results in 1022 valid host addresses per subnet. We’ve met one requirement, but not the other. To get the number of valid hosts per subnet below 1000, we have to borrow one more subnet bit.
7 subnet bits = 128 valid subnets
9 host bits = 510 valid host addresses

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111

Subnet Bits

1111111

Host Bits

0
00000000

The resulting mask is 255.255.254.0, or /23.

Given the network number 47.0.0.0, come up with the subnet mask that gives us at least 625 subnets while giving us the maximum number of host addresses per subnet.
Straightforward enough! We have a Class A network, so we have plenty of host bits to borrow for subnetting – 24 of them, in fact!

Octet 1
Octet 2
Octet 3
Octet 4

11111111

Subnet Bits

Host Bits

00000000
00000000
00000000

To meet the “maximum number of host addresses” requirement, we need to borrow as few bits as possible while still ending up with 625 subnets.
The lowest number of subnet bits that will give us that many subnets is 10, which results in 1024 valid subnets. (Nine subnet bits would give us 512 subnets, not enough to meet the requirement.)

Octet 1
Octet 2
Octet 3
Octet 4

11111111
11111111

Subnet Bits

11111111
11

Host Bits

000000

The resulting mask is /26, or 255.255.255.192.

Whew! That was a lot of binary and subnetting – and you got the job done!

Chris Bryant
“The Computer Certification Bulldog”