Binary: Combinations and Conversion

Understanding how the “combination tables” of “numeral systems” work gives you a big advantage. You need them to learn to write any number anywhere, at the right moment, and to convert any value you want with a few simple calculations (for example, to or from binary).

It may not be the proudest achievement in the world, but I promise that after reading this article you will be able to understand programmer jokes like this one:

I’d bet you’ve seen this joke in one of its hundreds of variants all over the Internet. You’ve probably heard it in class, at work, or from a tech-loving friend. You may even have missed it because you didn’t get it, but from now on you have to get it 😉

I’m going to reveal the trick behind the joke, and show you that converting from binary to decimal in your head is very simple and very fast. Mentally, start at 1 and keep doubling the amount toward the left as many times as the number you want to convert from binary to decimal has bits. For the hand example above, doubling once is enough (we only have two bits, representing the two raised fingers: “11”).

For the example I’m going to overdo it (two steps for the two bits would be enough, the rest are extra), doubling the previous number (x2) several times from right to left. You could also do it the other way around (left to right), but it’s usual to calculate binary from right to left (One thing: ignore the “MSB” acronym for now, I’ll explain it in a few lines; and you can skip the little red numbers for now, I’ll explain those in the note below):

Below the numbers we just calculated (…, 64, 32, 16, 8, 4, 2, 1), we write the bits of the binary number starting from the smallest number toward the biggest (for the binary number “11” from the fingers before, we write the first 1 under the 1, and the next 1 under the 2). We fill in the rest with zeros. Like in the following image:

And now we just have to calculate the decimal value. We cross out all the powers of 2 that have a “0” under them and add up the ones that have a “1”:

I overdid it here; “2+1” would have been enough. But I wanted to give you a complete example with “zeros” and “zero padding”.

As you can see, getting the programmer joke is an instant calculation (it took me longer to explain it than to do the math in my head).

And you can believe me when I say that all of binary calculation is this simple; we’re not going to do anything “special” or “extra”. But we will learn to deal with very large binary numbers, above all to know what they mean and why things work the way they do.

Let’s start with the easiest one: combination tables in decimal (the rest of the tables are just as simple; you only have to understand the logic and, as we said, everything works the same way).

Decimal (base 10)

As we know, the decimal numeral system has only 10 symbols (base 10, made up of combinations of the ten symbols we are more than used to: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9). If we put all the existing decimal symbols in a table, we get the following:

If we want to represent larger numbers we have to add more digits (a digit, also called a “figure”, is each symbol in a number). For example:

• The number 7 has 1 digit
• The number 45 has 2 digits
• The number 897 has 3 digits
• The number 1,589 has 4 digits
• The number 18,897 has 5 digits

By convention, any number (regardless of base) that has “zeros” on the left doesn’t get them written, that is, the number “000000097” is the same as “97”. And if the number has a fractional part, the zeros on the right are not written; for example, “000000097,150000” is the same as “97,15”.

It may not seem so, but leading zeros are written in many places you’ve surely seen, especially where there are fixed slots for the numbers. For example: a digital clock (you’ll see the time as “07:09”), or the dates in an operating system (we can see them as “03/07/2017”), even lottery tickets (which we can see as “0 0 5 7 6”), also flight tickets (for example “IBE 0467”), among hundreds of other examples. Since in the tables we will always say how many digits the numbers have, the slots are always fixed, so we will always fill all the positions of the number with zeros on the left. Besides, when working in binary there will always be fixed-size memory positions (that is, any file on your computer will always take up a multiple of some number of bits depending on where the bits are, whether in the processor, the hard drive, RAM, etc. For example, if the hard drive stores in groups of 8 bits, then a file will always take up a multiple of 8 bits, which is 1 Byte as we saw in the article about units of information; so it makes no difference whether a file takes up 75 bits, since memory will always reserve a multiple of 8 and it will always say 80 bits are used. And if the file grows to 81 bits? Then it will take up 88 bits), and that is another reason to put zeros in the part that doesn’t change the value, to fill it in.

