User Rating 0.0 ★★★★★

Total Usage 0 times

Category Math & Algebra

Dictionary (space-separated, ordered) Order defines lexicographic baseline. Each token is one symbol.

Sequence (space-separated) Must contain every dictionary symbol exactly once.

Is this tool helpful?

Your feedback helps us improve.

★ ★ ★ ★ ★

About

Lexicographic ordering assigns a unique rank to every permutation of a finite set. The rank is computed via the Lehmer code, which encodes positional displacement against remaining unused symbols. For a permutation of n distinct elements, there exist n! total arrangements. Miscounting a single position cascades through every subsequent factorial weight, producing an entirely wrong index. This tool computes both directions: sequence → index (0-based) and index → sequence, using arbitrary-precision BigInt arithmetic so it handles dictionaries well beyond 20 symbols where 20! ≈ 2.43 × 10¹⁸ exceeds standard floating-point range.

The tool assumes all characters in the input sequence are distinct members of the supplied dictionary. Repeated characters violate the permutation constraint and are rejected. Dictionary order defines the lexicographic baseline. Changing the dictionary order changes the rank. Pro tip: for numeric systems (base-n positional), supply digits in ascending order as your dictionary.

Formulas

The lexicographic rank of a permutation σ over n distinct symbols is computed via the Lehmer code:

rank = n−1∑i=0 L_i ⋅ (n − 1 − i)!

where L_i is the number of symbols in the remaining (unused) set that are lexicographically smaller than σ_i. The inverse operation recovers the permutation from an index:

L_i = r(n − 1 − i)! , r ← r mod (n − 1 − i)!

where r is the running remainder initialized to the target index. At each step, the L_i-th smallest remaining symbol is selected and removed from the available set.

Where: σ = input permutation, n = dictionary size (number of distinct symbols), L_i = Lehmer code digit at position i, r = remainder during index decomposition, i = position index from 0 to n−1.

Reference Data

Dictionary Size n	Total Permutations n!	Bits Required	Digits in Index	Example Dictionary
3	6	3	1	A B C
4	24	5	2	1 2 3 4
5	120	7	3	a b c d e
6	720	10	3	0 1 2 3 4 5
8	40,320	16	5	A B C D E F G H
10	3,628,800	22	7	0 1 2 3 4 5 6 7 8 9
12	479,001,600	29	9	A B C D E F G H I J K L
15	1,307,674,368,000	41	13	a b c d e f g h i j k l m n o
18	6,402,373,705,728,000	53	16	A through R
20	2,432,902,008,176,640,000	61	19	a through t
26	≈ 4.03 × 10²⁶	89	27	A through Z (full alphabet)
30	≈ 2.65 × 10³²	108	33	Custom 30-symbol set
36	≈ 3.72 × 10⁴¹	138	42	0-9 + A-Z (alphanumeric)

Frequently Asked Questions

In combinatorics, the first permutation in lexicographic order (the identity permutation matching dictionary order) has rank 0. The last permutation has rank n! − 1. This is consistent with the factorial number system where the all-zeros Lehmer code maps to rank 0. If you need 1-based indexing, simply add 1 to the output.

The tool rejects the input and displays an error toast identifying the invalid character(s). Every symbol in the sequence must exist exactly once in the dictionary. The Lehmer code algorithm requires a well-defined ordering over a known finite set - unknown symbols have no position and break the computation.

Yes. Separate dictionary entries with spaces. Each space-delimited token is treated as a single atomic symbol. For example, a dictionary of "01 02 03 04" defines four two-character symbols. Your input sequence must then use the same tokens separated by spaces.

The tool uses JavaScript BigInt for all factorial and rank arithmetic, so there is no upper overflow limit - it handles arbitrarily large dictionaries. However, the Lehmer code computation is O(n²) in the dictionary size n, so dictionaries beyond roughly 10,000 symbols may cause noticeable delay. For typical use (n ≤ 100), computation is instantaneous.

Absolutely. The rank is defined relative to the dictionary's ordering. If your dictionary is "B A C", then "B A C" is rank 0 (not 'A B C'). The tool uses the exact left-to-right order you provide. Rearranging the dictionary reassigns every permutation's rank. This is by design - lexicographic order is always relative to the underlying alphabet ordering.

This tool computes full permutations only - the input sequence must use every dictionary symbol exactly once. For k-permutations (arrangements of k items from n), the formula changes to n!/(n−k)! total arrangements with a modified Lehmer code. That is a different combinatorial object not covered here.