Arrangements

Ordered selections of $k$ distinct elements from $\{1, …, n\}$ — the $k$-permutations of $n$.

OEISA000522↗A008279↗Wolfram LanguageFactorialPower↗SageMathPermutations(n,k) [= Arrangements([1..n], k)]↗SymPyvariations↗mathlib4Nat.descFactorial↗

Arrangements(n, k)Ordered selections of $k$ distinct elements from $\{1, …, n\}$ — the $k$-permutations of $n$

Typed signatures

Type	Package	Applies
(integer<0..>, integer<0..>) -> indexed_collection<arrangement>	combinatorics	always

Domain: Collections

Details

• Count is the falling factorial $n^{\underline{k}} = n!/(n-k)!$.
• Each element is a length-$k$ one-line word with distinct entries from $\{1, …, n\}$.

Definition

Epsil, as the implementation runs it.

count(_n, _k)

Fold(Function(product * f, product, f), 1, Range(_n - _k + 1, _n, 1)) if _k <=
                                                                         _n else 0

unrank(_n, _k, _r)

Map(Function(Fold(
                   Function(v + 1 if v >= (_r - _r % Fold(
                                                           Function(
                                                                     product * f,
                                                                     product,
                                                                     f,
                                                                   ),
                                                           1,
                                                           Range(
                                                                  _n - i - (_k -
                                                                            i) +
                                                                  1,
                                                                  _n - i,
                                                                  1,
                                                                ),
                                                         )) / Fold(
                                                                   Function(
                                                                             product *
                                                                             f,
                                                                             product,
                                                                             f,
                                                                           ),
                                                                   1,
                                                                   Range(
                                                                          _n - i -
                                                                          (_k -
                                                                           i) + 1,
                                                                          _n - i,
                                                                          1,
                                                                        ),
                                                                 ) % (_n - i + 1) +
                                          1 else v, v, i),
                   (_r - _r % Fold(
                                    Function(product * f, product, f),
                                    1,
                                    Range(_n - j - (_k - j) + 1, _n - j, 1),
                                  )) / Fold(
                                            Function(product * f, product, f),
                                            1,
                                            Range(
                                                   _n - j - (_k - j) + 1,
                                                   _n - j,
                                                   1,
                                                 ),
                                          ) % (_n - j + 1) + 1,
                   Range(j - 1, 1, -1),
                 ), j), Range(1, _k, 1))

rank(_n, _k, _x)

Fold(
      Function(
                r * (_n - j + 1) + (_x[j] - 1 - Fold(
                                                      Function(c +
                                                               (1 if _x[i] <
                                                                     _x[j] else 0), c, i),
                                                      0,
                                                      Range(1, j - 1, 1),
                                                    )),
                r,
                j,
              ),
      0,
      Range(1, _k, 1),
    )

valid(_n, _k, _x)

Fold(Function(
               (ReplaceAt(di_seen, _x[di_j], 1) if di_seen[_x[di_j]] == 0 else ReplaceAt(
                                                                                          di_seen,
                                                                                          _n + 1,
                                                                                          1,
                                                                                        )) if 1 <= _x[di_j] &&
                                                                                             _x[di_j] <= _n else ReplaceAt(di_seen, _n + 1, 1),
               di_seen,
               di_j,
             ), Map(Function(0, di_z), Range(1, _n + 1, 1)), Range(1, _k, 1))[_n +
                                                                             1] ==
0 if Length(_x) == _k else False

Enumeration

Examples

1 more kept as data, checked against the oracles

Basic #

$Count(Arrangements(4, 2)) = 12$

live ↗

In$\mathrm{Count}(\mathrm{Arrangements}(4, 2))$Out$12$

The first element in enumeration order

live ↗

In$\mathrm{Arrangements}(4, 2)[1]$Out${\operatorname{Arrangement}}([1, 2])$

About

Examples	3
Crosswalk	OEIS ×2Wolfram LanguageSageMathSymPymathlib4

See also: SymmetricGroup, Subsets, Binomial