Il existe une bijection bien connue entre les permutations de n éléments et les nombres de 0 à n! -1 de sorte que l'ordre lexicographique des permutations et des nombres correspondants est le même. Par exemple, avec 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)

Il est également bien connu que les permutations de n éléments forment un groupe (le groupe symétrique d'ordre n!) - de sorte, en particulier, qu'une permutation de n éléments appliquée à une seconde permutation de n éléments donne une permutation de n éléments .

Par exemple, (1, 0, 2) appliqué aux rendements (a, b, c) (b, a, c), donc (1, 0, 2) appliqué aux rendements (2, 1, 0) (1, 2 , 0).

Écrivez un programme qui prend trois arguments entiers: n, p1 et p2; interprète p1 et p2 comme permutations de n éléments; applique le premier au second; et sort l'entier correspondant. Par exemple:

$ ./perm.sh 3 2 5
3

J, 30

J'aime l'élégance de ceci:

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

ou ca:

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

mais ils fonctionnent comme ceci:

3 f 2 5
3
12 f 8 9
17

Voici donc l'entrée valide:

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

Quelques explications:

• 3 A. 0 1 2: donne la 3ème permutation de 0 1 2(= 1 2 0)
• 0 1 2 (A.)~ 3: est le même mais avec des arguments inversés
• 0 1 2 (A.)~/ 3 4 5 ..."s'applique" (A.)~à 3 4 5 ..., donc il donne la 3ème, 4ème, 5ème, ... permutation de 0 1 2.
• A. 1 2 0: donne l'ordre de la permutation de 1 2 0(= 3)
• i. n: donne la séquence 0 1 2 ... n-1
• 1 2 0 { 0 2 1organise 0 2 1par 1 2 0(= 2 1 0)

Rubis - 77 caractères

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

Python 2.6, 144 caractères

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