Some binary numbers come up often enough in computing that it’s worth knowing their conversions by heart — round numbers like 256, and other common values that show up in file sizes, network settings, and programming examples.
Why 256 Is Everywhere
256 into binary is 100000000 — a 1 followed by eight 0s. It shows up constantly because 256 equals 2 to the 8th power, which is exactly the number of values a single byte can represent (0 through 255, or 256 total possibilities). Anywhere a system is limited by “one byte,” the number 256 tends to appear as the boundary.
Converting 35 to Binary
Using the subtract-the-largest-power-of-two method: 32 fits into 35 (mark 1, remainder 3), 16 and 8 and 4 don’t fit into 3 (mark 0 three times), 2 doesn’t fit either (mark 0), and 1 fits (mark 1, remainder 0). The result is 100011.
Converting 12 to Binary
8 fits into 12 (mark 1, remainder 4), 4 fits into the remainder (mark 1, remainder 0), and 2 and 1 don’t fit (mark 0 twice). The result is 1100.
Reading a Few Binary Numbers Back to Decimal
The number 11011 in binary breaks down as 16+8+0+2+1, giving 27 in decimal. The number 1110 breaks down as 8+4+2+0, giving 14. Working through both directions on the same handful of numbers is a good way to confirm you’re applying the place-value method consistently.
Where These Round Numbers Come From
Numbers like 8, 16, 32, 64, 128, and 256 keep showing up because they’re all powers of two, which makes them natural boundaries in a system built entirely on binary — the maximum value a certain number of bits can hold, the size of a memory block, or a common buffer size in software all tend to land on one of these numbers rather than an arbitrary one.
Common Powers of Two Worth Memorizing
Beyond 256, a handful of other powers of two come up often enough to be worth memorizing outright: 2, 4, 8, 16, 32, 64, and 128, each one double the last. Recognizing these instantly makes both directions of conversion noticeably faster, since a large chunk of everyday binary numbers are built from combinations of just these few values.
Binary Numbers From 0 to 15
These sixteen values appear everywhere because four bits (half a byte) can hold exactly this range. Each one also maps to a single hexadecimal digit.
- 0 = 0000 (0 in hex)
- 1 = 0001 (1 in hex)
- 2 = 0010 (2 in hex)
- 3 = 0011 (3 in hex)
- 4 = 0100 (4 in hex)
- 5 = 0101 (5 in hex)
- 6 = 0110 (6 in hex)
- 7 = 0111 (7 in hex)
- 8 = 1000 (8 in hex)
- 9 = 1001 (9 in hex)
- 10 = 1010 (A in hex)
- 11 = 1011 (B in hex)
- 12 = 1100 (C in hex)
- 13 = 1101 (D in hex)
- 14 = 1110 (E in hex)
- 15 = 1111 (F in hex)
Powers of Two in Binary
Each power of two is a 1 followed by zeros: 1 = 1, 2 = 10, 4 = 100, 8 = 1000, 16 = 10000, 32 = 100000, 64 = 1000000, 128 = 10000000, 256 = 100000000, 512 = 1000000000, 1024 = 10000000000. Spotting that pattern makes conversion easier.
Other Common Values
- 255 is 11111111, eight 1s, the largest value in one byte. It appears in IP addresses and color codes.
- 100 is 1100100.
- 65 is 01000001, the ASCII code for the letter “A”.
- 1,000 is 1111101000.
- 1,023 is 1111111111, ten 1s, one less than 1,024.
Where You Will See These Numbers
IP addresses use four numbers from 0 to 255, each stored in one byte. Web colors use three values from 0 to 255 for red, green and blue. Memory and storage sizes follow powers of two. For the unit side of this, see bytes, KB, MB and GB explained.
A Trick for Doubling
Adding a zero to the end of a binary number doubles it, just as adding a zero to a decimal number multiplies it by ten. For example, 11 (3) becomes 110 (6), and 110 becomes 1100 (12). The same idea powers the shift operations described in binary multiplication and division.
Practice More Conversions
Our binary translator checks binary-to-text conversions, and our guide on binary to decimal practice has additional worked examples if you want more to try.