Number List Generator

About the Number List Generator

This tool builds a sequence of numbers from a start value to an end value using whatever step size you set. If the start is larger than the end, it automatically counts down instead of up, so you don't need to enter a negative step yourself. You can join the numbers with a comma, a comma and space, a new line on each entry, or any custom separator you type in, and optionally pad shorter numbers with leading zeros so every entry lines up to the same width.

• Direction, inferred automatically from whether start is less than or greater than end.
• Zero padding, every number is padded to match the width of the longest number in the generated list.
• Shuffle, uses the browser cryptographic random number source for a fair, unbiased shuffle of the final order.
• Safety cap, generation is capped at 100000 numbers so an overly wide range with a tiny step cannot freeze your browser.

Decimal steps get rounded to correct for floating-point drift

Building a sequence with a non-integer step, like 0.1, means repeatedly adding that value in a loop, and JavaScript floating-point numbers (IEEE 754 doubles, the same representation nearly every language uses) cannot represent most decimal fractions exactly. A classic symptom is that 0.1 + 0.2 evaluates to 0.30000000000000004 instead of 0.3. Left uncorrected, that tiny drift compounds across a long sequence and starts showing up as numbers like 2.4999999999999996 instead of 2.5. This tool rounds every generated value to 9 decimal places (Math.round(n * 1e9) / 1e9) before it is added to the list, which cleans up that drift without limiting precision for standard calculations. The loop stopping condition also allows a tiny tolerance past the end value (plus or minus 0.000000001) for the same reason to prevent early termination.

Cryptographically secure Fisher-Yates shuffle

The Shuffle option pulls its randomness from crypto.getRandomValues() rather than Math.random(), ensuring that numbers driving each swap are cryptographically unpredictable. It runs an in-place Fisher-Yates shuffle across the generated array, guaranteeing an unbiased distribution of permutations across all elements.

The size cap is checked twice, before and during generation

Before building anything, the tool estimates how many numbers the range and step would produce and rejects the request up front if that estimate exceeds 100000. But the loop that actually builds the list checks the running count against that same cap on every iteration too, as a second, independent backstop, because an estimate computed from floating-point division can occasionally be slightly off for unusual step values, and a hard check inside the loop guarantees the browser can never be made to generate an unbounded list.

Zero-padding treats the minus sign correctly

When padding is on, the tool measures the digit width of the longest number in the list, ignoring the minus sign, then pads every entry digits to that width and re-attaches the sign afterward if it had one. That ordering matters: padding a negative number the naive way, by treating the whole string (including its leading minus) as something to left-pad with zeros, produces a malformed result like -007 where the zeros end up in the wrong place relative to the sign. Stripping the sign first, padding just the digits, and reapplying the sign after keeps a range like -5 to 15 formatted consistently as -05, -04 to 05, 15.