Binary number system and bit - byte concepts: Question bank

Three pictures below anchor the three ideas most of these traps hinge on: column weights, the shift-doubling move, and the branching tree that explains $2^{n}$ .

Column weights (which end is the least significant bit?) — the rightmost column is worth $2^{0} = 1$ ; each column to the left doubles.

Figure — Binary number system and bit - byte concepts

Appending a trailing zero shifts everything left = multiply by 2.

Why $n$ bits give $2^{n}$ patterns — each bit forks the count in two.

True or false — justify

Each line: a claim, then :::, then the honest reasoning. Do not accept a bare "true/false".

n

bits can represent

2^{n}

different values.

True. Each of the

n

bits independently has

2

choices, so by the multiplication principle there are

2 \times 2 \times \dots = 2^{n}

distinct patterns.

n

bits can hold a maximum unsigned value of

2^{n}

False. There are

2^{n}

patterns, but they run

0, 1, \dots, 2^{n} - 1

, so the largest value is

2^{n} - 1

. One byte tops out at

255

, not

256

Adding a leading zero to a binary number changes its value.

False. That extra bit sits in a column worth its power of two times

0

, contributing

0

01 1_{2}

and

1 1_{2}

both equal

3

Adding a trailing zero (a zero on the right) doubles a binary number's value.

True. It shifts every existing digit one column to the left, so each old weight

2^{i}

becomes

2^{i + 1}

— exactly a multiply by

2

, just like appending a

0

in decimal multiplies by

10

In binary the column weights, right to left, are

1, 2, 4, 8, 16, \dots

True. The base is

2

, so each column is worth

2

times the one to its right:

2^{0}, 2^{1}, 2^{2}, \dots

A byte can store exactly one text character.

False. By convention a byte is

8

bits, but characters can span multiple bytes (e.g. many symbols in UTF-8 take

2

–

4

bytes). "Byte" and "character" are not the same thing.

1 KB

always means exactly

1000

bytes.

False. In SI/decimal

1 kB = 1 0^{3} = 1000

bytes, but the memory unit

1 KiB = 2^{10} = 1024

bytes — so the meaning depends on context and is not always

1000

Base-2 is the only way a computer's hardware can physically store information.

False. Standard transistors are simplest with two stable states, which is why base-2 dominates; but hardware can use more levels (multi-level flash cells store several bits per cell, and analog/quantum devices exist). Base-2 is the common convention, not a physical law.

A nibble (

4

bits) can represent exactly one hexadecimal digit.

True.

4

bits give

2^{4} = 16

patterns, and hexadecimal has exactly

16

symbols (

0

–

F

), so one nibble ↔ one hex digit. See Hexadecimal number system.

Every binary number ends in the least significant bit on the left.

False. Position

0

(weight

2^{0} = 1

, the least significant bit) is on the right, matching how decimal puts the units digit on the right.

Spot the error

A student's line of reasoning is given; find the flaw and state the fix.

13/2 = 6

1

6/2 = 3

0

3/2 = 1

1

1/2 = 0

1

; reading top-to-bottom gives

101 1_{2}

The remainders are read bottom-up, not top-down. The first remainder is the

2^{0}

bit; reading upward gives

110 1_{2}

(

= 13

), while

101 1_{2}

wrongly equals

11

"One byte holds

2^{8} = 256

patterns, so its unsigned values go from

1

256

The range starts at

0

, not

1

. Values run

0

255

; the count

256

includes the pattern for

0

10 0_{2}

is bigger than

9 9_{2}

because

100

is a three-digit number."

You cannot judge magnitude by digit count across bases, and

9 9_{2}

is not even valid — the digit

9

doesn't exist in base

2

(only

0

and

1

are allowed).

"To store the number

256

you need

8

bits, since

2^{8} = 256

8

bits label only the values

0

–

255

, so the value

256

doesn't fit and overflows them. You need

9

bits, because

2^{8} = 256

patterns stop at label

255

; to include the value

256

you need

2^{9} = 512

