Hexadecimal and octal representation: Visual walkthrough

Step 1 — What a "bit" even is, and why we line them up in a row

WHAT. A bit is one thing that can only be in two states. Picture a light bulb: it is either off (we call that $0$ ) or on (we call that $1$ ). Nothing in between. That is the whole idea of binary — base $2$ means "two possible digit values, $0$ and $1$ ."

WHY. Computers are made of switches, and a switch is naturally a two-state thing. So the machine's most honest language is a row of bulbs. But a long row of bulbs is exhausting for a human to read — that is the problem the whole page is about to solve.

PICTURE. Below, a row of 8 bulbs. Dark bulb = $0$ , bright bulb = $1$ . This exact 8-bulb pattern (our running example $11010110$ ) is the star of every remaining figure.

Figure — Hexadecimal and octal representation

Step 2 — Place value: why the RIGHT end is special

WHAT. Every bulb carries a weight, and the weights are not equal. Reading from the right, the weights are $2^{0}, 2^{1}, 2^{2}, \dots$ — each step to the left doubles. The tiny raised number is the exponent: $2^{0}$ means "one" (nothing doubled yet), $2^{1}$ means "two", $2^{2}$ means "four", and so on.

The value of the whole row is the positional sum:

$value = \sum_{i} d_{i} \cdot 2^{i}$

Let me name every piece right where it sits:

$d_{i}$ — the digit ( $0$ or $1$ ) sitting in position $i$ (bulb dark or bright).
$i$ — the position, counted from the right starting at $0$ .
$2^{i}$ — the weight of that position; the base $2$ raised to the position number.
$\sum_{i}$ — the " $\sum$ " symbol is just shorthand for "add up all of these, for every position $i$ ." It is not new maths; it is a lazy way to write $+ + + \dots$

WHY $2^{i}$ and not something else? Because each new bulb to the left must be able to represent everything the bulbs to its right can already reach, plus one more. The bulbs to the right of position $i$ can count from $0$ up to $2^{i} - 1$ ; so the next bulb has to be worth exactly $2^{i}$ to continue without gaps or overlaps. That is the deep reason the weights double.

PICTURE. Each bulb labelled with its weight $2^{i}$ . Notice the arrow: weights grow leftward, so the anchor — the " $1$ s place", $2^{0}$ — is on the right. Remember this; it decides which side we group from.

Recall Why does grouping have to start from the right?

Because place value is anchored at $2^{0}$ on the right ::: any clean grouping must respect that anchor, or the block weights won't line up as powers of the base.

Step 3 — The magic coincidence: 4 bits fill exactly one hex digit

WHAT. Take 4 bulbs in a row. How many different patterns can 4 bulbs make? Each bulb doubles the count: $2 \times 2 \times 2 \times 2 = 2^{4} = 16$ patterns, from $0000$ up to $1111$ . And $16$ is exactly the number of symbols hexadecimal (base 16) needs: $0, 1, \dots, 9, A, B, C, D, E, F$ .

WHY this matters. A one-to-one matching. There are $16$ four-bit patterns and $16$ hex digits — no pattern is left out, no hex digit is unused. So one hex digit is a nickname for exactly one group of 4 bits. No arithmetic, no leftovers.

The hex letters (introduced in the parent) fill the gap above $9$ :

$A = 10, B = 11, C = 12, D = 13, E = 14, F = 15$

PICTURE. All 16 four-bit patterns as tiny bulb-rows, each paired with its single hex nickname. This is the whole translation table.

Step 4 — Cutting the byte into hex: watch the groups form

WHAT. Our running byte is $11010110$ . We slide a knife in from the right, cutting every 4 bulbs:

$left group 1101 right group 0110$

Then we look up each 4-bulb group in the Step-3 table:

right group $0110$ : value $0 \cdot 8 + 1 \cdot 4 + 1 \cdot 2 + 0 \cdot 1 = 6$ , so digit $6$ .
left group $1101$ : value $1 \cdot 8 + 1 \cdot 4 + 0 \cdot 2 + 1 \cdot 1 = 13 = D$ .

Reading the groups left-to-right (same order they sit) gives the hex number:

$1101011 0_{2} = D 6_{16}$

WHY the knife enters from the right. From Step 2, weights are anchored at the right. Each 4-bit block, starting at the right, occupies weights $2^{0} - 2^{3}$ , then $2^{4} - 2^{7}$ , and so on. Those block boundaries land exactly on multiples of $2^{4} = 16$ — which is precisely why each block becomes a clean power of $16$ . Cut from the left instead and the first block would straddle weights like $2^{7} - 2^{4}$ but the last would be a stub at $2^{3} - 2^{0}$ of the wrong size — the powers stop lining up.

PICTURE. The byte with a vertical cut line dropping in from the right, each group boxed and tagged with its hex nickname.

Step 5 — Same byte, octal knife: groups of 3

WHAT. Octal is base 8, and $8 = 2^{3}$ , so an octal digit is a nickname for exactly 3 bits ( $2^{3} = 8$ patterns, digits $0$ – $7$ ). Our byte has $8$ bits, and $8$ is not a multiple of $3$ — so before cutting we pad the left with a zero up to $9$ bits (a leading zero never changes the value, it is just a dark bulb worth nothing):

