About

The Look-and-Say sequence, introduced by John Conway in 1986, describes each term by reading aloud the digits of the previous term. The binary variant restricts both the seed and the counting to base-2 arithmetic. Given a term like 1110, you read it as "three ones, one zero," which in binary becomes 11 (three) 1 (the digit) followed by 1 (one) 0 (the digit), yielding 111110. This differs fundamentally from the decimal variant because binary counts themselves contain only 0 and 1, causing the sequence to grow at a different asymptotic rate. Miscounting run lengths or confusing decimal versus binary count encoding produces entirely wrong successor terms.

This tool computes exact binary Look-and-Say iterations for arbitrary binary seeds. Growth is approximately exponential. Sequence length roughly multiplies by a factor between 1.2 and 1.6 per iteration depending on the seed's structure. The generator caps at 60 iterations to prevent browser memory exhaustion. Note: seeds with long uniform runs produce shorter successors relative to seeds with high bit-alternation frequency.

Formulas

The binary Look-and-Say transform operates on a string S_n to produce S_n+1. The string is partitioned into maximal runs of identical digits.

S_n = r₁ r₂ … r_k

Each run r_i consists of c_i consecutive copies of digit d_i where d_i ∈ {0, 1}. The successor term concatenates the binary representation of each count with its digit:

S_n+1 = bin(c₁) ⋅ d₁ ⋅ bin(c₂) ⋅ d₂ ⋅ … ⋅ bin(c_k) ⋅ d_k

Where bin(c) converts the integer count c to its binary string representation and ⋅ denotes string concatenation.

The asymptotic growth ratio λ for length is defined as:

λ = lim_n→∞ |S_n+1||S_n|

Where |S_n| is the string length of the n-th term. For the decimal Look-and-Say with seed 1, Conway proved λ ≈ 1.303577 (Conway's constant). The binary variant exhibits a different growth constant dependent on the seed.

Reference Data

Iteration	Seed: 1	Length	Seed: 0	Length	Seed: 10	Length
0	1	1	0	1	10	2
1	11	2	10	2	1110	4
2	101	3	1110	4	11110	5
3	111011	6	11110	5	100110	6
4	1110101011	10	100110	6	11001010	8
5	111010111010111	15	11001010	8	10100111010	11
6	22 digits		12 digits		16 digits
7	33 digits		18 digits		24 digits
8	50 digits		26 digits		35 digits
9	75 digits		40 digits		53 digits
10	112 digits		59 digits		79 digits
15	~1,285 digits		~675 digits		~905 digits
20	~14,700 digits		~7,750 digits		~10,400 digits

Frequently Asked Questions

In the decimal Look-and-Say, run-length counts are expressed in base 10, so reading "three ones" produces the string "31". In the binary variant, that same count of three is expressed as its binary representation bin(3) = 11, so the output becomes 111 (binary three followed by digit one). This means the output alphabet is still restricted to {0, 1}, but the encoding of counts consumes more characters, altering the growth dynamics.

Each run of length c in the input produces floor(log₂(c)) + 1 bits for the count, plus 1 bit for the digit. A highly alternating input like 101010 has all runs of length 1, so each bit becomes 11 or 10 (two bits), roughly doubling the length. Seeds with longer uniform blocks grow more slowly because a run of length c collapses into approximately log₂(c) + 2 output bits.

A run of, say, 5 consecutive ones is encoded as bin(5) = 101 followed by the digit 1, yielding 1011. This multi-bit count encoding is what distinguishes the binary Look-and-Say from a naive "just prepend 1 for one occurrence" approach. Without tracking the boundary between count and digit, the sequence cannot be unambiguously decoded. This generator displays run-length annotations to help you trace each step.

No. Unlike the decimal version where digits 1 - 9 as counts are self-delimiting (single character), binary counts vary in length. Given the output 111, you cannot determine whether this means "11 ones and 1 of something" or "1 one and 1 one" without knowing the encoding convention. This tool uses the standard convention where counts are minimal binary (no leading zeros except for the number zero itself), followed immediately by the single digit being counted.

Yes. The generator accepts any binary string as a seed. Longer seeds produce correspondingly longer successor terms. A seed of length L with maximum alternation will produce a first iterate of approximately 2L bits. By iteration 10, the result can exceed tens of thousands of bits. The tool truncates display at 5,000 characters but computes and reports full statistics (length, ratio, run count) for the complete string.

Conway's constant λ ≈ 1.303577 applies specifically to the decimal Look-and-Say with seed 1. The binary variant has a different growth constant that depends on the seed. Empirically, seed 1 in binary produces a growth ratio converging near 1.47 - 1.50, while highly alternating seeds converge closer to 1.55 - 1.60. No closed-form constant analogous to Conway's has been proven for binary Look-and-Say.