Le défi ici est de prendre une chaîne et de produire toutes ses rotations, en déplaçant à plusieurs reprises le premier caractère jusqu'à la fin, une fois par caractère dans la chaîne, en terminant par la chaîne d'origine:

john -> ohnj, hnjo, njoh, john

Vous pouvez également faire un cycle dans l'autre sens, en déplaçant les personnages de la fin:

john -> njoh, hnjo, ohnj, john

Vous devez toujours générer une rotation par lettre même si le mot d'origine est atteint avant cela:

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

Les tableaux de caractères sont autorisés, tant que le résultat fonctionne comme indiqué ci-dessus.

La réponse la plus courte gagne!

Gelée , 2 octets

ṙJ

Un lien monadique acceptant une liste de caractères qui donne une liste de listes de caractères

Essayez-le en ligne! (joli pied de page s'imprime en appelant le lien et en se joignant à des caractères de nouvelle ligne)

Haskell, 27 octets

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

Essayez-le en ligne!

APL (Dyalog Unicode) , 6 octets ^SBCS

⍳∘≢⌽¨⊂

Essayez-le en ligne!

⍳ les indices

∘ de

≢ le décompte

⌽¨ chacun tourne (vers la gauche)

⊂ la chaîne entière

Python 2 , 38 octets

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

Essayez-le en ligne!

JavaScript (ES6), 37 32 octets

Renvoie un tableau de chaînes.

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

Essayez-le en ligne!

Japt, 5 3 octets

Prend l'entrée comme un tableau de caractères, génère un tableau de tableaux de caractères

£=é

Essayez-le ici

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

05AB1E , 3 octets

ā._

Essayez-le en ligne!

brainfuck , 59 octets

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

Essayez-le en ligne!

Génère chaque chaîne séparée par des octets nuls.

Explication:

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

tf&+)

1 octet enregistré grâce à @luis!

Essayez-le sur MATL Online !

Explication :

    # 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 octets

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

Essayez-le en ligne!

Prend une liste de caractères en entrée.

Partition (mais pas sa variante StringPartition utilisée ci-dessous) a un quatrième argument optionnel pour traiter son entrée comme cyclique (et pour spécifier comment le faire exactement), ce qui rend cette solution plus simple que la chaîne - en plus de ne pas avoir de 15 caractères construits -dans les fonctions.

Wolfram Language (Mathematica) , 44 octets

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

Essayez-le en ligne!

La même chose, mais prend une chaîne en entrée.

Se transforme "john"en "johnjohn", puis prend toutes les StringLength["john"]sous-chaînes de longueur de cette chaîne avec le décalage 1, produisant {"john","ohnj","hnjo","njoh","john"}, puis supprime la première d'entre elles avec Rest.

Attaché , 13 octets

Rotate#{1:#_}

Essayez-le en ligne!

Explication

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

Alternatives

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

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

16 octets :Rotate@Rotations

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

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

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

19 octets :Rotate#(Succ=>Iota)

J , 7 octets

#\|."{]

Essayez-le en ligne!

Explication:

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

R , 58 octets

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

Essayez-le en ligne!

C # (Visual C # Interactive Compiler) , 34 octets

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

Essayez-le en ligne!

C (32 bits), 58 51 50 octets

-1 octet pour un joli chiffre rond grâce au plafond

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

Essayez-le en ligne!

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

charbon , 10 octets

⮌Ｅθ⭆θ§θ⁻μκ

Essayez-le en ligne!Le lien est vers la version détaillée du code. Explication:

  θ         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

Pour tourner dans le sens opposé, remplacez Minuspar Plus.

Rouge , 49 43 octets

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

Essayez-le en ligne!

Python 2 , 54 48 octets

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

Essayez-le en ligne!

Bien battu par xnor mais affiché comme une approche alternative de toute façon.

Perl 6 , 32 octets

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

Essayez-le en ligne!

m:ex/^(.*)(.+)$/ exexhaustivement matches l'expression rationnelle donnée, le partage de la chaîne d'entrée à tous les endroits possibles, sauf que la deuxième sous - chaîne doit avoir au moins un caractère - qui empêche la chaîne d'entrée d'apparaître deux fois dans la sortie. Ensuite, chacun des Matchgroupes de capture des objets résultants est réduit ( []) en une seule chaîne avec R~, l'opérateur de concaténation de chaîne inversée.

Pushy , 4 octets

L:{"

Essayez-le en ligne!

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

V , 8 octets

ýñx$pÙñd

Essayez-le en ligne!

Hexdump:

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

Powershell, 44 octets

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

Script de test:

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

sortie:

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

Tcl , 80 91 octets

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

Essayez-le en ligne!

SNOBOL4 (CSNOBOL4) , 82 octets

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

Essayez-le en ligne!

Lua , 61 octets

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

Essayez-le en ligne!

Fractionner la chaîne à des indices successifs de un à la longueur de la chaîne (indexation sur une base), concaténer les morceaux dans l'ordre inverse, imprimer.

Rubis , 39 octets

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

Essayez-le en ligne!

JavaScript, 48 43 36 octets

-5 octets gracieuseté de @Bubbler * -7 octets avec l'aimable autorisation de @Shaggy

L'entrée est un tableau de caractères et la sortie est un tableau de tableaux de caractères.

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

Essayez-le en ligne!

Lisp commun, 88 octets

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

Essayez-le en ligne!

MBASIC , 69 66 octets

-3 octets, grâce à Ørjan Johansen

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

brainfuck , 38 octets

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

Essayez-le en ligne!

Basé sur l'idée de JoKing d'utiliser des caractères nuls comme symboles d'espace. Ce code marque les lettres actuelles à imprimer et boucle jusqu'à ce qu'il atteigne l'extrémité gauche.

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