Rotación de cadena: la cadena de salida mueve repetidamente el primer carácter al final

22

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!

code-golf string

— I_P_Edwards
fuente

55

Si una cadena como heeheevuelve al orden original en menos ciclos que su longitud, ¿nos detenemos allí? Espero que esto haga una gran diferencia para muchas respuestas.

— xnor

¿Podemos ir en la otra dirección?

— xnor

2

Edité la pregunta, incluidas sus aclaraciones, siéntase libre de cambiarla si no es lo que pretendía.

— xnor

1

@xnor que se ve mucho más claro que mi publicación original, ¡muchas gracias!

— I_P_Edwards

1

¿Se nos permite ingresar / extraer matrices de caracteres? (La distinción puede ser importante en algunos idiomas.)

— LegionMammal978

Respuestas:

7

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)

— Jonathan Allan
fuente

8

Haskell, 27 bytes

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

Pruébalo en línea!

— nimi
fuente

6

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

— Adán
fuente

6

Python 2 , 38 bytes

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

Pruébalo en línea!

— xnor
fuente

Python 3 tiene solo 9 bytes más.

— wizzwizz4

1

@ wizzwizz4 ¿Dónde conseguiste 9? Python 3 - 39 bytes (entrada estándar sin comillas)

— pizzapants184 12/12/18

@ pizzapants184 Olvidé que las cuerdas eran inmutables; tienes razón; es solo 1 byte más.

— wizzwizz4

6

JavaScript (ES6), 37 32 bytes

Devuelve una matriz de cadenas.

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

Pruébalo en línea!

— Arnauld
fuente

4

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

— Lanudo
fuente

3

05AB1E , 3 bytes

ā._

Pruébalo en línea!

— Okx
fuente

3

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

— Jo King
fuente

3

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

— Suever
fuente

@LuisMendo Clever! ¡Gracias!

— Suever

3

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.

— Misha Lavrov
fuente

Como las matrices de caracteres están permitidas, Rest@Partition[#~Join~#,Length@#,1]&serían 36 bytes.

— LegionMammal978

@ LegionMammal978 ¡Gracias! Probablemente también haya un enfoque más corto con las matrices de caracteres, aunque todavía no he pensado en nada.

— Misha Lavrov

2

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)

— Conor O'Brien
fuente

2

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

— Galen Ivanov
fuente

2

Usarlo de "esa manera es muy inteligente y requiere el conocimiento del diccionario del idioma. ¿Hay también un verbo con rango 1 0?

— Adám

@ Adám creo que es "#:. Aprendí esto aquí de Frownyfrog

— Galen Ivanov

2

R , 58 bytes

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

Pruébalo en línea!

— digEmAll
fuente

2

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

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

Pruébalo en línea!

— dana
fuente

2

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

Sugerir en ~++i+printf("%s%.*s\n",s+i,i,s)lugar dei++<printf("%s%.*s\n",s+i,i,s)-2

— ceilingcat

@ceilingcat Gracias, como siempre!

@ceilingcat Realmente debería llamarte flooringcat.

1

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.

— Neil
fuente

1

Rojo , 49 43 bytes

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

Pruébalo en línea!

— Galen Ivanov
fuente

1

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.

— ElPedro
fuente

1

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.

— Sean
fuente

1

Pushy , 4 bytes

L:{"

Pruébalo en línea!

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

— FlipTack
fuente

1

V , 8 bytes

ýñx$pÙñd

Pruébalo en línea!

Hexdump:

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

— DJMcMayhem
fuente

ýñx$pÙñdda 8 al eliminar la necesidad de H tio.run/##K/v///DewxsrVAoOzzy8MeX/f6/8jDwA

— Kritixi Lithos

@Cowsquack Aún mejor:ý<M-->ñx$pÙ

— DJMcMayhem

¿Eso no repite la última línea?

— Kritixi Lithos

1

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

— mazzy
fuente

1

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!

— sergiol
fuente

Reasignar texto en cada momento ahorra algunos bytesproc R t {time {puts [set t [string ra $t 1 end][string in $t 0]]} [string len $t]}

— david

Lo bajé a 80 bytes, gracias a @david

— sergiol

1

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!

— Giuseppe
fuente

1

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.

— ciclaminista
fuente

1

Ruby , 39 bytes

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

Pruébalo en línea!

— acornellier
fuente

1

Bienvenido al sitio! No parece que su enlace TIO corresponda a su respuesta. También parece que su respuesta no se ajusta a nuestros requisitos de entrada / salida. Puede usar una función o STDIN / STDOUT pero no permitimos la reasignación de variables.

— Mago de trigo

Gracias Garf. No estoy seguro de cómo logré desordenar a ambos. Debería estar todo bien ahora.

— acornellier

1

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!

— invitado271314
fuente

1

43 bytes .

— Bubbler

1

36 bytes

— Shaggy

@ Shaggy ¿Es un conteo de bytes válido y una entrada? ¿ [..."john"]No cuenta como manipulación de la cadena de entrada a una matriz antes de la llamada a la función?

— invitado271314

@ guest271314, la entrada es un carácter y la salida es una matriz de matrices de caracteres permitidas por la especificación de desafío y nuestros valores predeterminados de E / S.

— Shaggy

@Shaggy Actualizado. ¿Puedes dejar tu comentario anterior amablemente? ¿O debería incluirse su comentario en la respuesta para evitar confusiones? ¿O no es necesario?

— invitado271314

1

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!

— Renzo
fuente

1

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

— wooshinyobject
fuente

Sospecho que puedes acortar eso 1 INPUT S$:L=LEN(S$):FOR I=1 TO L:S$=MID$(S$+S$,2,L):PRINT S$:NEXT.

— Ørjan Johansen

@ Ørjan Johansen Muy bien, gracias.

— wooshinyobject

1

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

— dorio
fuente

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.

Licensed under cc by-sa 3.0 with attribution required.