Faça um programa que use a palavra que você digitou e adicione essa palavra à parte de trás de si menos sua primeira letra e depois repita até que todas as letras se esgotem. Por exemplo, catse tornaria catatt, e hellose tornaria helloellolloloo.

Insira
qualquer uma das 26 letras do alfabeto inglês. Pode haver várias palavras separadas por espaços, e a alteração deve ser aplicada a cada palavra.

Saída
A (s) palavra (s) inserida (s), com cada palavra colocada depois de si mesma com a primeira letra faltando e, em seguida, com a segunda letra faltando, e assim por diante até que não haja mais letras a serem adicionadas.

Mais exemplos:

ill eel saídas illlll eelell

laser bat saídas laserasersererr batatt

darth vader saídas dartharthrththh vaderaderdererr

Isso é código de golfe, então o código mais curto vence.

Esclarecimento:
Você pode tratar a entrada ou saída como uma lista. Você pode separar palavras usando nova linha em vez de espaço. Você pode adicionar um espaço à direita na entrada.

Japonês -m, 6 3 bytes

Entrada e saída são matrizes de palavras.

£sY

Tente

Explicação

        :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

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

Experimente online!

Requer um espaço à direita e imprime um espaço à esquerda. Ambos podem ser contornados, mas isso acaba em 112 bytes .

Explicação