That’s all well and good, but if we want to write the table with all the combinations of all the decimal numbers that have two digits, it’s not enough to draw from “ten” (10) to “ninety-nine” (99); we also need “zero” (0) to “nine” (9), since their first digit is a “zero” that isn’t normally written (for example, the symbol “5” represented with two decimal digits is written “05”). The table would be the following:

Another important thing -for any number in any numeral system we want- is to know the order in which to read the symbols of numbers with several digits. If I write “12” and ask you what decimal number it is, you’ll surely say “twelve”, but if I ask someone who reads them backwards they’ll say “twenty-one”. So it’s important to know which digit is the:

• Most significant digit: the digit with the highest value.
• Least significant digit: the digit with the lowest value.

For example, if we want to read the number “2.017” we know that the “Most significant digit” (in the image I’ve represented it as “D+R”) is at the far left, where the “thousands” are, and the “Least significant digit” (represented in the next image as “D-R”) is on the opposite side, at the far right, which will be the units. This way we can read “2.017” as “Two thousand seventeen” (and not the other way around as “Seven thousand one hundred two”).

It’s enough to know where the “Most significant digit” is located to deduce where the “Least significant digit” is (if one is at the start of the number, the other will be at the end; and vice versa). So usually only the “most significant” one is mentioned, and the “least significant” is deduced.

Luckily, and by convention, for decimal numbers the “Most significant digit” is always the leftmost digit. Understanding this is important for any numeral system (especially for binary, where it can vary whether you read from left to right or from right to left).

Taking the previous four-digit example “2.017”, knowing that the “Most significant digit” is the leftmost digit, if I ask you:

• Which digit is the thousands? You can already tell me it’s where the “Most significant digit” is, the far-left digit, the first digit starting from the left
• Which digit is the hundreds? The second digit starting from the left
• Which digit is the tens? The third digit starting from the left
• Which digit is the units? The fourth digit starting from the left

Units, hundreds, tens, thousands, etc. This means I can multiply each digit of the number “2.017” by the power of the base, in this case a power of 10 (a power of “ten” because decimal is base “ten”), with the “Most significant digit” located at the highest power of 10 (and the “Least significant digit” at the lowest power of 10, “raised to zero”):

• Thousands: 2 x 10³ = 2 x 1.000 = 2.000
• Hundreds: 0 x 10² = 0 x 100 = 0
• Tens: 1 x 10¹ = 1 x 10 = 10
• Units: 7 x 10⁰ = 7 x 1 = 7

Funny enough, if I add up all the results I get the number “2.017”:

2.000 + 0 + 10 + 7 = 2.017

Knowing which is the “most significant digit” comes in handy for establishing the multiples that will later help us with conversion between numeral systems (especially from any numeral system to decimal).

The complete table of the decimal numeral system for four digits would be (it’s simple, it has three things that repeat in all the tables; take a look and we’ll continue):

Comparative conversion example

And we finish with a complete example to “convert” the decimal number “3908” to the same decimal system (nothing is really converted here, but when we move on to the next base you’ll understand why we do this “conversion to itself”):

1. The decimal number to convert to decimal: 3908
2. For each column, its decimal multiplier: (3 x 10³) + (9 x 10²) + (0 x 10¹) + (8 x 10⁰)
3. Each power is: (3 x 1.000) + (9 x 100) + (0 x 10) + (8 x 1)
4. We calculate the parentheses: 3.000 + 900 + 0 + 8
5. We add up: 3908
6. Conversion: (3908)₁₀ = (3908)₁₀

Binary (base 2)

At last we get to the good stuff, the “binary tables”, now that we understand the previous “decimal tables”.

As we said, the numbers in a binary system have only two symbols (since it’s base 2): one (1) and zero (0).

Since in computing we don’t work with “numbers” but with bits, each symbol of a binary number is not called a “digit” (nor a “figure”) but a “bit”, so in binary we say (it’s the same thing with a different name):

• Most significant bit (MSB): the bit with the highest value (equivalent to the “Most significant digit”, the “D+R”).
• Least significant bit (LSB): the bit with the lowest value (equivalent to the “Least significant digit”, the “D-R”).

