Esiste una ben nota biiezione tra le permutazioni di n elementi e i numeri da 0 a n! -1 tale che l'ordinamento lessicografico delle permutazioni e dei numeri corrispondenti è lo stesso. Ad esempio, con 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)

È anche noto che le permutazioni di n elementi formano un gruppo (il gruppo simmetrico dell'ordine n!) - quindi, in particolare, che una permutazione di n elementi applicata a una seconda permutazione di n elementi produce una permutazione di n elementi .

Ad esempio, (1, 0, 2) applicato a (a, b, c) rese (b, a, c), quindi (1, 0, 2) applicato a (2, 1, 0) rese (1, 2 , 0).

Scrivi un programma che accetta tre argomenti interi: n, p1 e p2; interpreta p1 e p2 come permutazioni di n elementi; applica il primo al secondo; e restituisce il numero intero corrispondente. Per esempio:

$ ./perm.sh 3 2 5
3

J, 30

Mi piace l'eleganza di questo:

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

o questo:

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

ma funzionano così:

3 f 2 5
3
12 f 8 9
17

Quindi questa è la voce valida:

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

Alcune spiegazioni:

• 3 A. 0 1 2: dà la 3a permutazione di 0 1 2(=1 2 0 )
• 0 1 2 (A.)~ 3: è lo stesso ma con argomenti invertiti
• 0 1 2 (A.)~/ 3 4 5 ..."applica" (A.)~a 3 4 5 ..., quindi dà la 3a, 4a, 5a, ... permutazione di0 1 2 .
• A. 1 2 0: dà l'ordine della permutazione di 1 2 0 (= 3)
• i. n: dà la sequenza 0 1 2 ... n-1
• 1 2 0 { 0 2 1organizza 0 2 1per 1 2 0(= 2 1 0)

Rubino - 77 caratteri

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

Python 2.6, 144 caratteri

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