Thách thức ở đây là lấy một chuỗi và xuất ra tất cả các phép quay của nó, bằng cách liên tục di chuyển ký tự đầu tiên đến cuối, một lần cho mỗi ký tự trong chuỗi, kết thúc bằng chuỗi gốc:

john -> ohnj, hnjo, njoh, john

Bạn cũng có thể quay vòng theo hướng khác, di chuyển các ký tự từ cuối:

john -> njoh, hnjo, ohnj, john

Bạn vẫn nên xuất một vòng quay cho mỗi chữ cái ngay cả khi đạt được từ gốc trước đó:

heehee -> eeheeh, eheehe, heehee, eeheeh, eheehe, heehee

Mảng ký tự được cho phép, miễn là kết quả hoạt động như hình trên.

Câu trả lời ngắn nhất sẽ thắng!

Thạch , 2 byte

ṙJ

Liên kết đơn âm chấp nhận danh sách các ký tự mang lại danh sách các danh sách các ký tự

Hãy thử trực tuyến! (chân trang in đẹp bằng cách gọi liên kết và tham gia với các ký tự dòng mới)

Haskell, 27 byte

scanl(\(a:b)_->b++[a])=<<id

Hãy thử trực tuyến!

APL (Dyalog Unicode) , 6 byte ^SBCS

⍳∘≢⌽¨⊂

Hãy thử trực tuyến!

⍳ các chỉ số

∘ của

≢ kiểm đếm

⌽¨ mỗi vòng quay (sang trái)

⊂ toàn bộ chuỗi

Python 2 , 38 byte

s=input()
for c in s:s=s[1:]+c;print s

Hãy thử trực tuyến!

JavaScript (ES6), 37 32 byte

Trả về một chuỗi các chuỗi.

s=>[...s].map(c=>s=s.slice(1)+c)

Hãy thử trực tuyến!

Japt, 5 3 byte

Lấy đầu vào là một mảng ký tự, xuất ra một mảng các mảng ký tự

£=é

Hãy thử nó ở đây

£=é     :Implicit input of character array U
£       :Map
  é     :  Rotate U one element to the right
 =      :  Reassign to U for next iteration

05AB1E , 3 byte

ā._

Hãy thử trực tuyến!

Brainfuck , 59 byte

,[>,]<[>>[>]+[<]<[<]>-[[>]>[>]<+[<]<[<]>-]>[.>]>[.>]<[<].<]

Hãy thử trực tuyến!

Đầu ra mỗi chuỗi được phân tách bằng byte rỗng.

Giải trình:

,[>,]    # Get input
<[       # Start loop over input
  >>[>]       # Go to end of the string
  +           # Set it to one to mark it
  [<]<[<]>    # Move to the beginning of input
  -[[>]>[>]<+[<]<[<]>-]   # Transfer the first character to the end
  >[.>]>[.>]  # Print the rotated string
  <[<].       # Print a nul byte
<]       # Repeat loop while input

MATL , 6 5 byte

tf&+)

Lưu 1 byte nhờ @luis!

Hãy thử nó tại MATL Online !

Giải thích :

    # Implicitly grab input string
t   # Duplicate the input
f   # Create an array [1, ..., N] where N is the number of characters in the input
&+  # Add the transpose of this array to itself to create a 2D array of indices
    #
    #   +   1  2  3  4
    #       ----------
    #   1 | 2  3  4  5
    #   2 | 3  4  5  6
    #   3 | 4  5  6  7
    #   4 | 5  6  7  8
    #
)   # Use this 2D array to index into the original string using periodic indexing
    # Implicitly display the resulting character array

Ngôn ngữ Wolfram (Mathicala) , 35 26 byte

