About

Lexicographic permutation ranking assigns every arrangement of n distinct symbols a unique index k in the range [0, n! − 1]. The forward direction (sequence → index) is well-known. The reverse - recovering the original sequence from just the index and the dictionary - requires factoriadic decomposition, a procedure where a single arithmetic mistake silently produces a plausible but wrong permutation. This tool implements the exact inverse using arbitrary-precision integer arithmetic, so it handles dictionaries of any practical length without overflow. It assumes the dictionary defines the canonical sorted order; if your ranking used a different ordering, supply the characters in that exact order.

Note: the algorithm assumes all characters in the dictionary are distinct. Repeated characters create a multiset permutation problem with a different ranking formula involving multinomial coefficients. This tool does not handle that case - it validates uniqueness and rejects duplicates.

Formulas

Given a dictionary of n distinct symbols in canonical order and a zero-based index k, the original permutation is recovered by factoriadic (Lehmer code) decomposition:

k = n−1∑i=0 d_i ⋅ (n − 1 − i)!

Each factoriadic digit d_i is extracted iteratively:

d_i = k(n − 1 − i)! mod (n − i)

Then k is updated: k ← k mod (n − 1 − i)!

Equivalently, at step i, integer-divide k by (n − 1 − i)! to get the digit d_i, then take the remainder as the new k. The digit d_i is the zero-based index into the remaining available characters. Remove the selected character and proceed.

Where: k = zero-based permutation index, n = dictionary length, d_i = i-th factoriadic digit (Lehmer code element), (m)! = factorial of m.

Reference Data

Dictionary	Length n	Total Permutations n!	Index k	Resulting Sequence
abc	3	6	0	abc
abc	3	6	5	cba
0123456789	10	3628800	999999	2783915460
0123456789	10	3628800	0	0123456789
ABCD	4	24	14	CBAD
ABCD	4	24	23	DCBA
xyz	3	6	3	yxz
abcdef	6	720	719	fedcba
12345	5	120	60	31245
ACGT	4	24	6	CAGT
αβγδε	5	120	119	εδγβα
ABCDEFGHIJKLMNOPQRSTUVWXYZ	26	≈ 4.03 × 10²⁶	0	ABCDEFGHIJKLMNOPQRSTUVWXYZ

Frequently Asked Questions

The index k must satisfy 0 ≤ k < n!, where n is the number of characters in the dictionary. Index 0 always yields the dictionary in its original order (the lexicographically first permutation), and index n! − 1 yields the fully reversed dictionary (the lexicographically last permutation).

Yes. The algorithm treats the dictionary string as the canonical sorted order. If the original ranking was performed with characters sorted alphabetically (e.g., 'ABCD'), you must supply them in the same order. Supplying "DCBA" as the dictionary defines a different canonical order and will produce a different sequence for the same index.

JavaScript's Number type is a 64-bit IEEE 754 float, which loses integer precision beyond 2⁵³ (9007199254740992). Since 21! already exceeds this limit (51090942171709440000), any dictionary with more than 20 characters would produce incorrect results with standard arithmetic. BigInt provides arbitrary-precision integers.

The dictionary is interpreted as a sequence of Unicode code points (using the JS string iterator which handles surrogate pairs correctly). Each code point is one symbol. Multi-byte emoji and Greek letters work correctly. However, multi-character tokens like "AA" or "ab" as single symbols are not supported - each character is treated individually.

The tool rejects dictionaries with duplicate characters. Permutations of multisets (e.g., 'AABB') use a different ranking formula based on multinomial coefficients: n! ÷ (n₁! ⋅ n₂! ⋅ …). Applying the standard algorithm to duplicates would silently produce wrong results.

The factoriadic (factorial number system) represents any integer as a sum of multiples of factorials: k = d₁ ⋅ (n−1)! + d₂ ⋅ (n−2)! + … The sequence of digits d_i is precisely the Lehmer code of the permutation. Each digit tells you which element to pick from the remaining available symbols at that position.