$011010110 \to 301120106110$

$110 = 4 + 2 = 6$
$010 = 2$
$011 = 2 + 1 = 3$

$1101011 0_{2} = 32 6_{8}$

WHY pad on the LEFT specifically. Same anchor logic as Step 4: the knife must enter from the right so blocks align on multiples of $8$ . The right end must stay fixed at $2^{0}$ ; so any spare space to reach a multiple of 3 has to be added on the left, where a $0$ costs nothing.

PICTURE. The byte with one pad-bulb (drawn faint) added on the left, then three cuts, each group tagged with its octal digit.

Step 6 — Why hex and octal can't talk directly (the degenerate case)

WHAT. It is tempting to convert hex $\to$ octal by swapping groups directly. You cannot, because $4$ -bit groups and $3$ -bit groups do not line up on the same boundaries. Watch $2 F_{16}$ :

$2 F_{16} \to 20010 F 1111 = 0010111 1_{2}$

Now re-cut that same bit string into 3s from the right (pad left to 6 bits, dropping the leading pair which is all zero after regroup):

$00101111 \to 51017111 = 5 7_{8}$

WHY binary is the mandatory middle-man. Binary is the finest grid — every hex block and every octal block is built from single bits. So both align with binary, but their block sizes ( $4$ vs $3$ ) never align with each other. Binary is the common ground they must both pass through.

PICTURE. The same bit-string shown twice: top ruler cuts it into 4s (hex), bottom ruler into 3s (octal). The cut lines land at different places — that mismatch is the reason.

Step 7 — The other degenerate cases: zero, and a length that's already a multiple

WHAT.

All bulbs off ( $00000000$ ): every group is $0000 \to 0$ (hex) and $000 \to 0$ (octal). So the byte is $0 0_{16}$ and $00 0_{8}$ . No surprises — but you must not drop to a single $0$ if a fixed width is expected.
Length already a multiple of the group size: e.g. $1111$ (4 bits) needs no padding for hex — it is exactly one group, $F_{16}$ . For octal though, $1111$ pads to $001111 = 1 7_{8}$ . Padding is only about reaching the next multiple; when you're already there, skip it.

WHY show these. These are the cases where beginners either over-pad (adding a whole useless group) or under-pad (leaving a stub group that has fewer bits than the base needs). The rule is exact: pad the left with the fewest zeros needed to make the bit count a multiple of the group size (4 for hex, 3 for octal), then never again.

PICTURE. Two mini-rows: the all-off byte, and $1111$ shown once as a single hex group and once padded into two octal groups.

The one-picture summary

Everything above collapses into a single diagram: one binary byte in the middle, a 4-bit ruler cutting it upward into hex, a 3-bit ruler cutting it downward into octal, both knives entering from the right, pad-bulbs drawn faint on the left, and the decimal value $214$ hanging off to the side as the invariant nobody's allowed to change.

Recall Feynman retelling — say it like you'd tell a friend

A byte is a row of 8 light bulbs, and the rightmost bulb is the "ones" bulb — weights double as you walk left. Long rows are hard to read, so we give nicknames to chunks of bulbs. Here's the lucky thing: 4 bulbs make exactly 16 patterns, and hex has exactly 16 symbols, so 4 bulbs = 1 hex nickname with nothing wasted. Octal has 8 symbols and 3 bulbs make exactly 8 patterns, so 3 bulbs = 1 octal nickname. To translate, I slide a knife in from the right (because the "ones" anchor lives there) and cut every 4 bulbs for hex or every 3 for octal, padding the left with dark bulbs if I run short. Hex and octal can't chat directly — 4s and 3s never cut at the same place — so I always route through the raw bulbs. And no matter how I nickname it, the underlying number ( $214$ for our byte) never budges: I only changed its outfit, never its identity.

Quick recall

Why is the group size 4 for hex and 3 for octal?

Because

16 = 2^{4}

(exponent 4) and

8 = 2^{3}

(exponent 3); the exponent is the number of bits one digit covers.

Which side do you cut the binary from, and why?

From the right, because place value is anchored at

2^{0}

on the right; block boundaries then land on clean powers of the base.

Why pad on the left, never the right?

A leading zero is worthless (worth nothing), and the right end must stay fixed at

2^{0}

; the spare space goes on the left.

Convert

1101011 0_{2}

to hex and octal.

D 6_{16}

and

32 6_{8}

(both equal

21 4_{10}

Why can't you convert hex→octal by swapping groups?

4-bit and 3-bit boundaries never coincide; route through binary, the common finest grid.

What is

D 6_{16}

in decimal?

13 \cdot 16 + 6 = 214

Connections

Binary number system — the row of bulbs everything is built from.
Positional number systems and place value — where the doubling weights come from.
Bitwise operations — the grouping is why masks read cleanly in hex.
Memory addresses and byte addressing — bytes shown as 2 hex digits.
Two's complement and signed numbers — signed values usually printed in hex.
Boolean Algebra & Logic Gates — parent chapter.
Parent: 3.1.02 Hexadecimal and octal representation (Hinglish)