text:
Tower of strings
Given a string of text, output it as a 'tower'.
Each slice of the string (of the form 0:n) is repeated 5*n times, so the first character is repeated 5 times, then the first and the second 10 times, etc.
Examples:
'hello' ->

['h']
['h']
['h']
['h']
['h']
['h', 'e']
['h', 'e']
['h', 'e']
['h', 'e']
['h', 'e']
['h', 'e']
['h', 'e']
['h', 'e']
['h', 'e']
['h', 'e']
['h', 'e', 'l']
['h', 'e', 'l']
['h', 'e', 'l']
['h', 'e', 'l']
['h', 'e', 'l']
['h', 'e', 'l']
['h', 'e', 'l']
['h', 'e', 'l']
['h', 'e', 'l']
['h', 'e', 'l']
['h', 'e', 'l']
['h', 'e', 'l']
['h', 'e', 'l']
['h', 'e', 'l']
['h', 'e', 'l']
['h', 'e', 'l', 'l']
['h', 'e', 'l', 'l']
['h', 'e', 'l', 'l']
['h', 'e', 'l', 'l']
['h', 'e', 'l', 'l']
['h', 'e', 'l', 'l']
['h', 'e', 'l', 'l']
['h', 'e', 'l', 'l']
['h', 'e', 'l', 'l']
['h', 'e', 'l', 'l']
['h', 'e', 'l', 'l']
['h', 'e', 'l', 'l']
['h', 'e', 'l', 'l']
['h', 'e', 'l', 'l']
['h', 'e', 'l', 'l']
['h', 'e', 'l', 'l']
['h', 'e', 'l', 'l']
['h', 'e', 'l', 'l']
['h', 'e', 'l', 'l']
['h', 'e', 'l', 'l']
['h', 'e', 'l', 'l', 'o']
['h', 'e', 'l', 'l', 'o']
['h', 'e', 'l', 'l', 'o']
['h', 'e', 'l', 'l', 'o']
['h', 'e', 'l', 'l', 'o']
['h', 'e', 'l', 'l', 'o']
['h', 'e', 'l', 'l', 'o']
['h', 'e', 'l', 'l', 'o']
['h', 'e', 'l', 'l', 'o']
['h', 'e', 'l', 'l', 'o']
['h', 'e', 'l', 'l', 'o']
['h', 'e', 'l', 'l', 'o']
['h', 'e', 'l', 'l', 'o']
['h', 'e', 'l', 'l', 'o']
['h', 'e', 'l', 'l', 'o']
['h', 'e', 'l', 'l', 'o']
['h', 'e', 'l', 'l', 'o']
['h', 'e', 'l', 'l', 'o']
['h', 'e', 'l', 'l', 'o']
['h', 'e', 'l', 'l', 'o']
['h', 'e', 'l', 'l', 'o']
['h', 'e', 'l', 'l', 'o']
['h', 'e', 'l', 'l', 'o']
['h', 'e', 'l', 'l', 'o']
['h', 'e', 'l', 'l', 'o']

'cat' ->

['c']
['c']
['c']
['c']
['c']
['c', 'a']
['c', 'a']
['c', 'a']
['c', 'a']
['c', 'a']
['c', 'a']
['c', 'a']
['c', 'a']
['c', 'a']
['c', 'a']
['c', 'a', 't']
['c', 'a', 't']
['c', 'a', 't']
['c', 'a', 't']
['c', 'a', 't']
['c', 'a', 't']
['c', 'a', 't']
['c', 'a', 't']
['c', 'a', 't']
['c', 'a', 't']
['c', 'a', 't']
['c', 'a', 't']
['c', 'a', 't']
['c', 'a', 't']
['c', 'a', 't']

Rules:
You can output each layer as a list of characters or just a string of them joined together.

welcome to PPCG! Nice challenge.

I tried to clean up the formatting and explain the challenge a little bit better. Did I understand the challenge right?

Can we take the input as a list of characters ?

Can we output a 2D-array of strings like so: [["c","c","c","c","c"],["ca","ca","ca","ca","ca","ca","ca","ca","ca","ca"],...]?

Are outputs with leading or trailing newlines acceptable? Can we assume inputs do not contain newlines?

I assume that an empty string will display a single white space or no characters?

