Haga un programa que tome la palabra que ingresó y agregue esa palabra al reverso de sí misma menos su primera letra, luego repita hasta que todas las letras hayan desaparecido. Por ejemplo, catse convertiría catatty hellose volvería helloellolloloo.

Ingrese
cualquiera de las 26 letras del alfabeto inglés. Puede haber varias palabras separadas por espacios, y el cambio debe aplicarse a cada palabra.

Salida
La (s) palabra (s) ingresada (s), con cada palabra colocada después de sí misma con su primera letra faltante, y luego con su segunda letra faltante, y así sucesivamente hasta que no haya más letras para agregar.

Más ejemplos:

ill eel salidas illlll eelell

laser bat salidas laserasersererr batatt

darth vader salidas dartharthrththh vaderaderdererr

Este es el código de golf, por lo que gana el código más corto.

Aclaración:
puede tratar la entrada o salida como una lista. Puede separar palabras usando nueva línea en lugar de espacio. Puede agregar un espacio final a la entrada.

Japt -m, 6 3 bytes

Entrada y salida son matrices de palabras.

£sY

Intentalo

Explicación

        :For each word in the input array
£       :Map each letter at index Y
 sY     :  Slice the current word from index Y

brainfuck , 60 56 bytes

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

Pruébalo en línea!

Requiere un espacio final e imprime un espacio inicial. Ambos podrían ser evitados, pero eso termina en 112 bytes .

Explicación

,[  Loop over each byte of input
  Tape: 32 w o r-32 d'
  >++++++++[-<----<++++>>]   Subtract 32 from the character and add 32 to the previous char
  Tape: 32 w o r d-32 0'
  <[>>]<   If the last character was a space
  Tape: 32 w o r d-32 0'
  or
  Tape: 32 w o r d' space-32
  [
    [<]>.   Move to the end of the word and print out the space
    [   Loop over each letter
      [-]    Remove the first letter (initially space)
      >[.>]  Print the rest of the word
      <[<]>  Move back to the first letter
    ]
    Tape: clear
  ]
,]  Get the next byte of input

Haskell, 36 21 bytes

map$concat.scanr(:)""

Pruébalo en línea!

Editar: -15 bytes, debido al nuevo formato IO (lista de palabras en lugar de palabras separadas por espacios)

Perl -p, 36 25 23 bytes

s!\b|\S!$'=~s/ .*//r!eg

Pruébalo en línea!

Este es un registro único. Primero, coincide con todos los límites de palabras o caracteres que no son espacios:

[][H][e][l][l][o] [][W][o][r][l][d]

Tenga en cuenta que cada una de estas coincidencias debe reemplazarse con el resto de la palabra:

[→Hello][H→ello][e→llo][l→lo][l→o][o→] (...)

Podemos lograr esto con la variable especial $', que almacena la parte de la cadena después de la coincidencia. Sin embargo, debemos aplicarle el registro anidado s/ .*//, que elimina todo lo que haya pasado el primer espacio $', para eliminar las palabras restantes en la entrada.

Gracias a @nwellnhof por 2 bytes.

Python 3 , 49 bytes

d=lambda s:' '.join(n+d(n[1:])for n in s.split())

¡Pruébelo en línea!

Esto aprovecha el hecho de que "".split()devuelve una matriz vacía para que actúe como la comprobación del caso base en la recursividad.

Jalea , 3 bytes

ḊƬ€

Pruébalo en línea!

KYa no necesito la s ya que la entrada / salida de matriz ahora está permitida.

ḊƬ€
  €   For each word:
Ḋ       Remove the first letter
 Ƭ      until there are none left.

APL (Dyalog), 19 9 bytes

{⌽∊,\⌽⍵}¨

gracias a @ H.PWiz por activar mi cerebro

Esto funciona porque todas las cadenas en APL son matrices de caracteres.