Drawing the table with a single bit would be very simple:

Since it only has “0” and “1”, it only has two rows. We said it’s a single-bit table, so it only has one column. And remember that the decimal multiplier is the power (it’s the base of the numeral system we’re dealing with). In this case binary is base 2, so the power is 2.

The simplest table with two bits would be:

So the table for four bits would be:

Now we have the tables, so let’s see how to convert a binary number to decimal.

It’s important to understand well the relationship between the columns of the binary tables and their decimal multipliers (understand the logic so you can use it at any time), since with them we’ll be able to quickly convert any binary number to decimal in our heads. We’ll review the powers of two in a second:

• 2⁰ = 1
• 2¹ = 2
• 2² = 4
• 2⁴ = 8
• …
• 2ⁿ

So, for any number of columns we can know its value both as a power and directly as a decimal number in our heads, in a matter of seconds:

If you look at the first example, the programmer joke at the beginning of the article, this is how we calculate the decimal multipliers of the columns.

By the way, I’m calling them “decimal multipliers” because they let us convert any number of the table (of the base) we’re using to decimal, just by adding.

Converting binary to decimal

Now, if I ask you how much the binary number “1011” is in decimal? Easy, similar to how we did the previous “decimal to decimal” conversion (it’s above, in the section called “Comparative conversion example”). “1011” has four bits (four digits), and since we want to write it in decimal, the “ones” and “zeros” will be decimal, so we can calculate it step by step:

1. The binary number to convert to decimal: 1011
2. For each column, its decimal multiplier: (1 x 2³) + (0 x 2²) + (1 x 2¹) + (1 x 2⁰)
3. Each power is: (1 x 8) + (0 x 4) + (1 x 2) + (1 x 1)
4. We calculate the parentheses: 8 + 2 + 1
5. We add up: 11
6. Conversion: (1101)₂ = (11)₁₀

Very easy and extremely simple. The binary “1011” is 11 in decimal. Now you know how to calculate from binary to decimal.

Converting decimal to binary

And to convert a decimal number to binary, for example the decimal number “53”? You could say it’s the same as before, but in reverse: we need to find the largest column multiplier that, when subtracted from the decimal number, gives a positive result or zero (if it’s zero, we’re done), and then it will be a binary “1”; however, if it gives a negative result, it will be a binary “0”. Let’s see the steps of the example (I’m going to elaborate a bit in the following explanation, but it’s quite simple: you just keep subtracting the column multiplier from the positive result):

1. The decimal number to convert to binary: 53
2. We look for the first largest multiplier that, when subtracted from 53, stays positive. For example, 128 (= 2⁷) will be a binary “0” since subtracting it gives a negative number (53 – 128 = -75); the same happens with 64 (= 2⁶), which gives a negative (53 – 64 = -11) and will also be a binary “0”.
3. The first column, the largest one that gives a binary “1”, is 32 (= 2⁵), which corresponds to the sixth column (C6): 53 – 32 = 21, the positive result, so it’s a 1 Since we used 32 = 2⁵ (see the previous image of the columns) we know it belongs to the sixth column (C6), and from here we continue with the rest of the columns downward.
4. 16 (= 2⁴) from C5: 21 – 16 = 5, positive result so it’s a binary 1, for the sixth column (C6)
5. 8 (= 2³) from C4: 5 – 8 = -3, negative result so it’s a binary 0 (the negative result isn’t carried over to the next lower multiplier; the previous positive result is reused)
6. 4 (= 2²) from C3: 5 – 4 = 1, positive result so it’s a binary 1
7. 2 (= 2¹) from C2: 1 – 2 = -1, negative result so it’s a binary 0
8. 1 (= 2⁰) from C1: 1 – 1 = 0, zero result so it’s a binary 1 and we’re done
9. We collect the binary 1s and 0s in column order (starting from the MSB): 110101
10. So: (110101)₂ = (53)₁₀

There are other ways to convert binary to decimal. I think this one is the simplest and the fastest to do in your head.