Does it need to actually print, or just return the output?

It has to print

R, 48 bytes
function(s)substring(s,1,rep(x<-1:nchar(s),x*5))

Try it online!
Returns a list of strings.

I had missed the obvious golf here! nice solution I tried different approaches but so far all are far longer than this.

05AB1E, 6 bytes
ηā5*ÅΓ

Try it online!
Returns a list of string.
Explanation
     ÅΓ # Run-length decode...
η       # ... the prefixes of the input
 ā5*и   # ... with the length range multiplied by 5 -- [5, 10, 15, 20, 25]

@KevinCruijssen Thanks for noticing that ! I should not golf in the morning without a coffee first :-(

Using run length decoding saves 3 bytes: ηā5*ÅΓ

@Adnan Brilliant, thanks ! I think it deserves its own answer though, you've reduced the byte count by 33%...
I'll revert to my original solution if you decide to post it yourself.

Nice one, I had ηvyg5*Fy= for 8.

Haskell, 36 bytes
f""=[]
f s=f(init s)++(s<$s<*[1..5])

Try it online!

Canvas, 6 bytes
［³５×＊Ｐ

Try it here!
Explanation:
[      for each prefix
 ³5×     1-indexed counter * 5
    *    repeat the prefix vertically that many times
     P   and print that

Stax, 8 bytes
äï▄;♫├W^

Run and debug it
Unpacked, ungolfed, and commented, it looks like this.
|[F for each prefix of the input
  i^5*  5*(i+1) where i is the iteration index
  DQ    that many times, peek and print to output

Run this one

TI-Basic (TI-84 Plus CE), 29 bytes (27 tokens)
For(A,1,length(Ans
For(B,1,5A
Disp sub(Ans,1,A
End
End

Explanation:
For(A,1,length(Ans # 9 bytes, 8 tokens: for A from 1 to the length of the string
For(B,1,5A         # 8 bytes, 8 tokens:  5*A times
Disp sub(Ans,1,A   # 9 bytes, 8 tokens:   Print the first A characters of the string
End                # 2 bytes, 2 tokens:  end loop
End                # 1 byte,  1 token:  end loop

Retina, 15 bytes
.
$.>`*5*$($>`¶

Try it online! Link includes test cases. Explanation:
.

Match each character in the string.
$.>`*5*$($>`¶

$` is the prefix of the match. Retina then provides two modifiers, > modifies it to be in the context of the string between successive matches, while . takes the length. We therefore start with the prefix of the suffix, which is equivalent to the match including its prefix. This saves 2 bytes over using overlapping matches. The $( then concatenates that with a newline, the 5* repeats it, and then the $.>` repeats it a further number of times given by its length.

Brachylog, 15 bytes
a₀ᶠ⟨gj₎{l×₅}⟩ᵐc

Try it online!
The final c can be removed if OP replies positively to the question about outputting 2D arrays.

Cubix,  44  40 bytes
i.!?@UBqwW_#/>u...;B^...?qo;;q*n5;oN/./)

Try it online!
This still has a lot of no-ops, but it is a little better than before.
As a very brief description, a character is grabbed from input and tested for EOI (-1), halt if it is.  The stack is then reversed.  Get the number of items on the stack and multiple by -5.  Drop that to the bottom of the stack and clean up.  Loop through the stack, printing, until a negative number.  Print newline, increment the number, if 0 drop the zero, reverse stack and start from input again, otherwise loop through the stack, printing, until a negative number ... ad nauseum
Cubified it looks like
      i . !
      ? @ U
      B q w
W _ # / > u . . . ; B ^
. . . ? q o ; ; q * n 5
; o N / . / ) . . . . .
      . . .
      . . .
      . . .

Watch it online

Jelly, 8 bytes
¹Ƥx'J×5Ɗ

Try it online!
J×5x'@¹Ƥ

Try it online!
¹Ƥx'Jx'5

Try it online!
This is likely golfable.

A slightly different 8 is +\ẋ"Jx5Ẏ

JavaScript, 48 46 bytes
(thanks @redundancy)
Edit: The author clarified and this answer is now not valid, but I will leave it here unchanged.
Returns an array of multi-line strings.
s=>[...s].map(c=>(q+=c).repeat(5*++i),i=q=`
`)

Try it

f = s=>[...s].map(c=>(q+=c).repeat(5*++i),i=q=`
`);

console.log( f("hello").join`` );

Potential strategy:
It didn't help me much, but maybe someone can use this:
The number of characters at (0-indexed) line i is floor(sqrt(2/5*i+1/4)+1/2), which is golfed in JavaScript as (.4*i+.25)**.5+.5|0.
For a string of length n, there are n*(n+1)*5/2 lines.
Perhaps:
s=>{for(i=0;(n=(.4*i+++.25)**.5+.5|0)<=s.length;)console.log(s.slice(0,n))}

Assuming your output format is valid according to the challenge, you can save 2 bytes as demonstrated here: Try it online!

Python 3, 43 41 bytes
Thanks to ovs for saving 2 bytes!
Code
f=lambda x:[*x]and f(x[:-1])+[x]*5*len(x)

Try it online!

Haskell, 46 43 42 bytes
f s=do n<-[1..length s];take n s<$[1..n*5]

Try it online!
Sadly inits requires import Data.List, so
import Data.List
((<$)<*>(>>[1..5])=<<).inits

with its 45 bytes is longer.
Edit: -1 byte thanks to @BWO.

Charcoal, 11 bytes
Ｆ⊕ＬθＥ×⁵ι…θι

Try it online! Link is to verbose version of code. Output includes 0 repetitions of the zero-length substring. Explanation:
   θ          Input string
  Ｌ           Length
 ⊕            Incremented
Ｆ             Loop over implicit range
      ⁵       Literal 5
       ι      Current index
     ×        Multiply
    Ｅ         Map over implicit range
         θ    Input string
          ι   Current index
        …     Chop to length
              Implicitly print each string on its own line

Husk, 8 bytes
ΣzoR*5Nḣ

Try it online!
Explanation
Σz(R*5)Nḣ  -- example input: "ab"
        ḣ  -- non-empty prefixes: ["a","ab"]
 z(   )N   -- zip with [1..]
    *5     -- | multiply by 5
   R       -- | replicate
           -- : [["a","a","a","a","a"],["ab","ab","ab","ab","ab","ab","ab","ab","ab","ab"]]
Σ          -- concat: ["a","a","a","a","a","ab","ab","ab","ab","ab","ab","ab","ab","ab","ab"]

C (gcc), 67 bytes
i,j;f(char*s){for(i=0;s[i++];)for(j=5*i;j--;)printf("%.*s\n",i,s);}

Try it online!

Ruby, 46 42 bytes
->s{(1..s.size).map{|i|puts [s[0,i]]*i*5}}

Try it online!

PowerShell, 40 20 25 bytes
Score cut in half thanks to mazzy
+5 bytes thanks to AdmBorkBork pointing out the specs
$args|%{,($s+=$_)*5*++$i}

Try it online!
Takes input via splatting. Works by building the string by adding the next character to itself, converts it to a one element array, and then repeats it 5*i times.

param is very expensive. Try to avoid it

@mazzy Dang, trying to save the index instead of the char itself led me astray. Thanks.

@AdmBorkBork Ha ha, whoops. Should be fixed now

MATL, 12 bytes
f"G@:)@5*1X"

Try it online!
f               % Get the indices of input i.e. range 1 to length(input)
 "              % For loop over that
   G            % Push input string
    @           % Push current loop index
     :          % Range 1 to that
      )         % Index at those positions (substring 1 to i)
       @5*      % Multiply loop index by 5
          1X"   % Repeat the substring that many times rowwise
                % Results collect on the stack and are
                %  implicitly output at the end

V, 17 bytes
òïç$îî/6Ä
Hl$xòxú

Expects inputs without newlines, and outputs with superfluous leading newlines.
I can remove this entry if input/output violates the challenge spec.
Try it online!
21 bytes
òïç$îî/6Ä
Hl$xòxíîî/ò

Expects inputs without newlines, but outputs with only one leading and trailing newline.
Explanation
Differing substrings are separated with two consecutive newlines so that
linewise duplication only applies to lines matching the regex $\n\n.
When the duplication command (Ä) is supplied a count, e.g. 6Ä, (I think) it
deletes the current line before pasting n times, thus only appearing to append n - 1 copies.
ò         | recursively...
 ï        | . append newline
  ç       | . globally search lines matching...
   $îî    | . . compressed version of $\n\n regex
      /6Ä | . . duplicate to create 6 copies
H         | . go to first line
 l        | . move cursor right 1 char
          | . . if current line is 1 char long, errors out of recursion
  $x      | . delete 1 char from end of current line
    ò     | ...end
     x    | delete extra 1-char substring
      ú   | sort so that newlines rise to top

APL (Dyalog Unicode), 14 bytesSBCS
{↑(5×⍳≢⍵)/,\⍵}

Try it online!
My first apl post so please let me know if you have any suggestions
How it works:
{↑(5×⍳≢⍵)/,\⍵}
          ,\⍵  - Prefixes of the input
         /      - Repeated
     ⍳≢⍵        - By a list of indices the same length as the input
   5×           - Times 5
 ↑              - Separate into rows

↑ isn't really Separate into rows but rather Combine [list of lists] into rows [of a matrix], or more technically Increase rank at the expense of depth.

Wenyan, 350 326 308 bytes
吾有一術名之曰「A」欲行是術必先得一言曰「B」是術曰有數零名之曰「C」吾有一言名之曰「D」凡「B」中之「E」加五於「C」昔之「C」者今其是矣加「E」於「D」昔之「D」者今其是矣為是「C」遍夫「D」書之云云云云是謂「A」之術也

IDE
Just seen this programming language on GitHub, so I'll have a try. There is no equivalent for "process.argv", so I have to write this as a function, but then the boilerplate 吾有一術名之曰「X」欲行是術必先得一言曰「X」乃行是術曰...是謂「X」之術也 itself (114 bytes) is just too long.
Each variable has to be at least 7 bytes (the brackets themselves take 6 bytes), and a string takes 12 bytes + length of string to achieve. Of course I can trivially put something like 施「eval」於「「a=>[...a].map(_=>(a.slice(0,++i)+'\\n').repeat(i*5),i=0).join``」」 (91 bytes) but that's boring (why not use JavaScript then?)
Explanation
function A(B) {
 var C = 0, D = "";
 for (var E of B) {
  C = C + 5;
  D = D + E;
  for (var i = 0; i < C; i++)
   console.log(D);
 }
}

326->308 乃行 before 是術曰 is optional so it's removed, and 吾有一言曰「D」 is replaced by 夫「D」 to recall the variable.

Japt, 15 12 bytes
-3 bytes from @Shaggy
£¯°Y +R pY*5

Try it online!

12 bytes (including a small fix)

Perl 6, 25 bytes
{(1..*X*5)RZxx[\~] .comb}

Try it online!
Anonymous code block that returns a list of list of strings.
If you want it as a 1D array, you can append flat in front like so:
{flat (1..*X*5)RZxx[\~] .comb}

Try it online!
Explanation:
{                       }  # Anonymous code block
                   .comb   # Split the string into a list of characters
              [\~]         # Triangular reduce the list of characters with the concatenate operator
          RZxx             # Multiply each list by:
 (1..*X*5)                 # A sequence of 5,10,15 etc.

Alternatively,
{($+=5)xx*RZxx[\~] .comb}

Try it online!
Also works for the same amount of bytes.

Perl 5, 29 bytes
map{say}($x.=$_)x($y+=5)for@F

Try it online!

Japt, 10 bytes
Awaiting confirmation as to whether the output format is acceptable (+2 bytes if not).
å+ £T±5 ÇX

Try it

Output looks reasonable to me, nicely done.

Java 10, 120 92 90 89 bytes
s->{for(int j=1,i=1;i<=s.length();i+=++j>i*5?j=1:0)System.out.println(s.substring(0,i));}

-28 bytes thanks to @OlivierGrégoire.
-1 byte thanks to @ceilingcat.
Try it online.
Explanation:
s->{                      // Method with String parameter and no return-type
  for(int j=1,            //  Repeat-integer, starting at 1
      i=1;i<=s.length()   //  Loop `i` in the range [1,length_input]
      ;                   //    After every iteration:
       i+=++j>i*5?        //     Increase `j` by 1 first with `++j`
                          //     If `j` is now larger than `i` multiplied by 5:
           j=1            //      Increase `i` by 1, and reset `j` to 1
          :               //     Else:
           0)             //      Leave `i` the same by increasing it with 0
    System.out.println(   //   Print with trailing newline:
      s.substring(0,i));} //    The prefix of size `i`

92 bytes: s->{for(int i=1,j=1;i<=s.length();i+=j++<i*5?0:+(j=1))System.out.println(s.substring(0,i));}

@OlivierGrégoire Thanks! And I've been able to golf 2 more bytes by changing using >= and ?j=1:0 instead of < and ?0:+(j=1).

Good! I was trying to get rid of it, but I kept having compilation issues. Didn't think about reverting the condition. Well done! ;)

@ceilingcat Thanks

Forth (gforth), 48 bytes
: f 1+ 1 do i 5 * 0 do dup j type cr loop loop ;

Try it online!
Explanation

Loop from 1 to string-length
for each iteration:

Loop (5 * loop index) times
Print string from beginning to outer loop index

Code Explanation
: f                \ start a new word definiton
  1+ 1             \ set up to the loop paramers from 1 to str-length
  do               \ start a counted loop
    i 5 * 0 do     \ start a second counted loop from 0 to 5*index - 1
      dup j        \ duplicate the string address and set the length to the outer index
      type         \ print character from start of string to loop index
      cr           \ output a newline
    loop           \ end inner counted loop
  loop             \ end outer counted loop
;                  \ end word definition

JavaScript, 76 bytes
s=>{for(i=1;i<=s.length;i++)for(j=0;j<5*i;j++)console.log(s.substring(0,i))}

f=s=>{for(i=1;i<=s.length;i++)for(j=0;j<5*i;j++)console.log(s.substring(0,i))}

f("cat")

Hello and welcome to PPCG.

i=1;i<=s.length;i++ can be i=0;++i<=s.length;.

brainfuck, 40 bytes
++++++++++>,[>>+++++[<<[<]>[.>]>>+<-]<,]

Try it online!
[Tape: 10 (newline), [characters], 0, rowcounter]

++++++++++> 10 (newline)
,[          for each input character
  >>+++++     add 5 to number of rows
  [           for each row
    <<[<]       go to start
    >[.>]       print newline and all previous characters
    >>+         add 1 to next rowcounter cell
    <-          decrement current rowcounter cell
  ]
  <,          input next character
]

Ruby, 37 bytes
f=->s{s[0]?f[s.chop]+[s]*s.size*5:[]}

Try it online!

Python 3, 55 bytes
lambda a:[a[:i]for i in range(len(a)+1)for j in' '*5*i]

Try it online!

Jelly, 9 bytes
WẋL×5ƊƊƤẎ

Try it online!
-2 bytes thanks to Mr. Xcoder

9 bytes.

Clean, 47 bytes
import StdEnv
$s=[repeatn(5*i)c\\c<-s&i<-[1..]]

Try it online!

Tidy, 30 bytes
{k:c(k)*5*count(k)}on prefixes

Try it online!
Returns a list of list of characters. If that is not acceptable, the following also works:
Tidy, 37 bytes
{k:out on c(k)*5*count(k)}on prefixes

Try it online!
Explanation
{k:c(k)*5*count(k)}on prefixes
{k:               }on prefixes     over each prefix k:
   c(k)                              the singleton list k
       *5                            ...repeated 5 times
         *count(k)                   ...repeated by the number of elements in the prefix

Python 2, 42 bytes
lambda s:s and f(s[:-1])+(s+'\n')*len(s)*5

Try it online!

You can return as a list of strings for 41 bytes. Or if do input and output as a list of characters,  37 bytes

bash, 89 bytes (or 158 bytes for extra complex output shown as exemple)
version 1: 89 bytes (output cat as lines with: c  ca   cat )
read a;for i in $(seq 1 ${#a});do for c in $(seq 1 $((i*5)));do echo "${a:0:i}";done;done

version 2 : 158 bytes ( output cat as lines with : ['c']  ['c', 'a']  ['c', 'a', 't'] )
read a;for i in $(seq 1 ${#a});do for c in $(seq 1 $((i*5)));do printf "[$(for j in $(seq 1 $i);do printf ", '${a:j-1:1}'";done)]\n";done;done|sed -e 's/, //'

@whalalalalalala-chen : I try to respect the output given in the question... as it is unclear what output would be acceptable otherwise (if it could be : c ca  cat, without the '[' ']' and "'" , then the answer can be much shorter!)

awk, 74 bytes  (or 144 for the extra complex output shown in question)
version 1, 74 bytes: that the question seems to allow (each lines looking like:  c  ca  cat )
{for(c=1;c<=length($1);c++)for(n=1;n<=c*5;n++){print substr($1,1,c)};exit}

version 2, 144 bytes: extra complex output ( each lines looking like: ['c']  ['c', 'a']  ['c', 'a', 't'] )
{s=length($1);for(c=1;c<=s;c++)for(n=1;n<=c*5;n++){printf"[";for(i=1;i<=c;i++)printf("%s'%s'",(i>1)?", ":"",substr($1,i,1));printf("]\n")};exit}

Thanks to the exit, this processes only the first line entered on stdin.
Getting rid of it also processes multiple lines, one by one, stacking the towers together (and savig 5 bytes).
The default is the above, with only 1 tower (and only the first input line processed)

@whalalalalalala-chen : I try to respect the output given in the question... as it is unclear what output would be acceptable otherwise (if it could be : c ca  cat, without the '[' ']' and "'" , then the answer can be much shorter!)

Pascal (FPC), 96 bytes
var s:string;i,j:word;begin read(s);for i:=1to length(s)do for j:=1to i*5do writeln(s[1..i])end.

Try it online!
Longer than Java :(

brainf**k 93 81 76 bytes
++++++++++>+>>,[[<]<[<<+<+++++[>>>>>[.>]<[<]<<.<<-]>>>-]<<[->>+<<]>>+>>[>],]

Try it online!
Saved 12 bytes by removing a never-used empty cell. Saved another 5 bytes due to the help of Dorian (thanks!). Did not update the "How it works" section.
How it works
[-][ https://codegolf.stackexchange.com/questions/170872/tower-of-strings ]
[-][ -------------------------------------------------------------------- ]
[-][ Variables                                                            ]
[-][ p0: temp0                                                            ]
[-][ p1: temp1                                                            ]
[-][ p2: {LF}                                                             ]
[-][ p3: n input characters                                               ]
[-][ p4: zero                                                             ]
[-][ p5... inputs                                                         ]

p0    [-]
p1  > [-]
p2  > ++++++++++
p3  > +
p4  > [-]
p5  > ,   # read input
      [   # open loop
p4      [<] # go back to p4
p3       <
## loop current number of inputs
         [
p2         <
p1         < + # copy p3 to p1
p0         < +++++ # use p0 to count to 5
          [
p1         >
p2         >
p3         >
p4         >
p5         >
           [ ## output all until empty
             . >
           ] <
p4         [<] #back to p4
p3         <
p2         < . #output {LF}
p1         <
p0         <-
          ]
p1         >
p2         >
p3         > -
         ]
## copy p1 back to p3
p2       <
p1       <
         [ -
p2         >
p3         > +
p2         <
p1         <
         ]
p2        >
p3        > + # increase p3
p4        >
next     >[>] ,  # read next character
      ]

Shorter than Java ;-)

Hi and welcome to codegolf. You can remove the starting >>. Tio can handle negative indexes. And you can remove the [-], since that cell is already 0.

Pushy, 10 bytes
@L:OvL5*:"

Try it online!

                   \ Implicit: Input on stack, as character codes
@                  \ Reverse stack
 L:                \ length(stack) times do:
   Ov              \   Move TOS to auxiliary stack
     L5*:          \   5 * length(auxiliary stack) times do:
         "         \     Print the auxiliary stack as a string

C# (.NET Core), 89 bytes
Without LINQ.
x=>{int i=0;while(i++<x.Length)for(var j=0;j++<i*5;)Console.WriteLine(x.Substring(0,i));}

Try it online!

PHP, 70 bytes
If it's okay to print the strings like h he hel hell hello then this is a valid answer. Otherwise, I might need to add more code to make the square brackets, quotes and commas.
for(;$x<strlen($argn);)echo str_repeat(substr($argn,0,++$x)."
",5*$x);

Try it online!