{⌽∊,\⌽⍵}¨ 
        ¨ - for each string
      ⍵} - string argument - ex. "hello"
     ⌽ - reverse - "olleh"
   ,\ - scan magic - "o" "ol" "oll" "olle" "olleh"
  ∊ - enlist(join together) "oolollolleolleh"
{⌽ - reverse - "helloellolloloo"

TIO

JavaScript (ES6), 33 bytes

Guardado 1 byte gracias a @ShieruAsakoto

Formato de E / S: conjunto de palabras.

a=>a.map(g=w=>w&&w+g(w.slice(1)))

Pruébalo en línea!

JavaScript (ES6), 35 bytes

Formato de E / S: conjunto de palabras.

a=>a.map(w=>w.replace(/./g,"$&$'"))

Pruébalo en línea!

R , 82 75 67 bytes

write(sapply(x<-scan(,""),substring,1:(y=max(nchar(x))),y),1,y,,"")

Pruébalo en línea!

Varios bytes guardados gracias a JayCe

Separa la salida con nuevas líneas.

La sapply(...)expresión genera un vector matriz / columna de las subcadenas apropiadas, rellenando con las ""necesarias. writeluego imprime los elementos de la matriz, ypor línea, separándolos con "".

brainfuck , 94 93 bytes

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

Pruébalo en línea!

• Ahorro de un byte gracias a Nitrodon - golfing .[-]>[.>]<[<]>to [.>]<[<]>[-]>.

Explicación

[[[ (dynamic) tape layout: ... NUL STR ... STR CHR FLG BUF SPC NUL ... ]]]

load a 32 into SPC
-[-[-<]>>+<]>-

while FLG
<<+[

 read a word
 [
  clear FLG; read CHR
  [-]<,
  copy CHR to BUF (using FLG as a temporary)
  [->+>+<<]>[-<+>]
  subtract SPC from BUF and save SPC
  >>[-<->>+<]
  move tape layout one to the right
  <
 ]

 strip trailing space; set FLG to true
 << [>>+<<[-]]
 to STR's first character
 <[<]>
 print word in all reduced forms
 [
  [.>]<[<]>[-]>
 ]

 print SPC; move to FLG
 >>>>.<<
]

Pruébalo en línea!

Atribución

La colección constante Brainfuck de Esolang se utilizó para la carga espacial inicial.

05AB1E , 5 bytes

€.síJ

Pruébalo en línea!

Explicación

€.s        # push suffixes of each
   í       # reverse each
    J      # join suffixes

Vim , 47 bytes (38 pulsaciones de teclas)

Comience con su entrada como la única línea en un búfer Vim.

:s/<Space>/\r/g<CR>ggqaywPlxqqb99@aj0q99@bgg99J

Explicación

Esto pone cada palabra en su propia línea, itera sobre cada línea y luego las une a todas. Se rompe si las palabras tienen más de 99 caracteres o si su entrada tiene más de 99 palabras.

1. :s/<Space>/\r/g<CR> reemplaza espacios con nuevas líneas ( \r)
2. gg coloca el cursor al comienzo de la primera línea
3. qacomienza a grabar macro a :
   • yw tira del resto de la palabra
   • P lo pone detrás del cursor
   • lx elimina la primera letra de la última palabra
   • qdeja de grabar macro a
4. qbcomienza a grabar macro b :
   • 99@amacro ejecuta un noventa y nueve veces (introduce el límite de caracteres)
   • j0 posiciona el cursor al comienzo de la siguiente línea
   • qdeja de grabar macro b
5. 99@bejecuta macro b noventa y nueve veces (introduce el límite de palabras)
6. gg coloca el cursor en la primera línea
7. 99J une las siguientes noventa y nueve líneas con espacios (palabra límite de nuevo)

Para otros 2 bytes (2 pulsaciones de teclas) puede extender el límite de palabras a 999. Otros 4 bytes, 9999, etc.

Casco , 6 4 bytes

^{-2 bytes gracias a Jonathan Allan (tomando la entrada como una lista)!}

moΣṫ

Pruébalo en línea!

Explicación

Toma la entrada como una lista de cadenas y asigna la siguiente función:

Σṫ  -- example argument: "abc"
 ṫ  -- tails: ["abc","bc","c"]
Σ   -- concat: "abcbcc"

Retina 0.8.2 , 15 bytes

 
¶
.
$&$%'
¶
 

Pruébalo en línea! Nota: espacios finales. Explicación:

 
¶

Split en espacios.

.
$&$%'

Agregue su sufijo a cada letra. Los %medios que sólo obtenemos el sufijo de la palabra.

¶
 

Únete con espacios.

Pepe , 167 153 bytes

REEerEeeEeeeeeRrEEEEerEEEEEeerEErEEeerreErEEeErreEREEEEEEEreereErEerEEEErEEeerrEEreRRErEEEEreREEreeereReeRerEEEEEErEEEeerreEerEEeerEEEEerEEeEreereErEeree

Pruébalo en línea!

Código de ensamblado x86 de 16 bits, 24 bytes

     47             inc    di
     B020           mov    al,20h
l1:  3806           cmp    [si],al
     7212           jb     l5 ;less means end of string
     7401           je     l2  ;equal means space was seen
     4F             dec    di ;overwrite extra space
l2:  E80300         call   l3
     46             inc    si ;move to next character in word
     75F1           jne    l1
l3:  56             push   si
l4:  3806           cmp    [si],al
     A4             movsb      ;copy character
     77FB           ja     l4  ;until either zero or space is seen
     5E             pop    si
l5:  C3             ret

Llame con si = puntero a la cadena de origen, di = puntero al búfer de salida.
La cadena de origen requiere un byte cero para finalizarla.
El código es el mismo en 16 o 32 o 64 bits (si / di se convierte en esi / edi o rsi / rdi).
El código de 32 bits es dos bytes más grande debido a la llamada expandida.
El código de 64 bits es aún tres bytes más grande porque el inc / dec de rsi / rdi atrae un prefijo (pero si se sabe que están dentro del espacio de memoria de 32 bits, entonces pueden ser esi / edi nuevamente para evitar esa penalización) .

MATL , 18 16 bytes

"@gXH"HX@Jh)]0&h

La entrada es una matriz de celdas de palabras. Pruébalo en línea!

Explicación