Partition[#,Tr[1^#],1,-1]&

Hãy thử trực tuyến!

Đưa ra một danh sách các ký tự làm đầu vào.

Partition(nhưng không phải là biến thể StringPartitionđược sử dụng bên dưới) có một đối số thứ tư tùy chọn để coi đầu vào của nó là tuần hoàn (và để xác định chính xác cách thực hiện), điều này làm cho giải pháp này đơn giản hơn chuỗi một - ngoài việc không có bất kỳ ký tự 15 ký tự nào -in chức năng.

Ngôn ngữ Wolfram (Mathicala) , 44 byte

Rest@StringPartition[#<>#,StringLength@#,1]&

Hãy thử trực tuyến!

Tương tự, nhưng lấy một chuỗi làm đầu vào.

Biến "john"thành "johnjohn", sau đó lấy tất cả các StringLength["john"]chuỗi con của chuỗi này với offset 1, tạo ra {"john","ohnj","hnjo","njoh","john"}, sau đó bỏ đầu tiên của chuỗi này với Rest.

Tùy viên , 13 byte

Rotate#{1:#_}

Hãy thử trực tuyến!

Giải trình

Rotate#{1:#_}
      #          fork(f, g) = ${ f[x, g[x]] }; this forks:
Rotate               rotate's the input by
       {1:#_}        each number from 1 to the length of the input

Lựa chọn thay thế

15 byte :{_&Rotate!1:#_}

16 byte :{Rotate[_,1:#_]}

16 byte :Rotate@Rotations

16 byte :Rotate#(1&`:@`#)

17 byte :Rotate#{1+Iota@_}

18 byte :Rotate#(1&`+@Iota)

19 byte :Rotate#(Succ=>Iota)

J , 7 byte

#\|."{]

Hãy thử trực tuyến!

Giải trình:

  |."{    - rotate ( "{ is short for "0 1 - rank 0 1 ) 
      ]   - the input
#\        - lenght of the successive prefixes of the input 

R , 58 byte

function(s,`[`=substring)paste0(s[n<-nchar(s):1],s[1,n-1])

Hãy thử trực tuyến!

C # (Trình biên dịch tương tác Visual C #) , 34 byte

x=>x.Select(c=>x=x.Substring(1)+c)

Hãy thử trực tuyến!

C (32-bit), 58 51 50 byte

-1 byte cho số tròn đẹp nhờ trần

i;f(s){for(i=0;i++<printf("%s%.*s\n",s+i,i,s)-2;);}

Hãy thử trực tuyến!

Thuốc khử trùng

i;           // "Global" i.
f(s){   // s is pointer to string, which conveniently fits in a 32 bit integer.
    for(i=0; // Initialize i.
        // Increment i and take its complement, and add it to the
        // return value of printf(); which just happens to be strlen(s)+1.
        // ~i + strlen(s) + 1 == strlen(s) + 1 - i - 1, so the last printed
        // string is the original string.
        ~++i + printf("%s%.*s\n",s+i,i,s);
        // The printf prints two strings: first until the terminating \0,
        // the second until a \0 or until i chars have been printed. It also
        // prints a linefeed.
}

Than , 10 byte

⮌Ｅθ⭆θ§θ⁻μκ

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

  θ         Input string
 Ｅ         Map over characters
    θ       Input string
   ⭆        Map over characters and join
      θ     Input string
     §      Circularly indexed by
       ⁻    Difference between
        μ   Inner index
         κ  Outer index
⮌           Reversed
            Implicitly print each string on its own line

Để xoay theo hướng ngược lại, thay thế Minusbằng Plus.

Màu đỏ , 49 43 byte

func[s][forall s[print move head s tail s]]

Hãy thử trực tuyến!

Python 2 , 54 48 byte

lambda i:[i[x:]+i[:x]for x in range(1,len(i)+1)]

Hãy thử trực tuyến!

Cũng bị đánh bởi xnor nhưng dù sao cũng được đăng như một cách tiếp cận khác.

Perl 6 , 32 byte

{m:ex/^(.*)(.+)$/».&{[R~] @$_}}

Hãy thử trực tuyến!

m:ex/^(.*)(.+)$/ exthúc đẩy mạnh mẽ mregex đã cho, tách chuỗi đầu vào ở mọi nơi có thể, ngoại trừ chuỗi con thứ hai phải có ít nhất một ký tự - ngăn chuỗi đầu vào hiển thị hai lần trong đầu ra. Sau đó, mỗi Matchnhóm bắt của các đối tượng kết quả được giảm ( []) thành một chuỗi với R~, toán tử nối chuỗi ngược.

Pushy , 4 byte

L:{"

Hãy thử trực tuyến!

L:    \ Length of the string times do:
  {   \    Cyclically shift left once
   "  \    Print

V , 8 byte

ýñx$pÙñd

Hãy thử trực tuyến!

Hexdump:

00000000: fdf1 7824 70d9 f164                      ..x$p..d

Powershell, 44 byte

($s=$args|% t*y)|%{$h,$t=$s;-join($s=$t+$h)}

Kịch bản thử nghiệm:

$f = {

($s=$args|% t*y)|%{$h,$t=$s;-join($s=$t+$h)}

}

@(
    ,('john', 'ohnj', 'hnjo', 'njoh', 'john')
    ,('heehee', 'eeheeh', 'eheehe', 'heehee', 'eeheeh', 'eheehe', 'heehee')
) | % {
    $s,$expected = $_
    $result = &$f $s
    "$result"-eq"$expected"
    $result
}

đầu ra:

True
ohnj
hnjo
njoh
john
True
eeheeh
eheehe
heehee
eeheeh
eheehe
heehee

Tcl , 80 91 byte

proc P s {time {puts [set s [string ra $s 1 e][string in $s 0]]} [string le $s]}

Hãy thử trực tuyến!

SNOBOL4 (CSNOBOL4) , 82 byte

	S =INPUT
T	X =X + 1
	S LEN(1) . L REM . R
	OUTPUT =S =R L LE(X,SIZE(S))	:S(T)
END

Hãy thử trực tuyến!

Lua , 61 byte

function(s)for i=1,#s do print(s:sub(i+1)..s:sub(1,i))end end

Hãy thử trực tuyến!

Tách chuỗi ở các chỉ số liên tiếp từ một đến chiều dài của chuỗi (lập chỉ mục một lần), nối các mảnh theo thứ tự ngược lại, in.

Ruby , 39 byte

->s{a=s.chars.to_a;a.map{a.rotate!*''}}

Hãy thử trực tuyến!

JavaScript, 48 43 36 byte

-5 byte lịch sự của @Bubbler * -7 byte lịch sự của @Shaggy

Đầu vào là một mảng ký tự và đầu ra là một mảng các mảng ký tự.

s=>s.map(_=>([a,...b]=s,s=[...b,a]))

Hãy thử trực tuyến!

Lisp thông thường, 88 byte

(lambda(x)(loop for s from 1 to(length x)do(format t"~a~a "(subseq x s)(subseq x 0 s))))

Hãy thử trực tuyến!

MBASIC , 69 66 byte

-3 byte, nhờ rjan Johansen

1 INPUT S$:L=LEN(S$):FOR I=1 TO L:S$=MID$(S$+S$,2,L):PRINT S$:NEXT

Brainfuck , 38 byte

,[>>,]<<<+>[[.>>]<<[<<]>-[+>.>-].<<+>]

Hãy thử trực tuyến!

Dựa trên ý tưởng JoKing để sử dụng các ký tự null làm biểu tượng không gian. Mã này đánh dấu các chữ cái hiện tại để in và vòng lặp cho đến khi nó đến đầu bên trái.

,[>>,]<<    input string with empty cells in between
<+>         set first marker
[           main loop
  [.>>]     print remaining characters
  <<[<<]    return to start
  >-[+>.>-] print until marker (remove marker)
  .         print null
  <<+       set new marker
  >         restart loop with next character to the left
]           stop if there's no character to the left