About

Every integer maps to a unique binary string of 0s and 1s. The distribution of zeros within that string is not trivial. Leading zeros depend on word size. Trailing zeros equal the largest power of 2 that divides n. Consecutive zero runs affect Hamming weight calculations and carry-chain length in adder circuits. Miscounting zeros leads to incorrect bitmask construction, broken permission flags, and off-by-one bugs in network subnet calculations. This tool parses decimal, hexadecimal, octal, or raw binary input and returns a complete zero-distribution profile: total zeros, leading zeros, trailing zeros, longest zero run, zero density ρ₀, and a positional bit map. It assumes unsigned magnitude representation. Negative values are handled via two's complement at a configurable word size.

Formulas

Given an input value, convert it to its unsigned binary string B of length n. The zero density is defined as:

ρ₀ = Zn

where Z = total count of 0 bits in B, and n = bit length of B.

Trailing zeros equal the 2-adic valuation ν₂(n), i.e., the exponent of the highest power of 2 dividing n:

ν₂(n) = max{ k : 2^k | n }

Leading zeros depend on the chosen word size W (e.g., 8, 16, 32, 64):

L = W − n

where L = leading zero count, W = word size in bits, n = significant bit length. The longest zero run is found by iterating through B and tracking the maximum consecutive 0 subsequence length. Hamming weight (popcount) is H = n − Z, the count of 1 bits.

Reference Data

Decimal	Binary	Bit Length	Total Zeros	Leading Zeros (8-bit)	Trailing Zeros	Longest Zero Run	Zero Density
0	0	1	1	7	1	1	100%
1	1	1	0	7	0	0	0%
2	10	2	1	6	1	1	50%
7	111	3	0	5	0	0	0%
8	1000	4	3	4	3	3	75%
10	1010	4	2	4	1	1	50%
15	1111	4	0	4	0	0	0%
16	10000	5	4	3	4	4	80%
42	101010	6	3	2	1	1	50%
100	1100100	7	4	1	2	2	57.1%
127	1111111	7	0	1	0	0	0%
128	10000000	8	7	0	7	7	87.5%
255	11111111	8	0	0	0	0	0%
256	100000000	9	8	0	8	8	88.9%
1000	1111101000	10	4	0	3	3	40%
1023	1111111111	10	0	0	0	0	0%
1024	10000000000	11	10	0	10	10	90.9%
2048	100000000000	12	11	0	11	11	91.7%
4096	1000000000000	13	12	0	12	12	92.3%
65535	1111111111111111	16	0	0	0	0	0%

Frequently Asked Questions

Leading zeros are padding bits between the word boundary and the most significant 1 bit. An 8-bit word for the value 5 (101 in binary) has 5 leading zeros (00000101). A 32-bit word for the same value has 29. The tool defaults to the natural bit length (no leading zeros) but lets you select standard word sizes of 8, 16, 32, or 64 bits to match real hardware registers.

Trailing zeros in the binary form of n equal the 2-adic valuation ν₂(n). This tells you the largest power of 2 that divides n. It is critical in algorithms like binary GCD, memory alignment checks (addresses must be divisible by 4, 8, or 16), and determining loop unrolling factors in compiler optimization.

Zero density ρ₀ is the ratio of 0 bits to total bit length. Hamming weight counts 1 bits. They are complements: ρ₀ = 1 − Hn. A high zero density means the number is sparse in set bits, which affects entropy estimation and compression ratios.

Yes. Prefix your input with 0x for hexadecimal (e.g., 0xFF), 0o for octal (e.g., 0o77), or 0b for raw binary (e.g., 0b101010). Without a prefix, the tool interprets the input as a base-10 decimal integer. Invalid characters for the chosen base trigger an error toast.

The integer 0 has a single-bit binary representation 0. Total zeros = 1, trailing zeros = 1, leading zeros depend on word size (e.g., 7 for 8-bit), longest run = 1, zero density = 100%, and Hamming weight = 0. This is a valid edge case, not an error.

JavaScript handles safe integers up to 2⁵³ − 1 (9007199254740991). For larger values, the tool uses BigInt parsing, supporting arbitrarily large integers limited only by browser memory. Raw binary strings can be up to 1024 bits for practical display purposes.