Why does the sequence stop looking purely binary after a few terms?

Because once any run reaches a length of 2 or more, describing it introduces the digit '2' (or higher) into the term, e.g. "11" (two 1s) becomes "21". From that point on, terms are general digit strings, not binary strings, even though they started from a binary seed.

What does 'each term describes the previous term' actually mean?

You read the previous term aloud, run by run: "one 1" for "1", producing "11"; "two 1s" for "11", producing "21"; "one 2, one 1" for "21", producing "1211", and so on.

Is there a limit on the seed length or number of iterations?

Yes, the seed is capped at 20 digits and iterations at 40, since each look-and-say step can grow the term substantially (the sequence is known to grow at roughly 1.303 times per step), and an uncapped run could produce an impractically long string.

Does the sequence ever repeat or terminate?

No, other than a couple of special starting seeds (like "22", which maps to itself), the look-and-say sequence grows forever and never repeats or cycles.

Binary Look-and-Say Generator - Generate the Sequence Online

Overview

Introduction

The look-and-say sequence is a famous self-referential sequence: you read the previous term aloud, run of digits at a time, and that spoken description becomes the next term.

This tool generates it starting from any binary seed you choose (default "1"), producing one term per output line for as many iterations as you like.

What Is Binary Look-and-Say Generator?

A generator for the classic look-and-say (also known as Conway's) sequence, seeded from a binary starting value.

Each term after the first describes the run-lengths of consecutive identical digits in the previous term, using the format `<count><digit>` for each run, concatenated together.

How Binary Look-and-Say Generator Works

Starting from the seed, the tool scans each term left to right, grouping consecutive runs of the same digit, and for every run it emits the run's length followed by the digit itself.

Those `<count><digit>` groups are concatenated (with no separator) to form the next term, and the process repeats for the requested number of iterations, with each term printed on its own line.

When To Use Binary Look-and-Say Generator

Use it to explore or demonstrate this classic recreational-mathematics sequence, or to generate specific terms for a puzzle, teaching example, or programming exercise.

It's also a good way to sanity-check a look-and-say implementation you're writing yourself against a known-correct reference.

Often used alongside Binary RLE Encoder and Binary Square Generator.

Features

Advantages

Accepts any binary seed, not just the traditional "1", letting you explore how different starting points evolve.
Caps seed length and iteration count to keep output readable and generation fast, since the sequence grows quickly.
Prints every intermediate term, not just the final one, so you can see the full progression.

Limitations

Terms stop being purely 0s and 1s as soon as any run reaches a length of 2 or more, since describing that run introduces the digit '2' (or higher); only the seed itself is guaranteed to be pure binary.
The sequence grows in length by roughly 30% per term on average, so high iteration counts on a long seed can produce very long final terms even within the 40-iteration cap.

Examples

The classic sequence from seed "1"

Input

1 (5 iterations)

Output

Each line describes the run-lengths of the line above it: "1" is one 1 -> "11"; "11" is two 1s -> "21"; "21" is one 2 and one 1 -> "1211"; "1211" is one 1, one 2, two 1s -> "111221".

Starting from a different binary seed

Input

10 (3 iterations)

Output

10
1110
3110

"10" is one 1 and one 0 -> "1110"; "1110" is three 1s and one 0 -> "3110".

Best Practices & Notes

Best Practices

Start with the default seed "1" if you want to reproduce the sequence's most commonly cited form.
Keep iteration counts modest (under 15-20) for seeds longer than a few digits, since output length grows quickly.

Developer Notes

Implemented with the same run-scanning technique as Binary RLE Encoder: a two-pointer pass emits `<count><digit>` for each run, but concatenated directly (no separators) rather than joined with an 'x' and spaces, matching the traditional look-and-say notation.

Binary Look-and-Say Generator Use Cases

Exploring or demonstrating the look-and-say sequence for recreational mathematics
Generating known-correct reference terms to test your own look-and-say implementation
Producing sequence terms for a puzzle or teaching example

Common Mistakes

Expecting every term to remain a valid binary string; only the seed is guaranteed to be, later terms commonly contain digits like '2' or '3'.
Confusing this with run-length encoding notation; look-and-say concatenates `<count><digit>` directly with no separator or 'x' marker.

Tips

Compare this tool's run-scanning logic to Binary RLE Encoder, both find runs the same way, but format the result differently.
Try seed "22" to see one of the sequence's rare fixed points, where a term maps to itself.

Binary Look-and-Say Generator