Istnieje dobrze znany biject między permutacjami n elementów i liczbami od 0 do n! -1, tak że porządek leksykograficzny permutacji i odpowiadających im liczb jest taki sam. Na przykład 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)

Dobrze wiadomo również, że permutacje n elementów tworzą grupę (symetryczna grupa rzędu n!) - w szczególności, że jedna permutacja n elementów zastosowana do drugiej permutacji n elementów daje permutację n elementów .

Na przykład (1, 0, 2) zastosowane do (a, b, c) daje (b, a, c), więc (1, 0, 2) zastosowane do (2, 1, 0) daje (1, 2) , 0).

Napisz program, który pobiera trzy argumenty całkowite: n, p1 i p2; interpretuje p1 i p2 jako permutacje n elementów; stosuje pierwszy do drugiego; i wyprowadza odpowiednią liczbę całkowitą. Na przykład:

$ ./perm.sh 3 2 5
3

J, 30

Podoba mi się elegancja tego:

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

albo to:

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

ale działają w ten sposób:

3 f 2 5
3
12 f 8 9
17

To jest poprawny wpis:

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

Kilka wyjaśnień:

• 3 A. 0 1 2: daje 3. permutację 0 1 2(= 1 2 0)
• 0 1 2 (A.)~ 3: jest taki sam, ale z odwróconymi argumentami
• 0 1 2 (A.)~/ 3 4 5 ...„odnosi się” (A.)~do 3 4 5 ..., więc to daje 3, 4, 5 ... permutacji 0 1 2.
• A. 1 2 0: podaje porządek permutacji 1 2 0(= 3)
• i. n: podaje sekwencję 0 1 2 ... n-1
• 1 2 0 { 0 2 1porządkuje 0 2 1według 1 2 0(= 2 1 0)

Ruby - 77 znaków

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

Python 2.6, 144 znaki

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))