O desafio aqui é pegar uma string e produzir todas as suas rotações, movendo repetidamente o primeiro caractere para o final, uma vez por caractere na string, terminando com a string original:

john -> ohnj, hnjo, njoh, john

Você também pode andar de bicicleta na outra direção, movendo caracteres do final:

john -> njoh, hnjo, ohnj, john

Você ainda deve gerar uma rotação por letra, mesmo que a palavra original seja alcançada antes disso:

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

Matrizes de caracteres são permitidas, desde que o resultado funcione como mostrado acima.

A resposta mais curta vence!

Geléia , 2 bytes

ṙJ

Um link monádico que aceita uma lista de caracteres que produz uma lista de listas de caracteres

Experimente online! (o rodapé é impresso chamando o link e juntando-se a caracteres de nova linha)

Haskell, 27 bytes

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

Experimente online!

APL (Dyalog Unicode) , ^{SBCS de} 6 bytes

⍳∘≢⌽¨⊂

Experimente online!

⍳ os índices

∘ do

≢ a contagem

⌽¨ cada rotação (para a esquerda)

⊂ toda a cadeia

Python 2 , 38 bytes

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

Experimente online!

JavaScript (ES6), 37 32 bytes

Retorna uma matriz de seqüências de caracteres.

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

Experimente online!

Japonês, 5 3 bytes

Recebe entrada como uma matriz de caracteres, gera uma matriz de matrizes de caracteres

£=é

Experimente aqui

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

05AB1E , 3 bytes

ā._

Experimente online!

brainfuck , 59 bytes

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

Experimente online!

Produz cada sequência separada por bytes nulos.

Explicação:

,[>,]    # 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 bytes

tf&+)

1 byte salvo graças a @luis!

Experimente no MATL Online !

Explicação :

    # 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

Wolfram Language (Mathematica) , 35 26 bytes

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

Experimente online!

Leva uma lista de caracteres como entrada.

Partition(mas não sua variante StringPartitionusada abaixo) tem um quarto argumento opcional para tratar sua entrada como cíclica (e para especificar exatamente como fazê-lo), o que torna essa solução mais simples que a da cadeia anterior - além de não ter 15 caracteres construídos em funções.

Wolfram Language (Mathematica) , 44 bytes

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

Experimente online!

O mesmo, mas recebe uma string como entrada.

Se "john"transforma e "johnjohn", em seguida, pega todas as StringLength["john"]subseqüências de comprimento dessa sequência com o deslocamento 1, produzindo e {"john","ohnj","hnjo","njoh","john"}, em seguida, descarta a primeira delas com Rest.

Anexo , 13 bytes

Rotate#{1:#_}

Experimente online!

Explicação

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

Alternativas

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

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

16 bytes :Rotate@Rotations

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

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

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

19 bytes :Rotate#(Succ=>Iota)

J , 7 bytes

#\|."{]

Experimente online!

Explicação:

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

R , 58 bytes

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

Experimente online!

C # (compilador interativo do Visual C #) , 34 bytes

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

Experimente online!

C (32 bits), 58 51 50 bytes

-1 byte para um número redondo agradável, graças a

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

Experimente online!

Degolf

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.
}

Carvão , 10 bytes

⮌Ｅθ⭆θ§θ⁻μκ

Experimente online! Link é a versão detalhada do código. Explicação:

  θ         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

Para girar na direção oposta, substitua Minuspor Plus.

Vermelho , 49 43 bytes

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

Experimente online!

Python 2 , 54 48 bytes

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

Experimente online!

Bem derrotado pelo xnor, mas postado como uma abordagem alternativa de qualquer maneira.

Perl 6 , 32 bytes

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

Experimente online!

m:ex/^(.*)(.+)$/ exhaustively matches o regex dada, dividindo a cadeia de entrada em todos os lugares possíveis, exceto que a segunda substring deve ter pelo menos um caractere - que impede a cadeia de entrada de aparecer duas vezes na saída. Em seguida, cada um dos Matchgrupos de captura dos objetos resultantes é reduzido ( []) a uma única cadeia com R~o operador de concatenação de cadeia reversa.

Pushy , 4 bytes

L:{"

Experimente online!

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

V , 8 bytes

ýñx$pÙñd

Experimente online!

Hexdump:

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

Powershell, 44 bytes

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

Script de teste:

$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
}

saída:

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

Tcl , 80 91 bytes

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

Experimente online!

SNOBOL4 (CSNOBOL4) , 82 bytes

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

Experimente online!

Lua , 61 bytes

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

Experimente online!

Divida a sequência em índices sucessivos de um para o comprimento da sequência (indexação baseada em uma), concatene as partes na ordem inversa, imprima.

Ruby , 39 bytes

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

Experimente online!

JavaScript, 48 43 36 bytes

-5 bytes cortesia de @Bubbler * -7 bytes cortesia de @Shaggy

Entrada é uma matriz de caracteres e saída é uma matriz de matrizes de caracteres.

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

Experimente online!

Lisp comum, 88 bytes

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

Experimente online!

MBASIC , 69 66 bytes

-3 bytes, graças a Ørjan Johansen

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

brainfuck , 38 bytes

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

Experimente online!

Com base na idéia do JoKing de usar caracteres nulos como símbolos de espaço. Esse código marca as letras atuais a serem impressas e faz um loop até atingir a extremidade esquerda.

,[>>,]<<    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