[Question]
  [
Make a program that takes the word you input, and adds that word to the back of itself minus its first letter, then repeats until all letters are gone. For example, `cat` would become `catatt`, and `hello` would become `helloellolloloo`.
**Input**  
Any of the 26 letters of the English alphabet. There may be multiple words separated by spaces, and the change should be applied to every word.
**Output**  
The word(s) inputted, with each word put after itself with its first letter missing, and then with its second letter missing, and so on until there are no more letters to add.
**More examples:**
`ill eel` outputs `illlll eelell`
`laser bat` outputs `laserasersererr batatt`
`darth vader` outputs `dartharthrththh vaderaderdererr`
This is code golf, so the shortest code wins. 
Clarification:  
You can treat the input or output as a list. You can separate words using newline instead of space. You can add a trailing space to the input.
  
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), ~~60~~ 56 bytes
```
,[>++++++++[-<----<++++>>]<[>>]<[[<]>.[[-]>[.>]<[<]>]],]
```
[Try it online!](https://tio.run/##LYdBCoAgEAC/svfUFyz7kWUPJSuJoFEG/X7TaA7DzHauuaY7FjPHtPywRz/A2USC/IlRKDB7IQ7zx4o4MWsV@q7Q25EjtAT65KtrjQov "brainfuck – Try It Online")
Requires a trailing space and prints a leading space. Both of these could be circumvented, but that ends up at [112 bytes](https://tio.run/##VYtLCoAwDESv0n0/Jwi5SMhCS8UitKIVvH1MpS4cSJiZ5M3HlMtyxU3EEdoh8uBV0D0iA72LgJG8DoUeR@IBfKyegvbsxgtpYbv7kQ5ZpBbT1mRa3XM0dTHpzmdLJaYH "brainfuck – Try It Online").
### Explanation
```
,[  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
```
[Answer]
# Japt `-m`, ~~6~~ 3 bytes
Input and output are arrays of words.
```
£sY
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=o3NZ&input=WyJjb2RlIiwiZ29sZiJdCi1tUw==)
---
## Explanation
```
        :For each word in the input array
£       :Map each letter at index Y
 sY     :  Slice the current word from index Y
```
[Answer]
## Haskell, ~~36~~ 21 bytes
```
map$concat.scanr(:)""
```
[Try it online!](https://tio.run/##XcsxCoAwDADA3VeE0EFBfYDQl6hDiK0txrRY3291dj24QOVwItXbpZ6UDSdlusfCpFc7dYifRgULW2oA8hX1BgMeZgxfS7j@NIpgD@ic4Fof9kJ7qQPn/AI "Haskell – Try It Online")
Edit: -15 bytes, because of new IO format (list of words instead of space separated words) 
[Answer]
# [Python 3](https://docs.python.org/3/), 49 bytes
```
d=lambda s:' '.join(n+d(n[1:])for n in s.split())
```
[Try It Online!](https://tio.run/##VcixCsJADADQ3a8IXZogFMSt4JeIQ0pOGom5IxcEv/50Enzja@/cq5/HkIvxcxOGvs4wL4@qjn4U9OtpvdG9BjioQ196M00kGi3UEwUnNYNSbCI6/M64l4CN82@FI3d4sZT4/vgA)
This takes advantage of the fact that `"".split()` returns an empty array so that acts as the check for the base case in the recursion.
[Answer]
## Perl `-p`, ~~36~~ ~~25~~ 23 bytes
```
s!\b|\S!$'=~s/ .*//r!eg
```
[Try it online!](https://tio.run/##K0gtyjH9/79YMSapJiZYUUXdtq5YX0FPS1@/SDE1/f9/j9ScnHyF8PyinJR/@QUlmfl5xf91CwA)
This is a single regsub. First, it matches all word boundaries or non-space characters:
```
[][H][e][l][l][o] [][W][o][r][l][d]
```
Note that each of these matches should be replaced with the rest of the word:
```
[→Hello][H→ello][e→llo][l→lo][l→o][o→] (...)
```
We can accomplish this with the special variable `$'`, which stores the part of the string after the match. However, we need to apply the nested regsub `s/ .*//` to it, which removes everything past the first space in `$'`, in order to get rid of the remaining words in the input.
Thanks to [@nwellnhof](https://codegolf.stackexchange.com/users/9296/nwellnhof) for 2 bytes.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 3 bytes
```
ḊƬ€
```
[Try it online!](https://tio.run/##y0rNyan8///hjq5jax41rQEyNh1u9/7/Xz0lsagkQ6EsMSW1SB0A "Jelly – Try It Online")
Don’t need the `K`s anymore since array input/output is now allowed.
```
ḊƬ€
  €   For each word:
Ḋ       Remove the first letter
 Ƭ      until there are none left.
```
[Answer]
# APL(Dyalog), ~~19~~ 9 bytes
`{⌽∊,\⌽⍵}¨`
*thanks to @H.PWiz for jogging my brain*
This works because all strings in APL are character arrays.
```
{⌽∊,\⌽⍵}¨ 
        ¨ - for each string
      ⍵} - string argument - ex. "hello"
     ⌽ - reverse - "olleh"
   ,\ - scan magic - "o" "ol" "oll" "olle" "olleh"
  ∊ - enlist(join together) "oolollolleolleh"
{⌽ - reverse - "helloellolloloo"
```
[TIO](https://tio.run/##SyzI0U2pTMzJT///v/pRz95HHV06MSC6d2vtoRXYxDTUFdQfdcx41LngUVfbo65FmuoZqTk5@Qrl@UU5KepcxGjIzMlRSE3NIU5xTmJxapFCUmIJccpTEotKMhTKElNSi9QB)
[Answer]
# JavaScript (ES6), 33 bytes
*Saved 1 byte thanks to @ShieruAsakoto*
I/O format: array of words.
```
a=>a.map(g=w=>w&&w+g(w.slice(1)))
```
[Try it online!](https://tio.run/##bcpBDoMgEADAex8iu7GS@AD8SONhhZXSbMUAkedTzo3nmQ9dlG0KZ5mO6LjtppFZSH/pBG@qWeow1NFD1VmCZZgRsdl45CisJXrY4aWCiHoqZlEr4uNfhTKn7huVW3eUyrv7Ra6/PtoP "JavaScript (Node.js) – Try It Online")
---
# JavaScript (ES6), 35 bytes
I/O format: array of words.
```
a=>a.map(w=>w.replace(/./g,"$&$'"))
```
[Try it online!](https://tio.run/##bcpNDsIgEAbQvcdoGgeSSk9AL2JcfML0L2MhQNrjI2vj@r0dJ7JLWyyPI3ius62wE8wHUV12ukziKHCsRjMuQ9ffe@q0ri4cOQgbCYua1ZM2ERqIWeil9e1XBZlT8zfKX/dIZW1@wrfXRv0C "JavaScript (Node.js) – Try It Online")
[Answer]
# [R](https://www.r-project.org/), ~~82~~ ~~75~~ 67 bytes
```
write(sapply(x<-scan(,""),substring,1:(y=max(nchar(x))),y),1,y,,"")
```
[Try it online!](https://tio.run/##FcrBCoAgDADQXwlPG6yD16iPWSoplMhmpV9v9M5Pxngl1QDKpZwd2jqr4wxkDJLeu1ZJ@SC7QN8ubpBdZIGGiNSRLHX65/AsNU4P@yDjAw "R – Try It Online")
*Several bytes saved thanks to [JayCe](https://codegolf.stackexchange.com/users/80010/jayce)*
Separates output with newlines.
The `sapply(...)` expression generates a matrix/column vector of the appropriate substrings, padding with `""` as needed. `write` then prints the elements of the matrix, `y` per line, separating them with `""`.
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), ~~94~~ 93 bytes
```
-[-[-<]>>+<]>-<<+[[[-]<,[->+>+<<]>[-<+>]>>[-<->>+<]<]<<[>>+<<[-]]<[<]>[[.>]<[<]>[-]>]>>>>.<<]
```
[Try it online!](https://tio.run/##LYtRCoAwDEOv0v/ZnaD0ImUfOiYOYROd4O1nJhJoQvK6nHMu6x333tkgCaoOh0WcmXGQyVgdOpSYnQKA84dBYiMJyCA2GPP6Jw4DVvX47b0WaluiVo8cqa6Unny1VGKiFw "brainfuck – Try It Online")
* Saved one byte thanks to [Nitrodon](https://codegolf.stackexchange.com/users/69059/nitrodon) -- golfing `.[-]>[.>]<[<]>` to `[.>]<[<]>[-]>`.
# Explanation
```
[[[ (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
 >>>>.<<
]
```
[Try it online!](https://tio.run/##TVC7TsMwFN39FWejVUkG2KjlgUqFoUKoj8nK4DpOa5HEke1Q8vXh2mVAkRLH597zOntl@2bUX/MspcSinnrVWb1EVINBqyY3xheUZYmP0w6H4z6f03fzvsd294bX0xaHz03GE1ZVFWOtUzUUnp9g@@gSzgpJD6@EWNGrYOx2ta1JDIzzlWQM3uSdm/M1g2SAbo3yaWJ9x0iRbmVR8ceEumHKJog/eViMwfaXbEkF4ommG5xXflrmJbEiYVImDytR0VUYz9ErHbP5xrsus6i@RlDfJlsGRJovsmf66xwB/4qB602Sj1cDby/XSDOcgfIjRG8HkIBtk6swKG3WCCZmg2nHj4aBc8jEzikVKaSqjvuHgMb6EKGvKjk0ngYleWcYPPWZK6JiodqWmqlHbWo0znfh3pssRZXniVTc7dz3KNP6L4TLzVM@IUrOWTXPrs85ohushmtgfmyIptcGvw "brainfuck – Try It Online")
# Attribution
Esolang's [brainfuck constant collection](https://esolangs.org/wiki/Brainfuck_constants#32) was used for the initial space load.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 5 bytes
```
€.síJ
```
[Try it online!](https://tio.run/##yy9OTMpM/W/q9v9R0xq94sNrvf7r/I9WSk4sUYrlilbKSM3JyQezMnNylHQUlFJTc8DcnMTi1CKQQBJUZUpiUUkGSKAsMQUoEwsA "05AB1E – Try It Online")
**Explanation**
```
€.s        # push suffixes of each
   í       # reverse each
    J      # join suffixes
```
[Answer]
# [Husk](https://github.com/barbuz/Husk), ~~6~~ 4 bytes
-2 bytes thanks to [Jonathan Allan](https://codegolf.stackexchange.com/users/53748/jonathan-allan) (taking input as a list)!
```
moΣṫ
```
[Try it online!](https://tio.run/##yygtzv7/Pzf/3OKHO1f///8/WiknsTi1SElHKSmxRCkWAA "Husk – Try It Online")
### Explanation
Takes input as a list of strings and maps the following function:
```
Σṫ  -- example argument: "abc"
 ṫ  -- tails: ["abc","bc","c"]
Σ   -- concat: "abcbcc"
```
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 15 bytes
```
 
¶
.
$&$%'
¶
 
```
[Try it online!](https://tio.run/##K0otycxL/P9fgevQNi49LhU1FVV1EFPh//@UxKKSDIWyxJTUIgA "Retina 0.8.2 – Try It Online") Note: trailing spaces. Explanation:
```
 
¶
```
Split on spaces.
```
.
$&$%'
```
Append its suffix to each letter. The `%` means that we only get the word's suffix.
```
¶
 
```
Join with spaces.
[Answer]
# [Vim](https://www.vim.org/), 47 bytes (38 key strokes)
Start with your input as the sole line in a Vim buffer.
```
:s/<Space>/\r/g<CR>ggqaywPlxqqb99@aj0q99@bgg99J
```
## Explanation
This puts each word on its own line, iterates over each line, then rejoins them all. Breaks if words are longer than 99 characters or if your input has more than 99 words.
1. `:s/<Space>/\r/g<CR>` [replaces](http://vim.wikia.com/wiki/Search_and_replace) spaces with new lines (`\r`)
2. `gg` positions the cursor at the beginning of the first line
3. `qa` begins recording [macro](http://vim.wikia.com/wiki/Macros) *a*:
	* `yw` yanks the rest of the word
	* `P` [puts it behind the cursor](http://vimdoc.sourceforge.net/htmldoc/change.html#P)
	* `lx` removes the first letter of the latter word
	* `q` stops recording macro *a*
4. `qb` begins recording macro *b*:
	* `99@a` executes macro *a* ninety-nine times (introduces the character limit)
	* `j0` positions the cursor at the start of the next line
	* `q` stops recording macro *b*
5. `99@b` executes macro *b* ninety-nine times (introduces the word limit)
6. `gg` positions the cursor at the first line
7. `99J` [joins](http://vimdoc.sourceforge.net/htmldoc/change.html#J) the following ninety-nine lines with spaces (word limit again)
For another 2 bytes (2 key strokes) you could extend the word limit to 999. Another 4 bytes, 9999, etc.
[Answer]
# [Pepe](//github.com/Soaku/Pepe/), ~~167~~ 153 bytes
```
REEerEeeEeeeeeRrEEEEerEEEEEeerEErEEeerreErEEeErreEREEEEEEEreereErEerEEEErEEeerrEEreRRErEEEEreREEreeereReeRerEEEEEErEEEeerreEerEEeerEEEEerEEeEreereErEeree
```
[Try it online!](//soaku.github.io/Pepe/#T!8g--gE0E!k@A!m@AE7*AC!q!k@E$-&!q$FG$/.&2-c@K!k-g!m*AC*)
[Answer]
# 16-bit x86 assembly code, 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
```
Call with si = pointer to source string, di = pointer to output buffer.  
The source string requires a zero byte to end it.  
The code is the same in 16- or 32- or 64-bit (si/di become either esi/edi or rsi/rdi).  
32-bit code is two bytes larger because of the expanded call.  
64-bit code is three bytes larger still because the inc/dec of rsi/rdi attracts a prefix (but if it is known that they are within 32-bit memory space, then they can be esi/edi again to avoid that penalty).
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~18~~ 16 bytes
```
"@gXH"HX@Jh)]0&h
```
Input is a cell array of words. [Try it online!](https://tio.run/##y00syfn/X8khPcJDySPCwStDM9ZALeP//2r1nMTi1CJ1BfWkxBL1WgA)
### Explanation
```
"         % 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
```
[Answer]
# [K4](http://kx.com/download) / [K (oK)](https://github.com/JohnEarnest/ok), 9 bytes
**Solution:**
```
,/'(1_)\'
```
[Try it online!](https://tio.run/##y9bNz/7/X0dfXcMwXjNGXUMpJbGoJEPJWqksMSW1SEnz/38A "K (oK) – Try It Online")
**Explanation:**
```
,/'(1_)\' / the solution
        ' / apply to each
       \  / scan
   (  )   / do this together
    1_    / drop first
,/'       / flatten (,/) each (')
```
[Answer]
# [C++ (clang)](http://clang.llvm.org/), 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;}
```
[Try it online!](https://tio.run/##hY5BbsIwEEX3OYVrNh4FUGl3iUmPUhnbwpYmTjSxcSTE2UMoVYTYZDf/zZvR132/06jCeZo2PmhMxspW9U2xpCGSD@e9a4ohmqp6RkbiNWW4ZufRCpVix8bjjLUjkff6dx4FbL@/AMjGRIE98JBOD/65HXeLA1ByxksSY3mA@l/OH0fOf3L5cnQAqHJ9W@oy6buZW9U2hQ@RtcoHAddnW92lKKUgwT0isxY5gJR/KxsM1u8WqsESO6m44hlF0bGLMpZWTL36y1nE7t25TXc "C++ (clang) – Try It Online")
It's my first submission, and i didn't know if returning string instead of printing it is okay :)
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 3 bytes
```
m|]
```
[Run and debug it](https://staxlang.xyz/#c=m%7C]&i=darth%0Avader&a=1)
Explanation:
```
m   Map over the lines
 |] Get all suffixes (suffices?)
    Implicit flatten and output
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 5 bytes
```
ƛ[Ḣx+
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=&code=%C6%9B%5B%E1%B8%A2x%2B&inputs=%5B%27laser%27%2C%27bat%27%5D&header=&footer=)
(IMO) this is a really neat recursive solution. Port of my JS answer that came out really nicely.
```
ƛ     # Foreach value as n
 [    # If truthy (Not empty string)
   x  # Call this function (The function we're mapping with)
  Ḣ   # With n[1:] - remove first character
    + # Appended to the result
```
The "concatenation of suffixes" approach doesn't do any better:
# [Vyxal](https://github.com/Vyxal/Vyxal), 5 bytes
```
ƛṘ¦∑Ṙ
```
[Try it Online!](https://lyxal.pythonanywhere.com?flags=&code=%C6%9B%E1%B9%98%C2%A6%E2%88%91%E1%B9%98&inputs=%5B%27laser%27%2C%27bat%27%5D&header=&footer=)
```
ƛ     # Map...
 Ṙ    # Reverse
  ¦   # Cumulative sums (prefixes)
   ∑  # Concatenated
    Ṙ # Reversed
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 14 bytes
```
⪫Ｅ⪪Ｓ ⭆ι✂ιμＬι¹ 
```
[Try it online!](https://tio.run/##LYpBCoAgEEX3nUJajVCL1p2gKAg8waCSA2YiU9efjNp8/uM9G7DYE6PIVigxzCclWDGDyZEYppQvNlzVDrpTrWrrfvxGVCGS9e85OrX4tHMAqs2g9d/rUcRh4aBudL400t/xAQ "Charcoal – Try It Online") Note: Trailing space. Link is to verbose version of code. Explanation:
```
   Ｓ            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
```
[Answer]
# [Pip](https://github.com/dloscutoff/pip) `-s`, 11 bytes
```
J_@>,#_Mq^s
```
Takes the space-separated list of words from stdin. [Try it online!](https://tio.run/##K8gs@P/fK97BTkc53rcwrvj//5zE4tQihaTEkv@6xQA "Pip – Try It Online")
### Explanation
```
             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
```
[Answer]
# [Python 2](https://docs.python.org/2/), 63 bytes
```
lambda s:' '.join(map(g,s.split()))
g=lambda s:s and s+g(s[1:])
```
[Try it online!](https://tio.run/##TcrBCsIwDADQ@74ityQoAz0O9iXqIaNdV8m60gTBr6@34fXx6te3o9z7Oj@7yr4EAZsQcHwfudAuldLVRquanZh5SPO5DKQEsEsie9ymF/facnFYCbMqxKjIw0kqFhss4v8YpPkGHwmxIfcf "Python 2 – Try It Online")
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), 6 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
±［±］⇵］
```
[Try it here!](https://dzaima.github.io/Canvas/?u=JUIxJXVGRjNCJUIxJXVGRjNEJXUyMUY1JXVGRjNE,i=JTVCJTIybGFzZXIlMjIlMkMlMjAlMjJiYXQlMjIlNUQ_,v=8)
[5 bytes](https://dzaima.github.io/Canvas/?u=JUIxJXVGRjNCJXVGRjNEJXVGRjNEJUIx,i=JTVCJTIybGFzZXIlMjIlMkMlMjAlMjJiYXQlMjIlNUQ_,v=8) with a crazy output format
[Answer]
# C#, 111 90 bytes
```
b=>string.Join(" ",(b.Split(' ').Select(x=>string.Concat(x.Select((y, i)=>x.Substring(i))))))
```
[Try it Online!](https://tio.run/##hZDBSgMxEIbveYphL01gDXheW5CCgiiILXgQD9PssBtMkzXJlhbps69po3UpFP9DwvzzzTAzKlwp52nog7YNLHYh0rpi40jOnTGkonY2yHuy5LU6Ix61/TyzlrSN51brCetkyCWGj1AxZnFNoUNFME/NnaHbrrtmXwySlMEQ4Nm7xuP66GT/oBAxagUbp2t4Qm15iD71fXsH9E0QJ@6v4qC73qqbTJaQ/xkgTIfVdJZD@eBSswKKkq/kojM68glMhFzQ4QB8e@LSuAqT8ZvhuxK0mM6S0a8yw7U4akh7jqf42VS@eh0pHY448qIlY1whRPU/WqOPLWywJn@x4CXd@ciP8nuW3z0bvgE)
By Changing input and output to arrays, I saved a few bytes:
```
b=>b.Select(x=>string.Concat(x.Select((y,i)=>x.Substring(i)))).ToArray()
```
[Try it Online!](https://tio.run/##nVGxasMwEN31FYcnG1xB59SGEGihtFAaQ4fS4SIfsagjpZKSxgR/u3uJ49Z4yNA3CN27p6d7kvI3yjrqdl6bNSwbH2gzE@NKLmxdkwraGi8fyJDTaqJ40uZrQhV0CFOqcoQlE7JA/@lnQhjckN@iIliwua1pvt3eiqMAhqrRe3hxdu1wc2Z6/gQfMGgFe6tLeEZtYh8c@75/ALq1T351fydOuN8ZdTcoUxh2OSBk0K2yfCWXdEoaH7K873J2o5CJoRM3qU6ynOvdqpfEOmHIws6dwyZOOs41vvWSTL45HYgfii7DykfLg0cQpRgb@ubZjxBVVNc2gpYdZ/93KdGFKkoh2mNJ7prdK3/I2W3Ub0W/tqL7AQ)
[Answer]
# [K (oK)](https://github.com/JohnEarnest/ok), ~~17~~ 13 bytes
```
{,/|:'|,\|x}'
```
[Try it online!](https://tio.run/##y9bNz/7/P81KSUFJv1pHv8ZKvUYnpqaiVv1/moKGUmZOjpK1UmoqiMxJLE4tAtJJiSVAMiWxqCQDSJclpgBFNf8DAA "K (oK) – Try It Online")
Prefix anonymous function; Input is taken as a list of strings, which in turn are lists of characters.
Thanks @streetster for 4 bytes.
### How:
```
{,/|:'|,\|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")
```
[Answer]
# [Common Lisp](http://www.clisp.org/), 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)))))
```
[Try it online!](https://tio.run/##TY9LDgIxDEOvEpUFznnYskFtRlSK@kmLOP4QZlDFzrGjZzlqHm3fkWR7FTIMRqwlAVJSo8ElK/vRFVu2Md253G/tEYXRLJdIgQLDYHKEzJjoLv4tN098J@jiL6Qu5ORfr37lPBvWF6OfTD2Yu1fEKhaFwlNUK72raQp09UnT8w8 "Common Lisp – Try It Online")
This is my first try at golfing any edits are welcome 
[Answer]
# [Lua](https://www.lua.org), 70 bytes
```
for i=1,#arg do x=arg[i]for i=1,#x do io.write(x:sub(i))end print()end
```
[Try it online!](https://tio.run/##yylN/P8/Lb9IIdPWUEc5sShdISVfocIWyIjOjIWLV4BEM/P1yosyS1I1KqyKS5M0MjU1U/NSFAqKMvNKNEDM////Z6Tm5OT/L88vykkBAA "Lua – Try It Online")
### Explanation
The arguments in Lua are stored in the table `arg` starting at index 1. The unary operator `#` returns the size of the table and function `s:sub(a,b)` returns a substring
based on string `s` delimited by integers `a` and `b`, if b is not passed it will return the rest of the string.
I had to use `io.write()` instead of `print()` to avoid line breaking, and added `print()` at the end for the opposite reason.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~79~~ 74 bytes
*-5 bytes thanks to mypetlion*
```
print(*map(lambda x:''.join(x[n:]for n in range(len(x))),input().split()))
```
[Try it online!](https://tio.run/##DchBDkBADADAr/SmFXFx8xVxWLGoVNusFbx@OU0y/ubNtCvFE2vG@giOEo5pDvD0VdXuxorPoP24WAIFVkhB14gS/yeihtWvjNSeLvxLVMoWRQxuSzJ/ "Python 3 – Try It Online")
A full program that takes input from stdin and outputs to stdout.
]