patterns.

"Since decimal

253 = 2 \cdot 1 0^{2} + 5 \cdot 1 0^{1} + 3 \cdot 1 0^{0}

, binary must use powers of

10

too."

The place-value rule is the same, but the base changes the column weights. Binary uses powers of the base

2

(

1, 2, 4, 8, \dots

), not powers of

10

1024

is a nice round number, so

1 KiB

is a decimal kilobyte."

1024

is round only in binary (

= 2^{10}

). The decimal kilobyte is

1000

. Roundness in one base says nothing about the other.

Why questions

Why does repeatedly dividing a whole number by

2

produce its binary digits?

We work with the number's value, not any particular written form. Dividing by

2

asks "how many groups of two, and is there

1

left over?" — the remainder (

0

1

) is exactly the current least significant bit, and each division peels off the next bit from the right.

Why do we only add the columns that contain a

1

when converting binary to decimal?

0

in a column contributes

0 \times (its weight) = 0

, so it adds nothing; only the

1

-columns carry value.

Why is the byte (

8

bits) the standard addressable unit rather than the bit?

Addressing every single bit would need far more addresses and hardware; grouping into bytes gives a practical granularity, and

8

bits neatly hold one character-sized value or two nibbles/hex digits. See Memory addressing.

Why does the value formula

V = \sum d_{i} b^{i}

start the position count at

0

, not

1

The rightmost column must be worth

b^{0} = 1

(plain units); if we started at

1

the units column would wrongly be worth

b^{1} = b

, breaking every conversion.

Why can a computer represent letters, images, and sound if it only stores

0

s and

1

Any information can be encoded as a pattern of on/off states via an agreed scheme; the bits themselves are neutral — meaning comes from the convention that reads them.

Why is losing "one value" (

2^{n} - 1

instead of

2^{n}

) not really a loss of a pattern?

We don't lose a pattern at all — all

2^{n}

patterns exist. It's only that the labels

0.. 2^{n} - 1

include

0

, so the biggest label is one less than the count.

Edge cases

What does

0

bits (

n = 0

) represent?

2^{0} = 1

pattern — the empty pattern — representing exactly one value (conventionally

0

). It's a valid but degenerate case of the formula, not "nothing".

What is the binary representation of

0

A string of zeros (e.g.

0

000 0_{2}

); every column holds

0

, so the sum is

0

. It's the one pattern present in every bit width.

1_{2}

the same value as

1_{10}

Yes, both equal one — the single units column

2^{0} = 1 = 1 0^{0}

. Single-digit numbers coincide across all bases because only the

b^{0} = 1

column is used.

What is the largest value in a nibble, and does the "

2^{n} - 1

" rule still apply?

2^{4} - 1 = 15

(binary

111 1_{2}

). The rule holds for any width:

4

bits give

16

patterns labelled

0

–

15

If a value needs more bits than a byte provides, what happens on hardware that stores only bytes?

It's split across multiple bytes (multi-byte storage) — e.g. two bytes span

0

–

65535

(

2^{16} - 1

). A single byte alone simply cannot hold anything above

255

; larger values overflow it.

Does the number of digits in a binary number tell you its exact decimal value?

No. It bounds the value: an

n

-digit binary number (leading

1

) lies in

[2^{n - 1}, 2^{n} - 1]

, but the exact value depends on which inner bits are set.

Recall One-line self-test before you close

Cover the answers above and re-answer: " $n$ bits → max value?", "KiB vs kB?", "which end is the LSB?", "why bottom-up remainders?". If any reasoning wobbles, revisit the parent note's Section 3–4.

Connections

Binary number system and bit - byte concepts (index 3.1.1) — the parent this drill hardens.
Hexadecimal number system — one nibble ↔ one hex digit (edge-case section).
Two's complement — how the signed reading of a byte differs from the unsigned range here.
Logic Gates — the $0/1$ bits these traps concern are exactly what gates transform.
Memory addressing — why the byte, not the bit, is the addressable unit.