Для данной строки вы должны переместить каждую букву (начиная с первой буквы) по ее позиции в алфавите. Если вы достигнете конца строки, вы должны обернуть вокруг. Номера буквы не должны быть перемещены.

Пример:

Dog

Dэто четвертая буква в алфавите, поэтому мы переместим ее на четыре точки вправо. После переноса это меняет строку на oDg. oэто 15-я буква, (15 mod 3) = 0, поэтому она не двигается. g7-ая буква - (7 mod 3) = 1, поэтому строка становится goD.

hi*bye

• hэто 8-я буква, переместите ее на 8 позиций - hi*bye=>i*hbye
• iэто 9-я буква, переместите ее на 9 позиций - i*hbye=>*hbiye
• b2-я буква, переместите ее на 2 точки - *hbiye=>*hiybe
• yэто 25-я буква, переместите ее на 25 позиций - *hiybe=>*hibye
• eэто 5-я буква, переместите ее на 5 позиций - *hibye=>*hibey

Не буквы должны быть перемещены, но они все еще занимают место.

• cat => tca
• F.U.N => .F.NU
• mississippi => msiisppssii

CJam, 44 42 40 байт

qN+ee_{Xa/~\+XW=eu__el=!\'@-*m<Xa+}fXWf=

Вывод содержит завершающий перевод строки.

Проверьте это здесь.

объяснение

Вместо того, чтобы перемещать буквы по строке, я несколько раз удаляю буквы, поворачиваю строку соответственно, а затем снова вставляю буквы. Для этого есть одна загвоздка: нам нужно уметь отличать начало строки от конца строки (что мы не можем сделать после простого поворота). Вот почему мы вставляем перевод строки в конец как защитный символ (буква перед переводом строки является концом строки, буква после ее начала). Бонус в том, что это автоматически возвращает окончательную строку в правильное вращение, где перевод строки фактически находится в конце строки.

lN+     e# Read input and append a linefeed.
ee      e# Enumerate the array, so input "bob" would become [[0 'b] [1 'o] [2 'b] [3 N]]
        e# This is so that we can distinguish repeated occurrences of one letter.
_{      e# Duplicate. Then for each element X in the copy...
  Xa/   e# Split the enumerated string around X.
  ~     e# Dump the two halves onto the stack.
  \+    e# Concatenate them in reverse order. This is equivalent to rotating the current
        e# character to the front and then removing it.
  XW=   e# Get the character from X.
  eu    e# Convert to upper case.
  _     e# Duplicate.
  _el=! e# Check that convert to lower case changes the character (to ensure we have a
        e# letter).
  \'@-  e# Swap with the other upper-case copy and subtract '@, turning letters into 1 to
        e# 26 (and everything else into junk).
  *     e# Multiply with whether it's a letter or not to turn said junk into 0 (that means
        e# everything which is not a letter will be moved by 0 places).
  m<    e# Rotate the string to the left that many times.
  Xa+   e# Append X to the rotated string.
}fX
Wf=     e# Extract the character from each pair in the enumerated array.

Чтобы понять, почему это оказывается в правильном положении, рассмотрим последнюю итерацию hi*byeпримера. После того как мы обработали e, перечисляемая строка находится в этой позиции:

[[4 'y] [6 N] [2 '*] [0 'h] [1 'i] [3 'b] [5 'e]]

Сначала мы разбиваем строку и объединяем части в обратном порядке:

[[2 '*] [0 'h] [1 'i] [3 'b] [5 'e] [4 'y]]

Теперь перевод строки будет либо в начале, либо в конце этой строки. Но так как перевод строки является просто защитой, которая отмечает конец строки, это означает, что символы на самом деле в правильном порядке. Теперь перевод строки не является буквой, поэтому массив вообще не вращается. Таким образом, когда мы добавляем перевод строки, он идет туда, где он принадлежит, и все в том порядке, в котором мы ищем:

[[2 '*] [0 'h] [1 'i] [3 'b] [5 'e] [4 'y] [6 N]]

Некоторые дополнительные результаты, если кто-то хочет сравнить более длинные тестовые случаи:

Hello, World!
,W oeHlo!lrld

Programming Puzzles & Code Golf
ago fgliPomomnrr elP& uC dezzsG

The quick brown fox jumps over the lazy dog
t eg chbi ko qfTounyzrj omw epx ueoahs rlvd

abcdefghijklmnopqrstuvwxyz
aqbrcdsetfguhivjwklxmnyozp

zyxwvutsrqponmlkjihgfedcba
abcdefghijklmnopqrstuvwxyz

Мне нравится этот последний. :)

Рубин 125 130 132 139 байт

->q{a=q.chars.map{|c|[c,c=~/[a-z]/i&&c.ord%32]}
while i=a.index{|c,s|s}
c,s=a.delete_at i
a.insert (i+s)%q.size,[c]
end
a*''}

Демоверсия онлайн с тестами: http://ideone.com/GYJm2u

Начальная (версия без игры): http://ideone.com/gTNvWY

Редактировать: Большое спасибо Manatwork за его предложения!

Редактировать 2 : исправлено количество символов (я изначально считал окончания строки CRLF)

Python 3, 278 275 273 270 260 258 249 248 243 238 байт

Я должен действительно гольф это вниз лучше, но вот мое решение, с благодарностью katenkyo за помощь с логикой и Cyoce и Mego за помощь с игрой в гольф.

Изменить: Наконец, я получил это в одном утверждении сравнения. WOO! (И да, я мог бы переместить это z=-zв a,m=m,aбит, но это не спасет байты, и это запутало код больше, чем я думал, было необходимо)

Изменить: Счетчик байтов был выключен.

def m(s):
 l=len(s);r=range(l);p=[[i,s[i]]for i in r]
 for i in r:
  if s[i].isalpha():
   a=p[i][0];p[i][0]=m=(a+ord(s[i])%32)%l;z=1
   if a>m:a,m=m,a;z=-z
   for j in r:p[j][0]-=z*(j!=i)*(a<=p[j][0]<=m) 
 return''.join(dict(p).values())

Ungolfed:

def move(string):
 length = len(string)
 places = [[i,string[i]]for i in range(length)]
 for index in range(length):
  char = string[index]
  if char.isalpha():
   a = places[index][0]
   mov = (a + ord(char)%32) % length
   places[index][0] = mov
   for j in range(length):
    k = places[j][0]
    if a <= k <= mov and j!=index:
     places[j][0]-=1
    elif mov <= k <= a and j != index:
     places[j][0]+=1
 return''.join(dict(places).values())