Las primeras letras, ¡muévete! fue muy popular, pero tuvo una participación limitada. Este será más fácil de resolver, pero espero que implique algunos trucos en el golf.

Se le da una cadena de solo letras minúsculas. Para cada letra, con posición en el alfabeto m , muévala para que se convierta en la letra m desde el final. Si el valor de m es más largo que la longitud de la cadena, muévalo al frente. Salida solo la cadena completamente transformada.

Ejemplos:

"jirafa"

• 'g' es la séptima letra del alfabeto, ya es la séptima letra del reverso, así que déjalo.
• 'i' es la novena letra, ya que 9 es más grande que la longitud de la palabra, va al frente, por lo que la cadena se convierte en igraffe
• 'r' es la letra 18, como 'i' va al frente: rigaffe
• 'a' es la primera letra, va hasta el final: rigffea
• 'f' es la sexta letra, se convierte en la sexta desde atrás: rfigfea
• la siguiente 'f' también es la sexta letra, por lo que también va a la sexta desde atrás: rffigea
• 'e' es la quinta letra, va a la quinta desde atrás: rfefiga

"flor"

• 'f' (6) => flower
• 'l' (12) => lfower
• 'o' (15) => olfwer
• 'w' (23) => wolfer
• 'e' (5) => weolfr
• 'r' (18) => rweolf

"piña"

• 'p' (16) => pineapple
• 'i' (9) => ipneapple
• 'n' (14) => nipeapple
• 'e' (5) => nipaepple
• 'a' (1) => nipepplea
• 'p' (16) => pnipeplea
• 'p' (16) => ppnipelea
• 'l' (12) => lppnipeea
• 'e' (5) => lppneipea(¡asegúrate de mover la e que aún no se ha movido! Aquí no importa, pero debajo sí).

Gracias a @Neil por mejorar los casos de prueba con estas 3 adiciones:

"Pizza"

• 'p' (16) => pizza
• 'i' (9) => ipzza
• 'z' (26) => zipza
• 'z' (26) => zzipa(moviendo la segunda z!)
• 'a' (1) => zzipa

"abracadabra"

• 'a' (1) => bracadabraa
• 'b' (2) => racadabraba
• 'r' (18) => racadabraba
• 'a' (1) => rcadabrabaa
• 'c' (3) => radabrabcaa
• 'a' (1) => rdabrabcaaa
• 'd' (4) => rabrabcdaaa
• 'a' (1) => rbrabcdaaaa
• 'b' (2) => rrabcdaaaba
• 'r' (18) => rrabcdaaaba
• 'a' (1) => rrbcdaaabaa

"caracteres"

• 'c' (3) => haractecrs
• 'h' (8) => arhactecrs
• 'a' (1) => rhactecrsa
• 'r' (18) => rhactecrsa
• 'a' (1) => rhctecrsaa
• 'c' (3) => rhtecrscaa
• 't' (20) => trhecrscaa
• 'e' (5) => trhcrescaa
• 'r' (18) => rtrhcescaa
• 's' (19) => srtrhcecaa

CJam, 41 38 bytes

lee_S+W%\{Xa-X1='`-/(Xa+\L*+}fX1>W%1f=

Pruébalo aquí.

Python 3, 78 bytes.

Guardado 2 bytes gracias a orlp.
Guardado 7 bytes gracias a DSM.

x=input()
y=[]
for z in x:m=max(len(x)-ord(z)+96,0);y[m:m]=z
print(''.join(y))

Construye la palabra como una lista y luego se une.

Python 2, 86 bytes

a=input();k=list(a)
for i in a:k.remove(i);k.insert(ord(i)-97,i)
print"".join(k)[::-1]

Python 3, 88 bytes

a=input();k=list(a)
for i in a:k.remove(i);k.insert(ord(i)-97,i)
print("".join(k)[::-1])

Ejemplos

Python 2:

$ python2 test.py
"flower"
rweolf

Python 3:

$ python3 test.py
flower
rweolf

Javascript ES6, 136 134 131 bytes

s=>([...s].map(c=>{s=s.replace(c,'');p=s.length+97-c.charCodeAt();s=s.substr(0,p)+c.toUpperCase()+s.substring(p)}),s.toLowerCase())

Tenga en cuenta que tengo mucho cuidado de no mover el mismo personaje dos veces, de lo contrario se pizzaconvierte en zipzacuando debería ser zzipa. También hay un caso límite que trata de no eliminar caracteres prematuramente; characterstal vez srtrchaeaco srtrheccaasi lo haces mal pero debería ser srtrhcecaa. Otra palabra difícil es abracadabrapara la que la salidarrabaaadcba sería incorrecta; rrbcdaaabaaSería correcto.

Editar: recortó dos bytes utilizando una subcadena que automáticamente coacciona sus argumentos al rango 0..length.

Editar: eliminó tres bytes cambiando la primera subcadena a substr como lo sugiere el usuario 81665.

Pyth, 18 17 bytes

uXeS,Z-lzhx;HGHzk

Test Suite .

Itera el uso de reducir sobre la cadena de entrada, insertando en una cadena, cadena vacía del caso base, en la posición correcta.

𝔼𝕊𝕄𝕚𝕟, 23 caracteres / 40 bytes

ᴉⓜΞăМƲ ïꝈ-ᶛą$,0),0,$;Ξ⨝

Try it here (Firefox only).

Explicación

ᴉⓜΞăМƲ ïꝈ-ᶛą$,0),0,$;Ξ⨝ // implicit: ï=input, ᴉ=input split into chars, Ξ=empty array, ᶛ=lowercase alphabet
ᴉⓜ                      // map over input chars
   ΞăМƲ ïꝈ-ᶛą$,0),0,$;   // use splice to insert map item into Ξ at requested index
                      Ξ⨝ // join Ξ
                         // implicit output