"         % Implicit input: cell array of strings. For each cell
  @g      %   Push content of current cell, that is, a word
  XH      %   Copy into clipboard H
  "       %   For each letter
    H     %     Push word
    X@    %     Push iteration index
    Jh)   %     Index from that until the end into current word
  ]       %   End
  0       %   Push 0. Will be cast to char. Char(0) is displayed as space
  &h      %   Concatenate horizontally all elements so far. Implicit display

K4 / K (oK) , 9 bytes

Solución:

,/'(1_)\'

Pruébalo en línea!

Explicación:

,/'(1_)\' / the solution
        ' / apply to each
       \  / scan
   (  )   / do this together
    1_    / drop first
,/'       / flatten (,/) each (')

C ++ (clang) , 174 bytes

#include<map>
#include<string.h>
std::string r(std::string w){while(auto x=strchr(w.c_str(),32))return r(w.substr(0,x-w.c_str()))+" "+r(x+1);return w!=""?w+r(w.substr(1)):w;}

Pruébalo en línea!

Es mi primer envío, y no sabía si devolver la cadena en lugar de imprimir está bien :)

Stax , 3 bytes

m|]

Ejecutar y depurarlo

Explicación:

m   Map over the lines
 |] Get all suffixes (suffices?)
    Implicit flatten and output

Carbón , 14 bytes

⪫Ｅ⪪Ｓ ⭆ι✂ιμＬι¹ 

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

   Ｓ            Input string
  ⪪             Split on spaces
 Ｅ              Map over each word
      ι         Current word
     ⭆          Map over each character and join
        ι       Current word
         μ      Current index
           ι    Current word
          Ｌ     Length
            ¹   Literal 1
       ✂        Slice
⪫               Join with spaces
                Implicitly print

C (gcc) , 79 bytes

f(s,t)char*s,*t;{for(;*s;printf("%.*s",*s^32?t?t-s:~0:1,s),s++)t=strchr(s,32);}

Pruébalo en línea!

Pip -s , 11 bytes

J_@>,#_Mq^s

Toma la lista de palabras separadas por espacios de stdin. Pruébalo en línea!

Explicación

             s is space (implicit)
        q    Read a line of stdin
         ^s  Split it on spaces
       M     Map this lambda function to each word:
 _            The word...
  @>          sliced starting at index...
    ,#_       range(len(word))
              This creates len(word) slices ["word" "ord" "rd" "d"]
J             Join those into a single string
             The resulting list of modified words is printed; the -s flag uses space
             as the separator

Ruby , 42 bytes

->s{s.map{|a|(w=a.b).chars{a[0]='';w<<a}}}

Pruébalo en línea!

Python 2 , 63 bytes

lambda s:' '.join(map(g,s.split()))
g=lambda s:s and s+g(s[1:])

Pruébalo en línea!

Lienzo , 6 bytes.

±［±］⇵］

Pruébalo aquí!

5 bytes con un formato de salida loco

C #, 111 90 bytes

b=>string.Join(" ",(b.Split(' ').Select(x=>string.Concat(x.Select((y, i)=>x.Substring(i))))))

Pruébalo en línea!

Al cambiar la entrada y la salida a las matrices, guardé algunos bytes:

b=>b.Select(x=>string.Concat(x.Select((y,i)=>x.Substring(i)))).ToArray()

Pruébalo en línea!

K (oK) , 17 13 bytes

{,/|:'|,\|x}'

Pruébalo en línea!

Prefijo de la función anónima; La entrada se toma como una lista de cadenas, que a su vez son listas de caracteres.

Gracias @streetster por 4 bytes.

Cómo:

{,/|:'|,\|x}' //Main function, argument x → ("ill";"eel")
            ' // For each element of the argument
         |x}  // Flip it. x → ("lli";"lee")
       ,\     // Concatenate each element, keeping intermediates. x → (("l";"ll";"lli");("l";"le";"lee")
      |       // Flip it again. x → (("lli";"ll";"l");("lee";"le";"l"))
   |:'        // Now flip each element. x → (("ill";"ll";"l");("eel";"el";"l"))
{,/           // Concatenation scan. x → ("illlll";"eelell")

Lisp común , 179 bytes

(defun r(s)(cond((endp s)nil)((eql(first s)#\Space)(princ " ")(r(rest s)))(t(q s)(r(rest s)))))(defun q (l)(cond((eql(first l)#\Space)t)((endp l)t)(t(princ(first l))(q(rest l)))))

Pruébalo en línea!

Este es mi primer intento de jugar al golf. Cualquier edición es bienvenida.

Lua , 70 bytes

for i=1,#arg do x=arg[i]for i=1,#x do io.write(x:sub(i))end print()end

Pruébalo en línea!

Explicación

Los argumentos en Lua se almacenan en la tabla que argcomienza en el índice 1. El operador unario #devuelve el tamaño de la tabla y la función s:sub(a,b)devuelve una subcadena basada en una cadena sdelimitada por enteros ay b, si no se pasa b, devolverá el resto de la cadena.

Tuve que usar en io.write()lugar de print()evitar el salto de línea, y agregué print()al final por la razón opuesta.