Rotation de chaîne - chaîne de sortie déplaçant à plusieurs reprises le premier caractère jusqu'à la fin

22

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!

code-golf string

— I_P_Edwards
source

5

Si une chaîne comme heeheeretourne à l'ordre d'origine en moins de cycles que sa longueur, on s'arrête là? J'espère que cela ferait une grande différence pour de nombreuses réponses.

— xnor

Pouvons-nous faire du vélo dans l'autre sens?

— 2018

2

J'ai édité la question en incluant vos clarifications, n'hésitez pas à la changer si ce n'est pas ce que vous vouliez.

— xnor

1

@xnor qui semble beaucoup plus clair que mon message d'origine, merci beaucoup!

— I_P_Edwards

1

Sommes-nous autorisés à entrer / sortir des tableaux de caractères? (La distinction peut être importante dans certaines langues.)

— LegionMammal978

Réponses:

7

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)

— Jonathan Allan
source

8

Haskell, 27 octets

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

Essayez-le en ligne!

— nimi
source

6

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

— Adam
source

6

Python 2 , 38 octets

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

Essayez-le en ligne!

— xnor
source

Python 3 ne fait que 9 octets de plus.

— wizzwizz4

1

@ wizzwizz4 Où avez-vous 9? Python

— 3-39

@ pizzapants184 J'ai oublié que les chaînes étaient immuables; tu as raison; ce n'est qu'un octet de plus.

— wizzwizz4

6

JavaScript (ES6), 37 32 octets

Renvoie un tableau de chaînes.

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

Essayez-le en ligne!

— Arnauld
source

4

Japt, 5 3 octets

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

£=é

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

— Hirsute
source

3

05AB1E , 3 octets

ā._

Essayez-le en ligne!

— Okx
source

3

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

— Jo King
source

3

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

— Suever
source

@LuisMendo Clever! Merci!

— Suever

3

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.

— Misha Lavrov
source

Étant donné que les tableaux de caractères sont autorisés, Rest@Partition[#~Join~#,Length@#,1]&serait de 36 octets.

— LegionMammal978

@ LegionMammal978 Merci! Il y a probablement aussi une approche plus courte avec les tableaux de caractères, même si je n'ai encore rien pensé.

— Misha Lavrov

2

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)

— Conor O'Brien
source

2

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

— Galen Ivanov
source

2

Utiliser "comme ça est très intelligent et nécessite une connaissance de la langue par un dictionnaire. Y a-t-il aussi un verbe avec rang 1 0?

— 2018

@ Adám je pense que c'est "#:. J'ai appris cela ici de Frownyfrog

— Galen Ivanov

2

R , 58 octets

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

Essayez-le en ligne!

— digEmAll
source

2

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

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

Essayez-le en ligne!

— dana
source

2

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

Suggérer à la ~++i+printf("%s%.*s\n",s+i,i,s)place dei++<printf("%s%.*s\n",s+i,i,s)-2

— plafondcat

@ceilingcat Merci, comme toujours!

@ceilingcat Vous devriez vraiment être appelé flooringcat.

1

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.

— Neil
source

1

Rouge , 49 43 octets

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

Essayez-le en ligne!

— Galen Ivanov
source

1

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.

— ElPedro
source

1

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.

— Sean
source

1

Pushy , 4 octets

L:{"

Essayez-le en ligne!

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

— FlipTack
source

1

V , 8 octets

ýñx$pÙñd

Essayez-le en ligne!

Hexdump:

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

— DJMcMayhem
source

ýñx$pÙñddonne 8 en supprimant la nécessité de H tio.run/##K/v///DewxsrVAoOzzy8MeX/f6/8jDwA

— Kritixi Lithos

@Cowsquack Encore mieux:ý<M-->ñx$pÙ

— DJMcMayhem

Cela ne répète-t-il pas la dernière ligne?

— Kritixi Lithos

1

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

— mazzy
source

1

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!

— sergiol
source

Réaffecter du texte à chaque fois permet d'économiser quelques octetsproc R t {time {puts [set t [string ra $t 1 end][string in $t 0]]} [string len $t]}

— david

Je

— suis

1

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!

— Giuseppe
source

1

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.

— cyclaministe
source

1

Rubis , 39 octets

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

Essayez-le en ligne!

— acornellier
source

1

Bienvenue sur le site! Il ne semble pas que votre lien TIO corresponde à votre réponse. Il semble également que votre réponse ne corresponde pas à nos exigences d'entrée / sortie. Vous pouvez utiliser une fonction ou STDIN / STDOUT mais nous n'autorisons pas la réaffectation des variables.

— Wheat Wizard

Merci Garf. Je ne sais pas comment j'ai réussi à gâcher les deux. Ça devrait être bien maintenant.

— acornellier

1

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!

— guest271314
source

1

43 octets .

— Bubbler

1

36 octets

— Shaggy

@Shaggy Est-ce un nombre et une entrée d'octets valides? Ne [..."john"]compte pas comme une manipulation de la chaîne d'entrée dans un tableau avant l'appel de la fonction?

— guest271314

@ guest271314, l'entrée est un caractère et la sortie est un tableau de tableaux de caractères qui sont autorisés par la spécification de défi et nos valeurs par défaut d'E / S.

— Shaggy

@Shaggy Mis à jour. Pouvez-vous bien vouloir laisser votre commentaire ci-dessus? Ou votre commentaire doit-il être inclus dans la réponse pour éviter toute confusion? Ou n'est-ce pas nécessaire?

— guest271314

1

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!

— Renzo
source

1

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

— wooshinyobject
source

Je suppose que vous pouvez raccourcir cela 1 INPUT S$:L=LEN(S$):FOR I=1 TO L:S$=MID$(S$+S$,2,L):PRINT S$:NEXT.

— Ørjan Johansen

@ Ørjan Johansen Très sympa, merci.

— wooshinyobject

1

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

— Dorian
source

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.

Licensed under cc by-sa 3.0 with attribution required.