The binary number system begins counting from zero, not one, which is a key reason why the range starts at zero. When using n bits, the total number of possible combinations is 2^n, but since counting begins at 0, the final value is 2^n - 1. For example, 3 bits give you 8 combinations, from 000 (which is 0 in decimal) to 111 (which is 7 in decimal), covering values 0 through 7. If you were to list these combinations out, you would see that the smallest value always occurs when all bits are 0, and the largest value when all bits are 1. This range is crucial for defining the limits of data types and memory values in programming and computer systems. Understanding this pattern helps when working with binary arithmetic, programming ranges, loops, and designing digital circuits that must operate within fixed bit widths.

Bit combinations can be adapted to represent negative numbers using a method known as two’s complement representation. In this system, one bit (typically the most significant bit, or leftmost) is used to indicate the sign of the number. If the sign bit is 0, the number is positive; if it’s 1, the number is negative. For example, in a 4-bit system, 1000 represents -8 and 0111 represents +7. This system allows for a continuous range of values from -2^(n-1) to 2^(n-1) - 1, which helps simplify binary arithmetic and avoids the need for separate subtraction circuits. Importantly, two’s complement enables both addition and subtraction to be handled with the same binary hardware, as subtraction can be performed by adding the two’s complement of a number. While this goes beyond simple positive-only representation, it’s still a use of the same 2^n combinations, just interpreted differently within a signed number context.

When a binary value exceeds the representable limit of a fixed number of bits, it results in an overflow. Overflow occurs when a calculation produces a result that is too large to be stored in the available bit width. For instance, if you are using 4 bits, the maximum unsigned value is 2^4 - 1 = 15. If you try to store the value 16, the binary system will wrap around and restart at 0, producing an incorrect result. This is because binary systems do not automatically expand to accommodate larger values — they are constrained by the bit width defined in the system or hardware. In practical terms, this can cause logic errors or unexpected behaviour in programs, particularly in low-level languages like C or assembly where developers must manage bit sizes explicitly. Avoiding overflow requires either increasing the bit size or implementing logic to detect and handle such cases during processing.

Binary is favoured in digital systems because it aligns perfectly with the physical nature of electronic components, which typically operate in two distinct states: on or off, high voltage or low voltage, or true or false. These states can be easily mapped to the binary digits 1 and 0, making binary a natural and reliable way to represent information. Additionally, binary simplifies the design of digital circuits. Logic gates like AND, OR, and NOT work efficiently with two-state inputs, and memory devices such as flip-flops and registers are built to hold binary values. Binary also reduces the likelihood of signal degradation or ambiguity, which is more common when using more complex or multi-level systems. With binary, error detection and correction become more manageable, and calculations can be performed using simple, predictable rules. Overall, the robustness, clarity, and compatibility of binary with hardware make it the foundation of digital computing.

Using fixed-size bit groupings introduces several limitations, particularly in terms of range, flexibility, and efficiency. First, a fixed number of bits restricts the maximum and minimum values that can be represented. For example, 8 bits can only store values between 0 and 255 in an unsigned system. This can be problematic when larger values are needed, leading to overflow or requiring the use of larger bit sizes, which consume more memory. Second, fixed bit sizes can be inefficient. For instance, using 32 bits to store a value that only needs 8 bits wastes storage space. Third, some data types — like large integers or variable-length text — don’t always fit neatly into fixed bit sizes, requiring complex encoding schemes or multiple blocks of storage. Additionally, working with fixed bits can make it harder to adapt to changing data requirements, and it requires programmers to be mindful of limits and potential errors. These limitations make flexible data representation formats desirable in high-level systems.