[Question]
  [
Given an ASCII string, output the exploded suffixes of it. For example, if the string was `abcde`, there are 5 suffixes, ordered longest to shortest:
```
abcde
bcde
cde
de
e
```
Each suffix is then *exploded*, meaning each character is copied as many times as its one-indexed location in that suffix. For example, exploding the suffixes of `abcde`,
```
abcde
12345
abbcccddddeeeee
bcde
1234
bccdddeeee
cde
123
cddeee
de
12
dee
e
1
e
```
Altogether, the exploded suffixes of `abcde` are
```
abbcccddddeeeee
bccdddeeee
cddeee
dee
e
```
## Rules
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so the shortest code wins.
* The input will consist of the printable ASCII characters. (This excludes newlines but includes spaces.)
* The output will have each string on a separate line.
* Trailing spaces are allowed on each line and there may be an extra newline at the end.
## Test Cases
```
''
'a'
a
'bc'
bcc
c
'xyz'
xyyzzz
yzz
z
'code-golf'
coodddeeee-----ggggggooooooollllllllfffffffff
oddeee----gggggoooooolllllllffffffff
dee---ggggooooollllllfffffff
e--gggoooolllllffffff
-ggooollllfffff
goolllffff
ollfff
lff
f
's p a c e'
s  ppp    aaaaa      ccccccc        eeeeeeeee
 pp   aaaa     cccccc       eeeeeeee
p  aaa    ccccc      eeeeeee
 aa   cccc     eeeeee
a  ccc    eeeee
 cc   eeee
c  eee
 ee
e
```
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 5 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ṫJxJY
```
[Try it online!](http://jelly.tryitonline.net/#code=4bmrSnhKWQ&input=&args=cyBwIGEgYyBl) or [verify all test cases](http://jelly.tryitonline.net/#code=4bmrSnhKWQrDh-KCrGrigJzCtsK2&input=&args=JycsICdhJywgJ2JjJywgJ3h5eicsICdjb2RlLWdvbGYnLCAncyBwIGEgYyBlJw).
### How it works
```
ṫJxJY  Main link. Argument: s (string)
 J     Indices; yield I := [1, ..., len(s)].
ṫ      Tail; get the suffixes of s starting at indices [1, ..., len(s)].
   J   Indices; yield I again.
  x    Repeat. The atom 'x' vectorizes at depth 1 (1D arrays of numbers/characters)
       in its arguments. This way, each suffix t gets repeated I times, meaning
       that the first character of t is repeated once, the second twice, etc.
       If left and right argument have different lengths, the longer one is
       truncated, so I can safely be applied to all suffixes.
    Y  Join, separating by linefeeds.
```
[Answer]
# J, ~~22~~ ~~12~~ 8 bytes
*Thanks to miles for saving 14 bytes!*
```
(#~#\)\.
```
Now this is a really nice solution. Pretty succinct, too.
This is the hook `#~#\` applied to the suffixes (`\.`) of the input. The hook, when called on input `y`, is decomposed as thus:
```
(#~#\) y
y #~ #\ y
```
Here are some intermediate results:
```
   ]s =: 's p a c e'
s p a c e
   #\ s
1 2 3 4 5 6 7 8 9
   (quote) s
's p a c e'
   (quote;#)\ s
+-----------+-+
|'s'        |1|
+-----------+-+
|'s '       |2|
+-----------+-+
|'s p'      |3|
+-----------+-+
|'s p '     |4|
+-----------+-+
|'s p a'    |5|
+-----------+-+
|'s p a '   |6|
+-----------+-+
|'s p a c'  |7|
+-----------+-+
|'s p a c ' |8|
+-----------+-+
|'s p a c e'|9|
+-----------+-+
   1 2 3 # '123'
122333
   3 3 3 # '123'
111222333
   ]\. s
s p a c e
 p a c e
p a c e
 a c e
a c e
 c e
c e
 e
e
   quote\. s
's p a c e'
' p a c e'
'p a c e'
' a c e'
'a c e'
' c e'
'c e'
' e'
'e'
   (#~#\) s
s  ppp    aaaaa      ccccccc        eeeeeeeee
   (#~#\)\. s
s  ppp    aaaaa      ccccccc        eeeeeeeee
 pp   aaaa     cccccc       eeeeeeee
p  aaa    ccccc      eeeeeee
 aa   cccc     eeeeee
a  ccc    eeeee
 cc   eeee
c  eee
 ee
e
```
## Test cases
```
   f =: (#~#\)\.
   f
(#~ #\)\.
   f ''
   f 'a'
a
   f 'bc'
bcc
c
   f 'xyz'
xyyzzz
yzz
z
   f 'code-golf'
coodddeeee-----ggggggooooooollllllllfffffffff
oddeee----gggggoooooolllllllffffffff
dee---ggggooooollllllfffffff
e--gggoooolllllffffff
-ggooollllfffff
goolllffff
ollfff
lff
f
   f 's p a c e'
s  ppp    aaaaa      ccccccc        eeeeeeeee
 pp   aaaa     cccccc       eeeeeeee
p  aaa    ccccc      eeeeeee
 aa   cccc     eeeeee
a  ccc    eeeee
 cc   eeee
c  eee
 ee
e
   ]tc =: <;._1 '|' , '|a|bc|xyz|code-golf|s p a c e'
++-+--+---+---------+---------+
||a|bc|xyz|code-golf|s p a c e|
++-+--+---+---------+---------+
   ,. f &. > tc
+---------------------------------------------+
+---------------------------------------------+
|a                                            |
+---------------------------------------------+
|bcc                                          |
|c                                            |
+---------------------------------------------+
|xyyzzz                                       |
|yzz                                          |
|z                                            |
+---------------------------------------------+
|coodddeeee-----ggggggooooooollllllllfffffffff|
|oddeee----gggggoooooolllllllffffffff         |
|dee---ggggooooollllllfffffff                 |
|e--gggoooolllllffffff                        |
|-ggooollllfffff                              |
|goolllffff                                   |
|ollfff                                       |
|lff                                          |
|f                                            |
+---------------------------------------------+
|s  ppp    aaaaa      ccccccc        eeeeeeeee|
| pp   aaaa     cccccc       eeeeeeee         |
|p  aaa    ccccc      eeeeeee                 |
| aa   cccc     eeeeee                        |
|a  ccc    eeeee                              |
| cc   eeee                                   |
|c  eee                                       |
| ee                                          |
|e                                            |
+---------------------------------------------+
```
[Answer]
## Python, 61 bytes
```
f=lambda s,i=0:s[i:]and-~i*s[i]+f(s,i+1)or s and'\n'+f(s[1:])
```
Alternative 63:
```
f=lambda s,b=1:s and f(s[:-1],0)+s[-1]*len(s)+b*('\n'+f(s[1:]))
```
[Answer]
# Python 3, ~~91~~ ~~68~~ 65 bytes
```
def f(s):f(s[1:print(''.join(i*c for i,c in enumerate(s[0]+s)))])
```
Terminates with an error after printing the desired output. Test it on [Ideone](http://ideone.com/zTQWcK).
### How it works
Before **f** can call itself recursively, the indices of `s[1:...]` have to be computed.
First `enumerate(s[0]+s)` yields all pairs **(i, c)** of characters **c** of **s** – with its first character duplicated – and the corresponding indices **i**. Prepending `s[0]` serves two purposes here.
* The first character of **s** has to be repeated once, but the first index is **0**.
* Once all characters have been processed, `s[0]` will raise an *IndexError*, causing **f** to terminate with an error rather than printing newlines until the recursion limit is reached.
`''.join(i*c for i,c in ...)` builds a flat string of each **c** repeated **i** times, which `print` echoes to STDOUT.
Finally, since `print` returns *None* and `s[1:None]` is simply `s[1:]`, the recursive call `f(s[1:...])` repeats the above process for **s** without its first character.
[Answer]
# [Perl 6](https://perl6.org), 38 bytes
```
m:ex/.+$/.map:{put [~] .comb Zx 1..*}
```
37 bytes + 1 for `-n` command line switch
## Example:
```
$ perl6 -ne 'm:ex/.+$/.map:{put [~] .comb Zx 1..*}' <<< 'code-golf'
coodddeeee-----ggggggooooooollllllllfffffffff
oddeee----gggggoooooolllllllffffffff
dee---ggggooooollllllfffffff
e--gggoooolllllffffff
-ggooollllfffff
goolllffff
ollfff
lff
f
```
## Expanded:
```
# -n command line switch takes each input line and places it in ｢$_｣
# You can think of it as surrounding the whole program with a for loop
# like this:
for lines() {
  # match
  m
  :exhaustive # every possible way
  / .+ $/     # at least one character, followed by the end of the string
  .map:
  {
    put           # print with newline
      [~]         # reduce using string concatenation ( don't add spaces between elements )
        .comb     # split into individual chars
        Z[x]      # zip using string repetition operator
        1 .. *    # 1,2,3,4 ... Inf
  }
}
```
[Answer]
# [Brachylog](http://github.com/JCumin/Brachylog), 17 bytes
```
@]Elyk:Erz:jac@w\
```
[Try it online!](http://brachylog.tryitonline.net/#code=QF1FbHlrOkVyejpqYWNAd1w&input=ImNvZGUtZ29sZiI)
### Explanation
```
@]E                 E is a suffix of the Input
   lyk              The list [0, ..., length(E) - 1]
      :Erz          The list [[0th char of E, 0], ..., [Last char of E, length(E) - 1]]
          :ja       For all elements of that list, concatenate the Ith char I times to itself
             c      Concatenate the list into a string
              @w    Write followed by a line break
                \   False: backtrack to another suffix of the Input
```
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), 13 bytes
```
.sRvyvyN>×}J,
```
[Try it online!](http://05ab1e.tryitonline.net/#code=LnNSdnl2eU4-w5d9Siw&input=Y29kZS1nb2xm)
**Explanation**
```
.s              # push list of suffixes of input
  R             # reverse the list
   vy           # for each string
     vy   }     # for each char in string
       N>×      # repeat it index+1 times
           J,   # join and print with newline
```
[Answer]
## [CJam](http://sourceforge.net/projects/cjam/), 14 bytes
```
Sl+{_eee~n1>}h
```
[Try it online!](http://cjam.tryitonline.net/#code=U2wre19lZWV-bjE-fWg&input=cyBwIGEgYyBl)
### Explanation
```
Sl+   e# Read input and prepend a space.
{     e# While the string is non-empty...
  _   e#   Make a copy.
  ee  e#   Enumerate. Gives, e.g. [[0 ' ] [1 'a] [2 'b] [3 'c]].
  e~  e#   Run-length decode. Gives "abbccc".
  n   e#   Print with trailing linefeed.
  1>  e#   Discard first character.
}h
```
[Answer]
# C#, 101 bytes
```
f=s=>{var r="\n";for(int i=0;i<s.Length;)r+=new string(s[i],++i);return""==s?r:r+f(s.Substring(1));};
```
Recursive anonymous function, which also prints a leading newline. If the leading newline is not allowed, 3 extra bytes turn it into a trailing newline:
```
f=s=>{var r="";for(int i=0;i<s.Length;)r+=new string(s[i],++i);return""==s?r:r+"\n"+f(s.Substring(1));};
```
Full program with ungolfed method and test cases:
```
using System;
namespace ExplodedSuffixes
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<string, string> f = null;
            f = s =>
            {
                var r = "\n";
                for (int i = 0; i < s.Length; )
                    r += new string(s[i], ++i);
                return "" == s ? r : r + f(s.Substring(1));
            };
            
            // test cases:
            string x = "abcde";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "a";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "bc";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "xyz";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "code-golf";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "s p a c e";
            Console.WriteLine("\'" + x + "\'" + f(x));
        }
    }
}
```
[Answer]
# Haskell, 48 bytes
```
e=map(concat.zipWith replicate[1..]).scanr(:)[] 
```
is interfaced by any of
```
ghc exploded_suffixes.hs -e 'e"abcde"'
ghc exploded_suffixes.hs -e 'mapM_ putStrLn.e=<<getLine' <<<code-golf
ghc exploded_suffixes.hs -e 'Control.Monad.forever$putStr.unlines.e=<<getLine'
```
[Answer]
## Perl, 36 + 1 (`-n`) = 37 bytes
```
/.+$(?{$.=say$&=~s%.%$&x$.++%rge})^/
```
Needs `-n` and `-E` (or `-M5.010`) to run :
```
perl -nE '/.+$(?{$.=say$&=~s%.%$&x$.++%rge})^/' <<< "code-golf"
```
Note that it works on only one instance each time you run it (because it uses the variable `$.` which is incremented every time a line is read, so it hold `1` only the first time a line is read). (But no problem here, just `^D` and re-run it!)
[Answer]
# [Retina](http://github.com/mbuettner/retina), 31 bytes
Byte count assumes ISO 8859-1 encoding.
```
M&!`.+
$.%`$*»
%+r`»($|.)
$1$1
```
[Try it online!](http://retina.tryitonline.net/#code=TSYhYC4rCgokLiVgJCrCuwolK3JgwrsoJHwuKQokMSQx&input=cyBwIGEgYyBl)
[Answer]
# Java, ~~150~~ 127 bytes
Edit:
* ***-23** bytes off. Thanks to @Kevin Cruijssen*
Snipet:
```
f->{String s[]=f.split(""),o="";int i=-1,j,l=s.length;for(;++i<l;)for(j=-2;++j<i;o+=s[i]);return l<1?"":o+"\n"+f.substring(1);}
```
Ungolfed:
```
public static String explodeSuff(String suff){
  char [] s = suff.toCharArray();
  String out = "";
  if(s.length==0)return "";
  for(int i=-1;++i<s.length;){
    for(int j=-2;++j<i;){
      out+=s[i];
    }
  }
  return out+"\n"+suff.subString(1);
}
```
[Answer]
## Racket 184 bytes
```
(let p((l(string->list s))(ol'()))(cond[(null? l)(display(list->string(flatten ol)))]
[else(p(cdr l)(append ol(list #\newline)(for/list((i l)(n(length l)))(for/list((j(+ 1 n)))i))))]))
```
Ungolfed: 
```
(define(f s)
 (let loop((l(string->list s))
             (outl '()))
    (cond
      [(null? l)
       (display
        (list->string
         (flatten outl)))]
      [else
       (loop
        (rest l)
        (append outl
                (list #\newline)
                (for/list ((i l)
                           (n (length l)))
                  (for/list ((j (add1 n)))
                    i
                    ))))]  )))
(f "abcde")
(f "xyz")
```
Output: 
```
abbcccddddeeeee
bccdddeeee
cddeee
dee
e
xyyzzz
yzz
z
```
[Answer]
## JavaScript (ES6), 65 bytes
```
f=s=>s?[s.replace(/./g,(c,i)=>c.repeat(i+1)),...f(s.slice(1))]:[]
```
```
<input oninput=o.textContent=f(this.value).join`\n`><pre id=o>
```
Previous attempts:
```
67: s=>[...s].map((_,i)=>s.slice(i).replace(/./g,(c,i)=>c.repeat(i+1)))
84: s=>s.replace(/./g,`$&$'
    `).match(/.+/g).map(s=>s.replace(/./g,(c,i)=>c.repeat(i+1)))
89: f=(s,t=s.replace(/./g,(c,i)=>c.repeat(i+1)))=>t?[]:[t,...f(s,t.replace(/(.)(?=\1)/g,''))]
```
[Answer]
# PHP, 103 bytes (99 with short tags)
```
<?php for($s=$argv[1];""!=$s[$i++];$o.="
")for($j=0;""!=$l=$s[$j+$i-1];)$o.=str_pad('',++$j,$l);echo$o;
```
I'm pretty certain this isn't the shortest possible answer.
[Answer]
# [MATL](http://github.com/lmendo/MATL), 12 bytes
```
&+gYRYs"G@Y"
```
*I love it when quote marks come together!*
[Try it online!](http://matl.tryitonline.net/#code=JitnWVJZcyJHQFki&input=J2FiY2RlJw)
### Explanation
This works by building a matrix whose columns are used, one by one, to run-length decode the input. As an example, for input `'abcde'` the matrix is
```
1 0 0 0 0
2 1 0 0 0
3 2 1 0 0
4 3 2 1 0
5 4 3 2 1
```
Code:
```
&+g    % Implicit input. NxN matrix of ones, where N is input size
YR     % Set entries above diagonal to zero
Ys     % Cumulative sum of each column. This gives the desired matrix 
"      % For each column
  G    %   Push input (for example 'abcde')
  @    %   Push current column (for example [0;0;1;2;3])
  Y"   %   Run-length decode (example output 'cddeee')
       % Implicit end
       % Implicit display
```
[Answer]
# Python 3, 95 bytes
```
def f(s):return'\n'.join(''.join(s[j:][i]*(i+1)for i in range(len(s)-j))for j in range(len(s)))
```
This was surprisingly harder than I expected it to be. I redid my whole function maybe 4 times.
[Answer]
# Java 7,140 bytes
```
void c(char[]a,int l,int j){if(l<1)return;c(a,--l,++j);for(int i=0,k;i<j;i++)for(k=0;k++<=i;)System.out.print(a[i+l]);System.out.println();}
```
# Ungolfed
```
 void c(char[]a,int l,int j)
{
if (l < 1) 
return ;
c(a , --l , ++j) ;
for(int i = 0 , k; i < j ; i++)
for(k = 0 ; k++ <= i ;)
System.out.print(a[i+l]);
System.out.println();
}
```
Following line giving me very pain.i don't know how can i golfed it(because there are two loops to break the condition to put `"\n"` in print statement).
  
`System.out.println();` 
[Answer]
## Pyke, 12 bytes
```
VilS],A*s
}t
```
[Try it here!](http://pyke.catbus.co.uk/?code=VilS%5D%2CA%2as%0A%7Dt&input=abcde)
[Answer]
# Ruby, 51 bytes
Uses the `-n` flag for +1 byte.
```
(k=0;puts$_.gsub(/./){$&*k+=1};$_[0]="")while$_>$/
```
[Answer]
# R, 108 bytes
Read input from stdin and prints to stdout
```
s=scan(,"");n=nchar(s);for(i in 1:n)cat(do.call("rep",list(strsplit(s,"")[[1]][i:n],1:(n-i+1))),"\n",sep="")
```
I felt the use of `do.call` was appropriate here. It basically takes two inputs: 1. a function name in form of a string (`rep` here) and a list of arguments and 2. iteratively applies calls the function using the arguments in the list.
E.g.:
* `rep("c",3)` produces the vector `"c" "c" "c"`
* `do.call("rep",list(c("a","b","c"),1:3))` produces the vector `"a" "b" "b" "c" "c" "c"`
* which is equivalent to consecutively calling `rep("a",1)`, `rep("b",2)` and `rep("c",3)`
[Answer]
# Vim, 43 bytes
`qqYlpx@qq@qqr0<C-H><C-V>{$:s/\v%V(.)\1*/&\1/g<CR>@rq@r`
First macro separates the suffixes, second macro "explodes" them. Likely beatable. Spaces are annoying.
[Answer]
# C, 186 Bytes
```
#include <string.h>
#define S strlen
p(char* s){char *t=s;char u[999]="";for(int i=0;i<S(s);i++){for(int j=i+1;j>0;j--){sprintf(u+S(u),"%c",*t);}t++;}printf("%s\n",u);if(S(s)>1)p(s+1);}
```
This probably can be shortened quite a bit, but I just wanted to try it. It's my second try at golf, so give me any pointers (\*lol) you can. It takes a string as a parameter and does the exploding from there. u is used as a buffer that stores the exploded string.
Ungolfed:
```
#include <string.h>
#define S strlen 
p(char* s){
    char *t=s;
    char u[999]="";
    for(int i=0;i<S(s);i++){
        for(int j=i+1;j>0;j--){
            sprintf(u+S(u),"%c",*t);
        }
        t++;
    }
    printf("%s\n",u);
    if(S(s)>1)p(s+1);
}
```
[Answer]
## [*Acc!!*](https://codegolf.stackexchange.com/a/62493/16766), 150 bytes
Expects input on stdin, terminated with a tab character.
```
N
Count c while _/128^c-9 {
_+N*128^(c+1)
}
Count i while _-9 {
Count j while _/128^j-9 {
Count k while j+1-k {
Write _/128^j%128
}
}
Write 10
_/128
}
```
### Explanation
This is actually a pretty good task for *Acc!!*, since it only requires reading a string and iterating over it with some nested loops. We read the string into the accumulator, treating it as a sequence of base-128 digits, with the first character on the low-order end. After the opening `Count c` loop, the accumulator value can be conceptualized like this (using `xyz` as example input):
```
128^   3  2  1  0
     tab  z  y  x
```
(The actual accumulator value for this example is `9*128^3 + 122*128^2 + 121*128 + 120` = `20888824`.)
We can then iterate over the string by iterating over increasing powers of 128. And we can iterate over the suffixes by dividing the accumulator by 128 after each iteration, chopping off a character.
With indentation and comments:
```
# Initialize the accumulator with the first input character
N
# Loop until most recent input was a tab (ASCII 9)
Count c while _/128^c - 9 {
    # Input another character and add it at the left end (next higher power of 128)
    _ + N * 128^(c+1)
}
# Loop over each suffix, until only the tab is left
Count i while _ - 9 {
    # Loop over powers of 128 until the tab
    Count j while _/128^j - 9 {
        # Loop (j+1) times
        Count k while j + 1 - k {
            # Output the j'th character
            Write _ / 128^j % 128
        }
    }
    # Output a newline
    Write 10
    # Remove a character
    _/128
}
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `j`, 6 bytes
```
ÞKvÞżṠ
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyJqIiwiIiwiw55LdsOexbzhuaAiLCIiLCJjb2RlLWdvbGYiXQ==)
[Answer]
# [Knight](https://github.com/knight-lang/knight-lang), 48 bytes
```
;=xP Wx;=iF;W<=i+1i+1LxO+*Gx-iT1i"\";O""=xSxF1""
```
[Try it online!](https://knight-lang.netlify.app/#WyI7PXhQIFd4Oz1pRjtXPD1pKzFpKzFMeE8rKkd4LWlUMWlcIlxcXCI7T1wiXCI9eFN4RjFcIlwiIiwiY29kZS1nb2xmIl0=)
]