Hexadecimal (base 16)

Hexadecimal is base 16, and therefore this numeral system has sixteen symbols: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.

Working with binary is great, but it’s not convenient to “carry around”. It’s an ugly number with so many “ones” and “zeros”, and very long too. Remember when I told you in the previous article about numeral systems that the binary number “01101010” could represent other things, like the color “Dark Blue” (see the previous note: “Note about the possible representations of a binary number”)? And it’s dark blue in the RGB color model.

Look at the image below and answer this question: which number is easier and faster to memorize/carry around/write, the binary or the hexadecimal?

And likewise, if we remove the “useless” zeros on the left we’d have: “(1101010)₂ = (6A)₁₆”. Using hexadecimal is much shorter than binary. This trick to shorten the binary number (really, the trick is converting the number to a higher base to compress very large numbers of lower bases) is used a lot with bases that are powers of 2. It’s not unusual to find bit sequences written in bases like quaternary (base 4), octal (base 8), hexadecimal (base 16), base 32, base 64, etc. in all sorts of places (Internet, books, etc.). In any base except binary (base 2).

The hexadecimal number (base 16) has 16 symbols. 0 to 9 were chosen, and for the rest, the letters “A” to “F”. The table of all the existing hexadecimal symbols:

This table is quite a bit bigger; if you look closely, it follows the same principles as the previous bases: it’s easy to create.

Here’s the four-digit table for hexadecimal, quickly:

Converting hexadecimal to decimal

The conversion from hexadecimal to decimal is the same as from binary. For example, to convert the hexadecimal number “7C0A” to decimal:

1. The hexadecimal number to convert to decimal: 7C0A
2. For each column, its decimal multiplier: (7 x 16³) + (C x 16²) + (0 x 16¹) + (A x 16⁰)
3. We replace each hexadecimal symbol (the letters) with decimals: (7 x 16³) + (12 x 16²) + (0 x 16¹) + (10 x 16⁰)
4. Each power is: (7 x 4.096) + (12 x 256) + (0 x 16) + (10 x 1)
5. We calculate the parentheses: 28.672 + 3.072 + 0 + 10
6. We add up: 31.754
7. Conversion: (7C0A)₁₆ = (31.754)₁₀

Converting hexadecimal to binary

We can see the comparison of hexadecimal with decimal and binary in the following table:

What matters most is that the hexadecimal table repeats exactly when the 4-bit binary one ends (because 16 is a power of 2, specifically 2⁴ = 16; any base that’s a power of 2 will repeat and will be very good for instantly converting each symbol to its binary). With it, it’s easy to convert each hexadecimal symbol to a group of 4 bits directly from the table (I remove the decimal so as not to confuse things, since decimal doesn’t coincide with the end of the hexadecimal table and can’t be used to convert the hexadecimal symbol to decimal):

Converting from hexadecimal to binary is very simple. It’s enough to convert each hexadecimal letter to binary separately. For example, to convert the hexadecimal number “7C0A” to binary:

1. The hexadecimal number to convert to binary: 7C0A
2. Replace each hexadecimal symbol with its binary: 0111 1100 0000 1010
3. Conversion: (7C0A)₁₆ = (0111110000001010)₂

Converting binary to hexadecimal

And the other way around, converting from binary to hexadecimal is the same as before. Each group of four bits is a hexadecimal symbol. For example, to convert the binary number “0111110000001010” to hexadecimal:

1. The binary number to convert to hexadecimal: 0111110000001010
2. Split into groups of four bits: 0111 1100 0000 1010
3. Replace each group with its hexadecimal symbol: 7C0A
4. Conversion: (0111110000001010)₂ = (7C0A)₁₆

Converting hexadecimal to any numeral system

Once we have the value in binary, we can convert the value to decimal (as we saw before) or to any base we want.

To finish, I’ll mention that hexadecimal is used for a ton of things (besides colors and letters, as we said), always for the purpose of shortening the representation of lower bases. For:

