Desoriente: recordar una permutación y deshacerla

Question

Supongamos que tengo una función f que toma un vector v y devuelve un nuevo vector con los elementos transformados de alguna manera. Lo hace llamando a la función g que supone que el vector está ordenado. Así que quiero f para definirse así:

f[v_] := Module[{s, r}, 
    s = Sort[v]; (* remember the permutation applied in order to sort v *) 
    r = g[s]; 
    Unsort[r]  (* apply the inverse of that permutation *) 
] 

¿Cuál es la mejor manera de hacer el "Desordenar"?

O podríamos obtener realmente de lujo y tienen esto de alguna manera funciona:

answer = Unsort[g[Sort[v]]]; 

añadido: Vamos a hacer este hormigón con un ejemplo de juguete. Supongamos que queremos una función f que toma un vector y lo transforma añadiendo a cada elemento el siguiente elemento más pequeño, si lo hay. Eso es fácil escribir si asumimos el vector está ordenada, por lo que vamos a escribir una función auxiliar g que hace que esa suposición:

g[v_] := v + Prepend[Most@v, 0] 

Ahora para la función que realmente queremos, f, que funciona o no v se ordena :

f[v_] := (* remember the order; 
      sort it; 
      call g on it; 
      put it back in the original order; 
      return it 
     *) 

Answer 1

gracias a Tomd y Yaroslav, aquí es probablemente la forma más concisa/elegante de hacerlo:

f[v_] := g[Sort@v][[Ordering@Ordering@v]] 

y gracias a Janus, aquí hay un quizás más effic ient manera:

f[v_] := With[{o = Ordering@v}, g[v[[o]]][[Ordering@o]]] 

Tenga en cuenta que lo hace 2 tipos en lugar de 3.

Para la posteridad, aquí está mi intento original, aunque no creo que tenga nada que recomendaría a los anteriores:

f[v_] := With[{o = Ordering[v]}, Sort[Transpose[{o,g[v[[o]]]}]][[All,-1]]] 

Para abordar belisarius en los comentarios, la razón por la que no paso g como parámetro es porque estoy pensando en g como una función auxiliar para f. Es como si tuviera una función f que sería más fácil de escribir si pudiera asumir que su argumento era un vector ordenado. Así que escribo la versión que asume eso y luego hago este truco de envoltura.

Answer 2

Un posible método:

mylist = {c, 1, a, b, 2, 4, h, \[Pi]} 
    g /@ (Sort@mylist)[[Ordering@Ordering@mylist]] 

da

{g [c], g 1, g [a], g [b], g [2], g [4], g [h], g [[Pi]]}

Esto es,

(Sort@mylist)[[Ordering@Ordering@mylist]] == mylist 

originalmente supe de la arriba del grupo matemático, [Editado] a partir de un mensaje por Andrzej Kozlowsk i

http://forums.wolfram.com/mathgroup/archive/2007/Jun/msg00920.html

Answer 3

Aquí hay un patrón "de clasificación envoltorio" suggested por Michael Pilat anterior

Clear[g]; 
g[a_] := If[OrderedQ[a], a^2, Print["Failed"]]; 
g[{3, 2, 1}] 
g[a_] := g[Sort@a][[Ordering@Ordering@a]] /; Not[OrderedQ[a]]; 
g[{3, 2, 1}]