El desafío aquí es tomar una cadena y generar todas sus rotaciones, moviendo repetidamente el primer carácter hasta el final, una vez por carácter en la cadena, terminando con la cadena original:

john -> ohnj, hnjo, njoh, john

También puede desplazarse en la otra dirección, moviendo personajes desde el final:

john -> njoh, hnjo, ohnj, john

Aún debe generar una rotación por letra incluso si se alcanza la palabra original antes de eso:

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

Se permiten matrices de caracteres, siempre que el resultado funcione como se muestra arriba.

¡La respuesta más corta gana!

Jalea , 2 bytes

ṙJ

Un enlace monádico que acepta una lista de caracteres que produce una lista de listas de caracteres

Pruébalo en línea! (pie de página bonitas impresiones llamando al enlace y uniéndose con caracteres de nueva línea)

Haskell, 27 bytes

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

Pruébalo en línea!

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

⍳∘≢⌽¨⊂

Pruébalo en línea!

⍳ los índices

∘ de

≢ el recuento

⌽¨ cada uno gira (a la izquierda)

⊂ toda la cuerda

Python 2 , 38 bytes

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

Pruébalo en línea!

JavaScript (ES6), 37 32 bytes

Devuelve una matriz de cadenas.

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

Pruébalo en línea!

Japt, 5 3 bytes

Toma la entrada como una matriz de caracteres, emite una matriz de matrices de caracteres

£=é

Pruébalo aquí

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

05AB1E , 3 bytes

ā._

Pruébalo en línea!

brainfuck , 59 bytes

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

Pruébalo en línea!

Emite cada cadena separada por bytes nulos.

Explicación:

,[>,]    # 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 guardado gracias a @luis!

¡Pruébalo en MATL Online !

Explicacion :

    # 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]&

Pruébalo en línea!

Toma una lista de caracteres como entrada.

Partition(pero no la variante que se StringPartitionusa a continuación) tiene un cuarto argumento opcional para tratar su entrada como cíclica (y para especificar cómo hacerlo exactamente), lo que hace que esta solución sea más simple que la cadena, además de no tener 15 caracteres construidos -en funciones.

Wolfram Language (Mathematica) , 44 bytes

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

Pruébalo en línea!

Lo mismo, pero toma una cadena como entrada.

Se convierte "john"en "johnjohn", luego toma todas las StringLength["john"]subcadenas de longitud de esta cadena con el desplazamiento 1, produciendo {"john","ohnj","hnjo","njoh","john"}, luego suelta la primera de ellas con Rest.

Adjunto , 13 bytes

Rotate#{1:#_}

Pruébalo en línea!

Explicación

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

#\|."{]

Pruébalo en línea!

Explicación:

  |."{    - 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])

Pruébalo en línea!

C # (compilador interactivo de Visual C #) , 34 bytes

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

Pruébalo en línea!

C (32 bits), 58 51 50 bytes

-1 byte para un buen número redondo gracias a ceilingcat

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

Pruébalo en línea!

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

Carbón de leña , 10 bytes

⮌Ｅθ⭆θ§θ⁻μκ

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

  θ         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 rotar en la dirección opuesta, reemplace Minuscon Plus.

Rojo , 49 43 bytes

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

Pruébalo en línea!

Python 2 , 54 48 bytes

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

Pruébalo en línea!

Bien golpeado por xnor, pero publicado como un enfoque alternativo de todos modos.

Perl 6 , 32 bytes

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

Pruébalo en línea!

m:ex/^(.*)(.+)$/ exataca con mfuerza la expresión regular dada, dividiendo la cadena de entrada en todos los lugares posibles, excepto que la segunda subcadena debe tener al menos un carácter, lo que evita que la cadena de entrada aparezca dos veces en la salida. Luego, cada uno de los Matchgrupos de captura de los objetos resultantes se reduce ( []) a una sola cadena con R~el operador de concatenación de cadenas invertidas.

Pushy , 4 bytes

L:{"

Pruébalo en línea!

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

V , 8 bytes

ýñx$pÙñd

Pruébalo en línea!

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 prueba:

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

salida:

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

Pruébalo en línea!

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

Pruébalo en línea!

Lua , 61 bytes

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

Pruébalo en línea!

Dividir la cadena en índices sucesivos de uno a la longitud de la cadena (indexación basada en uno), concatenar las piezas en el orden inverso, imprimir.

Ruby , 39 bytes

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

Pruébalo en línea!

JavaScript, 48 43 36 bytes

-5 bytes cortesía de @Bubbler * -7 bytes cortesía de @Shaggy

La entrada es una matriz de caracteres y la salida es una matriz de matrices de caracteres.

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

Pruébalo en línea!

Lisp común, 88 bytes

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

Pruébalo en línea!

MBASIC , 69 66 bytes

-3 bytes, gracias 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

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

Pruébalo en línea!

Basado en la idea de JoKing de usar caracteres nulos como símbolos de espacio. Este código marca las letras actuales para imprimir y los bucles hasta que llega al extremo izquierdo.

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