• IP addresses (the ones you use to connect a computer to the Internet), especially for the new IPv6 protocol, which supports 2¹²⁸ different addresses. For example, an IPv6 address could be (it’s already long in hexadecimal, imagine in binary): “2001:0DB8:AC10:FE01:2541:FE18:12AE:F81B”
• MAC addresses (the physical address of the network card of any of your devices; the “network card” is what unequivocally identifies your computer so it can be connected, for example, to a router, so it has Internet). For example: “48:6D:43:C2:3C:FE”
• In product serial numbers. It depends on the manufacturer, but sometimes you can see hexadecimal on product boxes instead of decimal (like on the boxes of televisions, microwaves, or smartphones). Also when buying software (the number it normally asks for during installation, to make sure it’s genuine).
• Programming with assembly code (“assembly code” is used to program the processor of your computer or smartphone; for example, telling the processor to add two numbers that are in two separate memory positions and place the result in another memory position). For example, an assembly instruction could be: “C010 B6 80 04”

Octal (base 8)

Although all the tables are the same by now, I didn’t want to finish without showing you the octal ones (base 8, which has 8 symbols: 0, 1, 2, 3, 4, 5, 6, 7), since grouping binary into octal is also very common (8 is a power of 2, specifically: 2³=8). It’s not as widely used as hexadecimal, but it’s also important. And it’s calculated exactly the same way as the other tables (learn one and you know them all).

Here’s the basic one-digit table, quickly:

And any other one, for example the four-digit one:

I’m also giving you, for free, the comparison of the four numeral systems we’ve seen (binary, octal, hexadecimal and decimal). So you can see that octal also coincides before moving on to the next round number (by “round number” I mean the one after the last one that ends the count with the symbols of a numeral system; that is, the one that ends in “zero”. For decimal the round numbers would be 10, 20, 30,… , 80, 90, 100, etc. For binary: 10, 100, 110, 1000, 1100, 1110, etc. For hexadecimal: 10, 20, 30,… , D0, F0, 100, etc. And for octal: 10, 20, 30,… , 60, 70, 100, etc.), exactly where the tables for binary and hexadecimal also end (as we said, the coincidence isn’t by chance; they coincide because they’re powers of 2; decimal isn’t a power of 2, it’s a power of 10, and it would coincide with other numeral systems that are powers of 10).

Converting octal to decimal

The conversion from octal to decimal is the same as the previous ones. For example, to convert the octal number “6017” to decimal:

1. The octal number to convert to decimal: 6017
2. For each column, its decimal multiplier: (6 x 8³) + (0 x 8²) + (1 x 8¹) + (7 x 8⁰)
3. Each power is: (6 x 512) + (0 x 64) + (1 x 8) + (7 x 1)
4. We calculate the parentheses: 3.072 + 0 + 8 + 7
5. We add up: 3.087
6. Conversion: (6017)₈ = (3.087)₁₀

Converting octal to binary

Just as simple as hexadecimal, to convert from octal to binary and vice versa:

Converting from octal to binary. Convert each octal letter to binary separately. For example, convert the octal number “6701” to binary:

1. The octal number to convert to binary: 6701
2. Replace each hexadecimal symbol with its binary: 110 111 000 001
3. Conversion: (6701)₈ = (110111000001)₂

Converting binary to octal

And the other way around, converting from binary to octal. Each group of three bits is an octal symbol. For example, to convert the binary number “110111000001” to hexadecimal:

1. The binary number to convert to octal: 110111000001
2. Split into groups of three bits: 110 111 000 001
3. Replace each group with its hexadecimal symbol: 6701
4. Conversion: (110111000001)₂ = (6701)₈

Converting octal to any numeral system

And just like hexadecimal, from the value in binary we can convert the value to decimal (as we saw before) or to any base we want.

Attributions

• RGB color model image by Ninja404 obtained from Wikipedia: https://upload.wikimedia.org/wikipedia/commons/c/c2/AdditiveColor.svg
• 1968 ASCII code chart image by LWChris obtained from Wikipedia: https://upload.wikimedia.org/wikipedia/commons/archive/8/82/20140820143049%21US-ASCII_code_chart.png

References