Es gibt einen bekannten Unterschied zwischen den Permutationen von n Elementen und den Zahlen 0 bis n! -1, so dass die lexikografische Reihenfolge der Permutationen und der entsprechenden Zahlen gleich ist. Zum Beispiel mit n = 3:

0 <-> (0, 1, 2)
1 <-> (0, 2, 1)
2 <-> (1, 0, 2)
3 <-> (1, 2, 0)
4 <-> (2, 0, 1)
5 <-> (2, 1, 0)

Es ist auch bekannt, dass die Permutationen von n Elementen eine Gruppe bilden (die symmetrische Gruppe der Ordnung n!), So dass insbesondere eine Permutation von n Elementen, die auf eine zweite Permutation von n Elementen angewendet wird, eine Permutation von n Elementen ergibt .

Zum Beispiel ergibt (1, 0, 2), angewendet auf (a, b, c), (b, a, c), so dass (1, 0, 2), angewendet auf (2, 1, 0), (1, 2) ergibt , 0).

Schreiben Sie ein Programm, das drei ganzzahlige Argumente akzeptiert: n, p1 und p2; interpretiert p1 und p2 als Permutationen von n Elementen; wendet das erste auf das zweite an; und gibt die entsprechende ganze Zahl aus. Beispielsweise:

$ ./perm.sh 3 2 5
3

J, 30

Ich mag die Eleganz davon:

[:A.[:{/]A.~/~i.@[

oder dieses:

13 :'A.{/(i.x)(A.)~/y'

aber sie arbeiten so:

3 f 2 5
3
12 f 8 9
17

Das ist also der gültige Eintrag:

([:A.[:{/i.@{.A.~/}.)".}.>ARGV

Einige Erklärungen:

• 3 A. 0 1 2: gibt die 3. Permutation von 0 1 2(= 1 2 0) an
• 0 1 2 (A.)~ 3: ist das gleiche, aber mit umgekehrten Argumenten
• 0 1 2 (A.)~/ 3 4 5 ...„gilt“ (A.)~zu 3 4 5 ..., so dass es die dritte gibt, 4., 5., ... Permutation 0 1 2.
• A. 1 2 0: gibt die Reihenfolge der Permutation von 1 2 0(= 3) an
• i. n: gibt die Reihenfolge an 0 1 2 ... n-1
• 1 2 0 { 0 2 1arrangiert 0 2 1von 1 2 0(= 2 1 0)

Ruby - 77 Zeichen

n,a,b=$*.map &:to_i
l=[*[*0...n].permutation]
p l.index(l[b].values_at *l[a])

Python 2.6, 144 Zeichen

import sys
from itertools import*
n,p,q=map(int,sys.argv[1:])
R=range(n)
P=list(permutations(R))
print P.index(tuple(P[q][P[p][i]] for i in R))