,[  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(:)""

Experimente online!

Editar: -15 bytes, devido ao novo formato IO (lista de palavras em vez de palavras separadas por espaço)

Perl -p, 36 25 23 bytes

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

Experimente online!

Este é um único regsub. Primeiro, ele corresponde a todos os limites de palavras ou caracteres não espaciais:

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

Observe que cada uma dessas correspondências deve ser substituída pelo restante da palavra:

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

Podemos fazer isso com a variável especial $', que armazena a parte da sequência após a partida. No entanto, precisamos aplicar o regsub aninhado s/ .*//a ele, que remove tudo após o primeiro espaço $', para se livrar das palavras restantes na entrada.

Obrigado a @nwellnhof por 2 bytes.

Python 3 , 49 bytes

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

Experimente Online!

Isso tira proveito do fato de que "".split()retorna uma matriz vazia para que atue como a verificação do caso base na recursão.

Geléia , 3 bytes

ḊƬ€

Experimente online!

Não Ké mais necessário s, já que a entrada / saída da matriz agora é permitida.

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

APL (Dyalog), 19 9 bytes

{⌽∊,\⌽⍵}¨

graças a @ H.PWiz por movimentar meu cérebro

Isso funciona porque todas as seqüências de caracteres no APL são matrizes 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 graças a @ShieruAsakoto

Formato de E / S: matriz de palavras.

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

Experimente online!

JavaScript (ES6), 35 bytes

Formato de E / S: matriz de palavras.

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

Experimente online!

R , 82 75 67 bytes

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

Experimente online!

Vários bytes salvos graças ao JayCe

Separa a saída com novas linhas.

A sapply(...)expressão gera um vetor de matriz / coluna das substrings apropriadas, preenchendo ""conforme necessário. writedepois imprime os elementos da matriz, ypor linha, separando-os com "".

brainfuck , 94 93 bytes

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

Experimente online!

• Salvo um byte graças ao Nitrodon - golfe .[-]>[.>]<[<]>para [.>]<[<]>[-]>.

Explicação

[[[ (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
 >>>>.<<
]

Experimente online!

Atribuição

A coleção constante do cérebro de Esolang foi usada para a carga espacial inicial.

05AB1E , 5 bytes

€.síJ

Experimente online!

Explicação

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

Vim , 47 bytes (38 pressionamentos de tecla)

Comece com sua entrada como a única linha em um buffer do Vim.

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

Explicação

Isso coloca cada palavra em sua própria linha, itera sobre cada linha e depois se junta a todas. Quebra se as palavras tiverem mais de 99 caracteres ou se sua entrada tiver mais de 99 palavras.

1. :s/<Space>/\r/g<CR> substitui espaços por novas linhas ( \r)
2. gg posiciona o cursor no início da primeira linha
3. qacomeça a gravar a macro a :
   • yw puxa o resto da palavra
   • P coloca atrás do cursor
   • lx remove a primeira letra da última palavra
   • qpára de gravar a macro a
4. qbcomeça a gravar a macro b :
   • 99@aexecuta macro um noventa e nove vezes (introduz o limite de caracteres)
   • j0 posiciona o cursor no início da próxima linha
   • qpara de gravar a macro b
5. 99@bexecuta a macro b noventa e nove vezes (introduz o limite de palavras)
6. gg posiciona o cursor na primeira linha
7. 99J une as seguintes noventa e nove linhas com espaços (limite de palavras novamente)

Por mais 2 bytes (2 pressionamentos de tecla), você pode estender o limite de palavras para 999. Outros 4 bytes, 9999, etc.

Casca , 6 4 bytes

^{-2 bytes graças a Jonathan Allan (tomando a entrada como uma lista)!}

moΣṫ

Experimente online!

Explicação

Recebe a entrada como uma lista de cadeias e mapeia a seguinte função:

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

Retina 0.8.2 , 15 bytes

 
¶
.
$&$%'
¶
 

Experimente online! Nota: espaços à direita. Explicação:

 
¶

Dividir em espaços.

.
$&$%'

Anexe seu sufixo a cada letra. Os %meios que obtemos apenas o sufixo da palavra.

¶
 

Junte-se a espaços.

Pepe , 167 153 bytes

REEerEeeEeeeeeRrEEEEerEEEEEeerEErEEeerreErEEeErreEREEEEEEEreereErEerEEEErEEeerrEEreRRErEEEEreREEreeereReeRerEEEEEErEEEeerreEerEEeerEEEEerEEeEreereErEeree

Experimente online!

Código de montagem 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

Chame com si = ponteiro para a string de origem, di = ponteiro para o buffer de saída.
A cadeia de origem requer um byte zero para finalizá-la.
O código é o mesmo em 16 ou 32 ou 64 bits (si / di se torna esi / edi ou rsi / rdi).
O código de 32 bits é dois bytes maior por causa da chamada expandida.
O código de 64 bits ainda é três bytes maior porque o inc / dec de rsi / rdi atrai um prefixo (mas se for sabido que eles estão no espaço de memória de 32 bits, eles podem ser esi / edi novamente para evitar essa penalidade) .

MATL , 18 16 bytes

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

Entrada é uma matriz de células de palavras. Experimente online!

Explicação

"         % 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

Solução:

,/'(1_)\'

Experimente online!

Explicação:

,/'(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;}

Experimente online!

É a minha primeira submissão, e eu não sabia se retornar a string em vez de imprimir está ok :)

Stax , 3 bytes

m|]

Execute e depure

Explicação:

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

Carvão , 14 bytes

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

Experimente online! Nota: Espaço à direita. Link é a versão detalhada do código. Explicação:

   Ｓ            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);}

Experimente online!

Pip -s , 11 bytes

J_@>,#_Mq^s

Retorna a lista de palavras separadas por espaço de stdin. Experimente online!

Explicação

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

Experimente online!

Python 2 , 63 bytes

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

Experimente online!

Tela , 6 bytes

±［±］⇵］

Experimente aqui!

5 bytes com um formato de saída louco

C #, 111 90 bytes

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

Experimente Online!

Alterando entrada e saída para matrizes, salvei alguns bytes:

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

Experimente Online!

K (oK) , 17 13 bytes

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

Experimente online!

Prefixar função anônima; A entrada é tomada como uma lista de cadeias, que por sua vez são listas de caracteres.

Obrigado @streetster por 4 bytes.

Como:

{,/|:'|,\|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 comum , 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)))))

Experimente online!

Esta é a minha primeira tentativa de jogar golfe.

Lua , 70 bytes

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

Experimente online!

Explicação

Os argumentos em Lua são armazenados na tabela arginiciando no índice 1. O operador unário #retorna o tamanho da tabela e a função s:sub(a,b)retorna uma substring baseada na sequência sdelimitada por números inteiros ae b, se b não for passado, retornará o restante da sequência.

Eu tive que usar em io.write()vez de print()evitar quebras de linha e adicionei print()no final pelo motivo oposto.