Cho một chuỗi bạn phải di chuyển từng chữ cái (bắt đầu từ chữ cái đầu tiên) theo vị trí của nó trong bảng chữ cái. Nếu bạn đến cuối chuỗi, bạn phải quấn quanh. Không phải chữ cái không cần phải di chuyển.

Thí dụ:

Dog

Dlà chữ cái thứ tư trong bảng chữ cái để chúng ta di chuyển bốn điểm sang bên phải. Sau khi quấn quanh, điều đó thay đổi chuỗi thành oDg. olà chữ cái thứ 15, (15 mod 3) = 0, vì vậy nó không di chuyển. glà chữ cái thứ 7 - (7 mod 3) = 1, do đó chuỗi trở thành goD.

hi*bye

• hlà chữ cái thứ 8, di chuyển nó 8 điểm - hi*bye=>i*hbye
• ilà chữ cái thứ 9, di chuyển nó 9 điểm - i*hbye=>*hbiye
• blà chữ cái thứ 2, di chuyển nó 2 điểm - *hbiye=>*hiybe
• ylà chữ cái thứ 25, di chuyển nó 25 điểm - *hiybe=>*hibye
• elà chữ cái thứ 5, di chuyển nó 5 điểm - *hibye=>*hibey

Các chữ cái không cần phải di chuyển, nhưng chúng vẫn chiếm dung lượng.

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

CJam, 44 42 40 byte

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

Đầu ra chứa một linefeed trailing.

Kiểm tra nó ở đây.

Giải trình

Thay vì di chuyển các chữ cái qua chuỗi, tôi liên tục xóa một chữ cái, xoay chuỗi tương ứng và sau đó đặt lại chữ cái. Có một nhược điểm để làm điều này: chúng ta cần có khả năng phân biệt phần đầu của chuỗi với phần cuối của chuỗi (mà chúng ta không thể sau một vòng quay đơn giản). Đó là lý do tại sao chúng tôi chèn một nguồn cấp dữ liệu ở cuối như một người bảo vệ (chữ cái trước dòng cấp dữ liệu là phần cuối của chuỗi, chữ cái sau nó là phần đầu). Phần thưởng là điều này sẽ tự động trả về chuỗi cuối cùng cho phép xoay chính xác trong đó nguồn cấp thực sự nằm ở cuối chuỗi.

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.

Để xem tại sao điều này kết thúc ở đúng vị trí, hãy xem xét lần lặp cuối cùng của hi*byeví dụ. Sau khi chúng tôi xử lý e, chuỗi liệt kê ở vị trí này:

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

Đầu tiên, chúng tôi phân chia xung quanh nguồn cấp dữ liệu và nối các phần theo thứ tự ngược lại:

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

Nguồn cấp dữ liệu bây giờ sẽ ở đầu hoặc cuối chuỗi này. Nhưng vì linefeed chỉ là một người bảo vệ đánh dấu sự kết thúc của chuỗi, điều này có nghĩa là các ký tự thực sự theo đúng thứ tự. Bây giờ linefeed không phải là một chữ cái, do đó, mảng không được xoay vòng. Do đó, khi chúng tôi nối thêm nguồn cấp dữ liệu, nó sẽ đi đến nơi nó thuộc về và mọi thứ theo thứ tự chúng tôi đang tìm kiếm:

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

Một số kết quả bổ sung nếu ai đó muốn so sánh các trường hợp thử nghiệm dài hơ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

Tôi thích cái cuối cùng :)

Ruby 125 130 132 139 byte

->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*''}

Bản demo trực tuyến với các bài kiểm tra: http://ideone.com/GYJm2u

Bản gốc (phiên bản chưa được chỉnh sửa): http://ideone.com/gTNvWY

Chỉnh sửa: Cảm ơn rất nhiều vì manatwork cho đề xuất của mình!

Chỉnh sửa 2 : số lượng ký tự cố định (ban đầu tôi đang đếm các kết thúc dòng CRLF.)

Python 3, 278 275 273 270 260 258 249 248 243 238 byte

Tôi thực sự nên chơi golf này tốt hơn, nhưng đây là giải pháp của tôi, cảm ơn katenkyo vì sự giúp đỡ của anh ấy với logic, và Cyoce và Mego vì sự giúp đỡ của họ với việc chơi golf.

Chỉnh sửa: Cuối cùng, tôi đã đưa nó xuống một tuyên bố so sánh. Ôi! (Và vâng, tôi có thể chuyển nó z=-zthành a,m=m,abit, nhưng điều đó không lưu byte và nó làm rối mã nhiều hơn tôi nghĩ là cần thiết)

Chỉnh sửa: Số lượng byte đã tắt.

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

Ung dung:

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