Decimal to binary, one division at a time

Divide by two over and over, write down each remainder, and read the remainders from last to first. Take 42: halving gives 21 remainder 0, then 10 remainder 1, then 5 remainder 0, then 2 remainder 1, then 1 remainder 0, then 0 remainder 1 — read upwards, that is 101010. The method works because every division asks the same question, whether what is left is odd, and each answer is worth twice the one before it. The other direction is quicker mentally: subtract the largest power of two that fits, put a 1 in that column, and repeat.

It lets one piece of hardware do both addition and subtraction. Under two's complement the top bit carries a negative weight, so adding the bit patterns for −3 and 5 with the ordinary addition circuit gives 2 with no special case for the sign, and subtraction becomes addition of the complement. The alternatives were tried and abandoned: sign-magnitude and one's complement each have two representations of zero, so a comparison against zero needs two tests, and one's complement addition needs an end-around carry that adds a whole extra pass. Two's complement has exactly one zero, no extra hardware, and it is now so universal that C++20 and C23 stopped allowing anything else.

Because there is no negative zero to waste. The 256 available patterns split into 128 with the top bit clear, which are 0 to 127, and 128 with it set, which are −128 to −1 — an asymmetric range with one more negative value than positive. That extra value causes a real bug class: negating −128 in 8 bits, or −2,147,483,648 in 32, overflows back onto itself, so Math.abs of the most negative integer returns the same negative number in most languages, and dividing it by −1 traps on x86.

The high bits are discarded and the value wraps, which is arithmetic modulo 2 to the power of the width. Storing 300 in 8 bits leaves 00101100, which reads back as 44, because 300 − 256 = 44; storing 255 + 1 leaves zero. This page flags that instead of hiding it, showing how many bits the number really needs beside the value the register would hold. The classic public example is YouTube's view counter, which was a signed 32-bit integer capped at 2,147,483,647 until Gangnam Style got close enough in 2014 that Google moved it to 64 bits.

No — this page halves whole numbers, and fractions use the mirror-image method: multiply the fractional part by two repeatedly and record the integer part of each result, reading downwards. That gives 12.75 as 1100.11, because .75 doubles to 1.5 (write 1) and the remaining .5 doubles to 1.0 (write 1, and stop). Most decimal fractions never stop: a tenth becomes 0.0001100110011… forever, which is why 0.1 has no exact binary form and why floating-point arithmetic surprises people. Round to a whole number of units — cents, milliseconds, pixels — before converting.

Take the base-2 logarithm and round down, then add one: an n-bit unsigned field holds 0 to 2ⁿ − 1. In practice you can count decimal digits and multiply by 3.32, since each decimal digit carries log₂10 bits — a 6-digit number needs about 20 bits, and 255 needs 8 while 256 needs 9. For a signed value add one more bit for the sign, so storing −1,000 takes 11 bits rather than 10. The bit count is shown here beside every result, which is usually all you need to pick between a 16-bit and a 32-bit column.

Because four bits are exactly one hex digit, so the grouping converts the two notations by eye. 1101 0010 reads as D2 without any arithmetic, and once the habit is there a 32-bit pattern becomes eight familiar symbols rather than thirty-two identical ones. Groups of eight mark byte boundaries and are the other common choice, particularly in network diagrams and register maps where what matters is which byte a bit lives in.