Using binary place values, the decimal value of the binary number 101 is 5, so the correct answer is C. The digits are read right to left as 2^0 (1), 2^1 (2), and 2^2 (4). Only the 1s count, and they sit in the 4 and 1 positions: 4 + 1 = 5. The middle zero contributes nothing because 2 × 0 = 0.
How place-value expansion works
Binary is a positional numeral system, which means each digit's contribution depends on where it sits, not what it is. The rightmost position carries weight 2^0, the next 2^1, then 2^2, and so on. This mirrors decimal, where 101 means 1 × 10^2 + 0 × 10^1 + 1 × 10^0 = 101. Swap the base from 10 to 2 and the same machinery gives 1 × 2^2 + 0 × 2^1 + 1 × 2^0 = 5.
The deeper reason each position doubles is that binary has only two symbols, 0 and 1. Once a digit reaches 2, it cannot stay in one column, so it carries into the next column left. Every carry moves one place and multiplies the value by the base, which is 2. That single rule, base-2 carrying, generates the entire weight sequence 1, 2, 4, 8, 16, 32 and so on. A string of digits is therefore a sum of powers of two, filtered by which positions hold a 1.
Expansion is best done in three steps. Write the place weights under each digit, multiply each digit by its weight, then add the products. For 101 that is (1 × 4) + (0 × 2) + (1 × 1) = 5. The method scales to any width without changing, which is why computer architectures can rely on it. In plain terms, you only add up the place values wherever a 1 appears.
The numbers behind a three-bit string
A three-bit binary number spans exactly 8 distinct patterns, from 000 to 111, because 2^3 = 8. Their decimal values run from 0 to 7, so any three-bit answer outside 0 through 7 is impossible. That constraint alone eliminates option D (7) as a reading error and confirms the 101 string sits mid-range at 5.
| Binary | Place-value sum | Decimal | Notes |
|---|---|---|---|
| 000 | 0 + 0 + 0 | 0 | Smallest three-bit value |
| 001 | 0 + 0 + 1 | 1 | Only the 2^0 bit set |
| 010 | 0 + 2 + 0 | 2 | Only the 2^1 bit set |
| 011 | 0 + 2 + 1 | 3 | Option A in the question |
| 100 | 4 + 0 + 0 | 4 | Option B; the 2^2 bit alone |
| 101 | 4 + 0 + 1 | 5 | Correct answer, option C |
| 110 | 4 + 2 + 0 | 6 | Two high bits set |
| 111 | 4 + 2 + 1 | 7 | Largest three-bit value; option D |
The table exposes why the distractors exist. Option B (4) is what you get if you read only the leftmost digit's weight. Option D (7) comes from assuming all three bits are set. Option A (3) often appears when someone adds all three weights (4 + 2 + 1) regardless of the digits. Each wrong answer corresponds to a specific slip in the expansion procedure, not random guessing.
Edge cases that trip people up
Leading zeros do not change a value, so 101 and 00101 are both 5; padding a string to a fixed width is standard in hardware registers. The opposite error, dropping a trailing zero, is fatal. The string 1010 is 10, not 5, because the extra position adds a weight of 8. Position matters more than digit count, and a single shifted zero doubles the result.
Fractions behave the same way to the right of a binary point. The places there carry 2^-1 (0.5), 2^-2 (0.25), 2^-3 (0.125). So 101.1 equals 5.5, and 0.1 in binary is 0.5 in decimal, not 0.1. That mismatch is the root of floating-point rounding surprises in software, where values like 0.1 have no exact finite binary form, only an infinitely repeating one truncated by the machine.
A counterintuitive professional caveat: context can override the math you just did. The bit pattern 101 is 5 as an unsigned integer, but in a two's-complement signed 3-bit field its top bit signals a negative number, and the stored value would be interpreted as -3. The decimal reading depends on the declared data type, not the digits alone. Engineers always confirm signedness and width before trusting a conversion.
Red flag: treating all set bits as automatically additive without checking position. Red flag: assuming a longer string is always larger; alignment and sign bits break that. Red flag: reading binary left to right as if the leftmost digit were smallest. Red flag: ignoring the radix point in fractional strings and truncating silently.
Misconceptions worth correcting
The most common myth is that 101 in binary somehow equals 101 in decimal. It does not; the same glyphs mean different quantities because the base differs. A close second is counting the number of 1s and calling that the value. Two set bits in 101 give 5, not 2, because the bits sit on weights 4 and 1. Digit count is not value.
Another persistent error is believing the leftmost digit carries the least weight. Positional systems always grow leftward in weight for a fixed base, so the leftmost bit here is the most significant. Confusing most-significant and least-significant ends is the single most frequent cause of a wrong answer on this exact question.
People also assume binary conversion requires a calculator or a lookup table. The place-value method is fully manual and arguably faster for short strings, because you only sum the powers where 1s appear. Professionals keep the first eight weights memorized (1, 2, 4, 8, 16, 32, 64, 128) and read bytes by eye.
Checking answers by subtraction and grouping
A reliable second method is repeated subtraction. Start from the target value, subtract the largest power of two that fits, and mark a 1 in that position. For 5, the largest fitting power is 4, leaving 1 remainder; place a 0 at weight 2 because 2 does not fit into 1; then place a 1 at weight 1, remainder 0. Read top to bottom and the bits spell 101. Subtraction and expansion are inverses, so agreement between them is strong evidence.
For longer strings, group bits into nibbles of four and convert each group separately. Each nibble holds values 0 through 15 (2^4 = 16 patterns), which map cleanly to one hexadecimal digit. The grouping trick is what makes byte-level inspection practical, since 8 bits split into two hexadecimal characters instantly. A 101 padded to 0101 is hexadecimal 5, matching the decimal answer.
Timeline of converting 101 into the answer begins and ends quickly:
| Step | Action | Result |
|---|---|---|
| 1 | Write the string | 101 |
| 2 | Label positions right to left | 2^2, 2^1, 2^0 |
| 3 | Write weights | 4, 2, 1 |
| 4 | Multiply digit by weight | 4, 0, 1 |
| 5 | Sum the products | 5 |
| 6 | Match to options | C |
Practical actions for reliable conversion
Memorize the first several place weights, because speed comes from recall rather than computation. Know 2^0 through 2^7 cold: 1, 2, 4, 8, 16, 32, 64, 128. Most everyday conversions never exceed 8 bits, and that list covers the full range.
Apply a fixed checklist every time, which prevents the distractor traps. Align the string, label weights beneath each digit, multiply, then sum. Cross-check with repeated subtraction, and confirm the answer falls inside the legal range 0 to 2^n minus 1 for an n-bit unsigned string. For 3 bits that ceiling is 7, and 5 passes.
Watch the width and signedness before reporting a value in any real system. State explicitly whether the field is unsigned or two's-complement signed, since the same bits can mean 5 or -3 depending on declaration. When fractional bits exist, count the places to the right of the point to set the negative exponents correctly.
When teaching or verifying, test the known anchors: 100 must equal 4, 111 must equal 7, 101 must equal 5. If any anchor fails, the procedure is wrong, not the numbers. This bounded-set logic makes three-bit conversions self-checking and removes guesswork.
Limits of the simple reading
The place-value answer of 5 is correct only under the standard interpretation of 101 as an unsigned base-2 integer with three bits. Change the assumed width and the value can shift, as signed fields demonstrate. Change the base and the glyphs mean something else entirely. The number 101 in decimal is one hundred one; in binary it is five.
This explainer does not cover bitwise operations, floating-point encoding standards, or hardware register layouts, which each add their own conventions. Those topics require the specific data format in use, and a general reading cannot predict how a particular system will interpret the pattern. Confirm the declared type in any engineering context before acting on a converted value.
For routine study of this question, no external authority is needed; the arithmetic is definitional and stable. The takeaway is a repeatable method, an awareness of the 0-to-7 range, and the habit of checking signedness. That combination answers the question and prevents the common errors around it.