Le prime lettere, muoviti! era molto popolare, ma aveva una partecipazione limitata. Questo sarà più facile da risolvere, ma si spera coinvolga alcuni trucchi nel golf.

Ti viene data una stringa di sole lettere minuscole. Per ogni lettera, con la posizione nell'alfabeto m , spostala in modo che diventi la m lettera dalla fine. Se il valore di m è più lungo della lunghezza della stringa, spostalo in primo piano. Emette solo la stringa completamente trasformata.

Esempi:

"giraffa"

• 'g' è la settima lettera dell'alfabeto, è già la settima lettera dal retro, quindi lasciala.
• 'i' è la nona lettera, poiché 9 è più grande della lunghezza della parola, va in primo piano, quindi la stringa diventa igraffe
• 'r' è la 18a lettera, come 'i' va in primo piano: rigaffe
• 'a' è la prima lettera, arriva fino alla fine: rigffea
• 'f' è la sesta lettera, diventa la sesta da dietro: rfigfea
• la 'f' successiva è anche la sesta lettera, quindi va anche al sesto da dietro: rffigea
• 'e' è la 5a lettera, va in 5a dalla parte posteriore: rfefiga

"fiore"

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

"ananas"

• '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(assicurati di spostare la e che non è stata già spostata! Qui non importa, ma sotto lo fa.)

Grazie a @Neil per migliorare i casi di test con queste 3 aggiunte:

"Pizza"

• 'p' (16) => pizza
• 'i' (9) => ipzza
• 'z' (26) => zipza
• 'z' (26) => zzipa(spostando la seconda 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

"personaggi"

• '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 byte

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

Provalo qui.

Python 3, 78 byte.

Salvato 2 byte grazie a orlp.
Salvataggio di 7 byte grazie a DSM.

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

Costruisce la parola come un elenco, quindi la unisce.

Python 2, 86 byte

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 byte

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

Esempi

Python 2:

$ python2 test.py
"flower"
rweolf

Python 3:

$ python3 test.py
flower
rweolf

Javascript ES6, 136 134 131 byte

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

Nota che faccio molta attenzione a non spostare lo stesso personaggio due volte, altrimenti pizzasi trasforma in zipzaquando dovrebbe essere zzipa. C'è anche un caso limite relativo alla non rimozione prematura dei personaggi; charactersdiventa forse srtrchaeaco srtrheccaase lo fai in modo errato, ma dovrebbe essere srtrhcecaa. Un'altra parola complicata è abracadabraper la quale l'output rrabaaadcbasarebbe errato; rrbcdaaabaasarebbe corretto.

Modifica: rasato due byte usando la sottostringa che costringe automaticamente i suoi argomenti all'intervallo 0..lunghezza.

Modifica: eliminazione di tre byte modificando la prima sottostringa in substr come suggerito dall'utente81665.

Pyth, 18 17 byte

uXeS,Z-lzhx;HGHzk

Test Suite .

Itera usando riduci sulla stringa di input, inserendola in una stringa, stringa vuota della custodia di base, nella posizione corretta.

𝔼𝕊𝕄𝕚𝕟, 23 caratteri / 40 byte

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

Try it here (Firefox only).

Spiegazione

ᴉⓜΞăМƲ ïꝈ-ᶛą$,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