Say the digits out loud, then write down what you said
Start from 1. You see one 1, so the next term is 11. Now you see two 1s, which gives 21. Then one 2 followed by one 1, written 1211. No arithmetic happens anywhere. Each term is a spoken description of the one before, turned back into digits.
| Term | Read as | Next term |
|---|---|---|
1 | one 1 | 11 |
11 | two 1s | 21 |
21 | one 2, one 1 | 1211 |
1211 | one 1, one 2, two 1s | 111221 |
111221 | three 1s, two 2s, one 1 | 312211 |
312211 | one 3, one 1, two 2s, two 1s | 13112221 |
John Conway gave the sequence its serious treatment in a 1986 paper with a playful title, The Weird and Wonderful Chemistry of Audioactive Decay. Programmers meet the same rule under another name, count and say, as LeetCode problem 38. Click any row in the ladder above and the Read aloud box spells out the runs for that term, one chip per run, followed by the term they produce.
Why the digits never climb past 3
Start from 1 and the sequence never writes a 4, a 5, or anything higher. The reason fits in a few lines. A term is a chain of pairs, a count and then a digit. Suppose four identical digits ever sat side by side, say 2222. Read as pairs, those are two 2s followed by two 2s, two neighbouring runs of the same digit. A correct description would have merged them into four 2s, so the situation never arises. After the first step no run is longer than 3, every count is 1, 2, or 3, and the only digits a term holds are those counts plus whatever digits the seed brought in.
The generator confirms this on the fly. Seed 1 run to 50 terms ends in a term of 894,810 digits, made of 442,943 ones, 286,629 twos, and 165,238 threes. Not a single 4. The Digit mix stat under the chart shows the same split for whatever seed you type.
The last digit never changes
The final run of a term ends in some digit d, and the description of that run ends in d too. So every term ends with the last digit of the seed, forever. Seed 2026 produces 12101216, then 1112111011121116, and every line after closes with 6. The stat panel reports this as Every term ends in, which doubles as a quick sanity check on an exported file.
22 is the only seed that stays put
Read 22 aloud and you get two 2s, which is 22 again. Conway showed no other seed describes itself, and every other non-empty seed grows without limit. Tap the 22 chip and the ladder prints the same two digits on every row, with a ratio of exactly 1.0000x down the right side.
Conway's constant, about 30 percent longer per step
Term lengths from seed 1 start out jumpy. Two steps keep the length level, at T2 to T3 and again at T5 to T6. Further down, the ratio between neighbouring lengths settles.
| Term | Digits | Ratio to the term before |
|---|---|---|
| T10 | 20 | 1.4286 |
| T20 | 302 | 1.3363 |
| T30 | 4,462 | 1.3085 |
| T40 | 63,138 | 1.3042 |
| T50 | 894,810 | 1.3032 |
The ratio closes in on 1.303577, known as Conway's constant and written as the Greek letter lambda. Conway derived it as the largest real root of a polynomial of degree 71, built by tracking how 92 recurring blocks of digits feed into each other. In practice the constant gives you a fast estimate. Lambda to the 10th power is about 14.17, so ten more steps make a term roughly 14 times longer. Multiply T40's 63,138 digits by 14.17 and you land within 200 of the real T50.
The periodic table hidden inside long terms
Conway noticed that long terms split into blocks that evolve without touching their neighbours. He found 92 of them and named them after the chemical elements, hydrogen through uranium. Hydrogen is 22, the seed that never changes. Uranium is the single digit 3, and its decay chain is the start of the seed 3 sequence: 3, 13, 1113, 3113, 132113. His Cosmological Theorem says every seed, after enough steps, breaks into a mix of these 92 elements plus two transuranic families for strings that carry digits 4 and above.
Count and say for coding interviews
The interview version fixes the seed at 1 and asks for term n, with countAndSay(1) equal to "1". The seed is term 1 there, which is the default numbering here. Switch the numbering to Seed is T0 if your source counts the seed as term zero, the most common off-by-one when comparing two lists. LeetCode caps n at 30, and T30 is 4,462 digits long, so the expected answer is a string of 4,462 characters rather than a number. Tap the 1 to T30 chip to see it.
// JavaScript: one regex pass per term
const next = s => s.replace(/(\d)\1*/g, run => run.length + run[0]);
# Python: groupby collects each run
from itertools import groupby
def next_term(s):
return "".join(f"{len(list(g))}{d}" for d, g in groupby(s))The bug behind most failed hand-written loops is the final run. A loop that writes out a run when the digit changes never sees a change after the last digit, so 1211 comes out as 1112 instead of 111221. Flush the open run after the loop ends, or use one of the two forms above, which handle the end of the string for you.
Seeds that bend the usual pattern
- Ten or more of one digit. 1111111111 is ten 1s, written 101. A 0 shows up, and the next term is 111011. Counts are written in plain decimal, which is the standard reading. Some puzzle sites cap runs at 9 and split longer ones, and their terms will not match this page.
- Digits above 3. Seed 9 gives 19, 1119, 3119. The 9 never multiplies, since counts stay at 3 or below, and the 9 never disappears either. A seed of 2026 keeps one 6 at the end of every term.
- Zero and leading zeros. 0 reads as one 0, giving 10, then 1110, then 3110. Leading zeros are kept exactly as typed, so 007 becomes 2017 while 7 becomes 17.
- Spaces. The seed field strips spaces, so
1 2 1 1is read as 1211. Any other character that is not a digit stops the ladder with an error under the field.
Where this generator stops
- 50 terms at most. From seed 1 the ladder ends at 894,810 digits and holds about 3.8 million characters in total. Building that takes a fraction of a second on a laptop and noticeably longer on an older phone.
- One million digits per term. Longer seeds hit this before term 50. Seed 123 repeated ten times crosses a million digits at T39, so the ladder keeps T1 through T38 and says so in a note.
- Rows show 240 digits. Longer terms display a shortened row with a count of the hidden digits. Copy and Download always carry every digit.
- Seeds up to 30 digits. A longer seed only reaches the million-digit ceiling sooner, so the field rejects it rather than producing a short ladder.
- Decimal counts only. Variants in base 2 or base 3, and the summarize version that counts every digit in a term regardless of position, follow different rules and are not built here.
Everything runs in this tab. The seed you type, the terms, and the exports never leave your browser, and Copy link puts only the seed and the term count in the address.