About

The count of 1-bits in a binary representation is formally called the Hamming weight or population count (popcount). It appears in error-correcting codes, cryptographic hash analysis, combinatorial optimization, and low-level CPU instruction design. Getting it wrong in a checksum computation or a bitmask filter means silent data corruption. This tool computes the exact Hamming weight for integers of arbitrary size using Brian Kernighan's algorithm, which runs in O(k) time where k equals the number of set bits. It accepts decimal, binary (0b prefix), hexadecimal (0x), and octal (0o) input. Negative integers are not supported because two's complement width is ambiguous without a fixed register size.

Formulas

The Hamming weight (population count) of a non-negative integer n is the number of 1-bits in its binary expansion.

popcount(n) = L − 1∑i = 0 b_i

where b_i ∈ {0, 1} is the i-th bit and L is the bit length of n.

Brian Kernighan's algorithm exploits the fact that n ∧ (n − 1) clears the lowest set bit. Repeat until n = 0 and count iterations.

k = 0
while n ≠ 0:
n ← n ∧ (n − 1)
k ← k + 1
return k

Bit density is defined as: density = popcount(n)L × 100%

where L = ⌊log₂(n)⌋ + 1 for n > 0, and L = 1 for n = 0.

Reference Data

Decimal	Binary	Ones Count	Bit Length	Density	Notes
0	0	0	1	0%	Zero case
1	1	1	1	100%	Single bit
7	111	3	3	100%	All ones (2³ − 1)
8	1000	1	4	25%	Power of 2
15	1111	4	4	100%	All ones (nibble)
42	101010	3	6	50%	Alternating pattern
127	1111111	7	7	100%	Max signed 8-bit
128	10000000	1	8	12.5%	Power of 2
255	11111111	8	8	100%	Full byte
256	100000000	1	9	11.1%	Power of 2
1023	1111111111	10	10	100%	2¹⁰ − 1
1024	10000000000	1	11	9.1%	1 KiB boundary
4096	1000000000000	1	13	7.7%	Page size
65535	1111111111111111	16	16	100%	Full 16-bit word
2147483647	31 ones	31	31	100%	Max signed 32-bit
4294967295	32 ones	32	32	100%	Max unsigned 32-bit
3735928559	0xDEADBEEF	24	32	75%	Classic debug marker
3405691582	0xCAFEBABE	22	32	68.8%	Java class magic number
48879	0xBEEF	12	16	75%	Common test value
170	10101010	4	8	50%	0xAA alternating

Frequently Asked Questions

JavaScript's Number type uses IEEE 754 double-precision floats, which can only represent integers exactly up to 2⁵³ − 1 (Number.MAX_SAFE_INTEGER = 9,007,199,254,740,991). Beyond that threshold, bit-level operations produce incorrect results because the least significant bits are silently truncated. BigInt supports arbitrary-precision integers, so the popcount remains exact for numbers with hundreds or thousands of digits.

A naive approach iterates over every bit position (O(L) where L is the bit length). Kernighan's algorithm runs in O(k) where k is the number of set bits. For sparse numbers like powers of 2, this means a single iteration instead of L. The trick: n & (n − 1) always clears exactly the lowest set bit because subtracting 1 flips all bits from the lowest set bit downward.

Bit density (ones / total bits × 100%) indicates how "heavy" a binary value is. In networking, high-density subnet masks indicate broader address ranges. In cryptography, hash outputs should have approximately 50% density; significant deviation may signal weakness. In compression, low-density values indicate redundancy. Hardware engineers use density to estimate power consumption because transistor switching correlates with the number of 1-bits.

The Hamming weight of a negative integer depends on the register width. In 8-bit two's complement, −1 has 8 ones. In 32-bit, it has 32. In 64-bit, 64. Without a fixed width, the count is ambiguous. This tool computes the Hamming weight of the mathematical (non-negative) integer itself. If you need two's complement popcount, convert manually using a specific bit width first.

Yes. The tool accepts four formats: plain decimal (42), binary with 0b prefix (0b101010), hexadecimal with 0x prefix (0xDEADBEEF), and octal with 0o prefix (0o52). The prefix is case-insensitive. Spaces and underscores within the number are stripped for readability (e.g., 1_000_000 or 0xFF_FF are valid).

The Hamming distance between two integers a and b equals popcount(a XOR b). XOR produces a 1 wherever the bits differ. Counting those 1-bits gives the number of bit positions where a and b disagree. This is the foundation of error-detection codes like Hamming(7,4) and is used in similarity metrics for binary feature vectors in machine learning.