[Question]
  [
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.
  
[Answer]
# [R](https://www.r-project.org/), 48 bytes
```
function(s)substring(s,1,rep(x<-1:nchar(s),x*5))
```
[Try it online!](https://tio.run/##K/qfpmCj@z@tNC@5JDM/T6NYs7g0qbikKDMvXaNYx1CnKLVAo8JG19AqLzkjsQgorVOhZaqp@T9NQykjNScnX0mTC8hMTixR0vwPAA "R – Try It Online")
Returns a list of strings.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 6 bytes
```
ηā5*ÅΓ
```
[Try it online!](https://tio.run/##yy9OTMpM/f//3PYjjaZah1vPTf7/PyM1JycfAA "05AB1E – 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]
```
[Answer]
# [Haskell](https://www.haskell.org/), 36 bytes
```
f""=[]
f s=f(init s)++(s<$s<*[1..5])
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P01JyTY6litNodg2TSMzL7NEoVhTW1uj2Eal2EYr2lBPzzRW839uYmaegq1CbmKBr0JBaUlwSZFPnoKKQpqCUgbQkHyl/wA "Haskell – Try It Online")
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 8 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
äï▄;♫├W^
```
[Run and debug it](https://staxlang.xyz/#p=848bdc3b0ec3575e&i=hello&a=1)
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](https://staxlang.xyz/#c=%7C[F%09for+each+prefix+of+the+input%0A++i%5E5*%095*%28i%2B1%29+where+i+is+the+iteration+index%0A++DQ%09that+many+times,+peek+and+print+to+output&i=hello&a=1)
[Answer]
# 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
```
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 15 bytes
```
.
$.>`*5*$($>`¶
```
[Try it online!](https://tio.run/##K0otycxLNPyvquGe8F@PS0XPLkHLVEtFQ8Uu4dC2//8zUnNy8rmSE0sA "Retina – 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.
[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=JXVGRjNCJUIzJXVGRjE1JUQ3JXVGRjBBJXVGRjMw,i=JTIyaGVsbG8lMjI_,v=6)
Explanation:
```
[      for each prefix
 ³5×     1-indexed counter * 5
    *    repeat the prefix vertically that many times
     P   and print that
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 15 bytes
```
a₀ᶠ⟨gj₎{l×₅}⟩ᵐc
```
[Try it online!](https://tio.run/##ATMAzP9icmFjaHlsb2cy//9h4oKA4bag4p@oZ2rigo57bMOX4oKFfeKfqeG1kGP//yJjYXQi/1o "Brachylog – Try It Online")
The final `c` can be removed if OP replies positively to the question about outputting 2D arrays. 
[Answer]
# [Cubix](https://github.com/ETHproductions/cubix), ~~44~~ 40 bytes
```
i.!?@UBqwW_#/>u...;B^...?qo;;q*n5;oN/./)
```
[Try it online!](https://tio.run/##Sy5Nyqz4/z9TT9HeIdSpsDw8XlnfrlRPT8/aKQ5I2hfmW1sXauWZWuf76evpa/7/75Gak5MPAA "Cubix – 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](https://ethproductions.github.io/cubix/?code=ICAgICAgaSAuICEKICAgICAgPyBAIFUKICAgICAgQiBxIHcKVyBfICMgLyA+IHUgLiAuIC4gOyBCIF4KLiAuIC4gPyBxIG8gOyA7IHEgKiBuIDUKOyBvIE4gLyAuIC8gKSAuIC4gLiAuIC4KICAgICAgLiAuIC4KICAgICAgLiAuIC4KICAgICAgLiAuIC4=&input=c3RlcAo=&speed=20)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 8 bytes
```
¹Ƥx'J×5Ɗ
```
[Try it online!](https://tio.run/##y0rNyan8///QzmNLKtS9Dk83Pdb1/3B75P//GUCJfAA "Jelly – Try It Online")
```
J×5x'@¹Ƥ
```
[Try it online!](https://tio.run/##y0rNyan8/9/r8HTTCnWHQzuPLfl/uD3y//8MoHg@AA "Jelly – Try It Online")
```
¹Ƥx'Jx'5
```
[Try it online!](https://tio.run/##y0rNyan8///QzmNLKtS9KtRN/x9uj/z/PwMonA8A "Jelly – Try It Online")
This is likely golfable.
[Answer]
# 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))}`
[Answer]
# [Python 3](https://docs.python.org/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!](https://tio.run/##K6gsycjPM/7/P802JzE3KSVRocIqWqsiNjEvRSFNoyLaStcwVlM7uiJWy1QrJzVPo0Lzf0FRZl6JRpqGUnJiiZKm5n8A "Python 2 – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 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!](https://tio.run/##HczBCoMwEATQu1@xCEI2JqUeelrsj1gP6ULsBpqWpHgRvz2a3t7MwLBdmEsRE8grfrmkM27@k5SMV8qT9P1MWHMYb1ooWEv4TRJ/XrXdRedHbI2YjLSXs4S3k6gqXFrY1D/Q@vSKsDUA4lUd7gPCX@s0zEjNXop78gE "C (gcc) – Try It Online")
[Answer]
# [Husk](https://github.com/barbuz/Husk), 8 bytes
```
ΣzoR*5Nḣ
```
[Try it online!](https://tio.run/##yygtzv7//9ziqvwgLVO/hzsW////Xyk5sUQJAA "Husk – 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"]
```
[Answer]
## Haskell, ~~46~~ ~~43~~ 42 bytes
```
f s=do n<-[1..length s];take n s<$[1..n*5]
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P02h2DYlXyHPRjfaUE8vJzUvvSRDoTjWuiQxO1UhT6HYRgUknqdlGvs/NzEzT8FWITexwDdeoaC0JLikyCdPQUUhTUEpObFE6T8A "Haskell – 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.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 11 bytes
```
Ｆ⊕ＬθＥ×⁵ι…θι
```
[Try it online!](https://tio.run/##FcYxDoAgDADAr3RsExydfIGJJA5@gEAVkgKCxO/XeNP56LqvTlTP2gHX4jtnLoMDblyuEbEREew9lYHW3XikzA/OBhIZsFUCtv9Ei2pkkarTKx8 "Charcoal – 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
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~46~~ 42 bytes
```
->s{(1..s.size).map{|i|puts [s[0,i]]*i*5}}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1664WsNQT69YrzizKlVTLzexoLoms6agtKRYIbo42kAnMzZWK1PLtLb2P1hMKSM1JydfQddOiSstGsJRiuUCSXFB5JMTS2CyQKZS7H8A "Ruby – Try It Online")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/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!](https://tio.run/##K8gvTy0qzkjNyfmvkqZgq1D9XyWxKL24RrVaR0OlWNtWJV5Ty1RLW1sls/Z/LReXCkhlPlCdEpihxKUG1OUAZv8HAA "PowerShell – 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.
[Answer]
# [MATL](https://github.com/lmendo/MATL), 12 bytes
```
f"G@:)@5*1X"
```
[Try it online!](https://tio.run/##y00syfn/P03J3cFK08FUyzBC6f9/9YzUnJx89f8A "MATL – 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
```
[Answer]
# [V](https://github.com/DJMcMayhem/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!](https://tio.run/##ASMA3P92///DssOvw6ckw67Dri82w4QKSGwkeMOyeMO6//9oZWxsbw "V – 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
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 14 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
```
{↑(5×⍳≢⍵)/,\⍵}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///v/pR20QN08PTH/VuftS56FHvVk19nRggVfs/7VHbhEe9fY/6pnr6P@pqPrTeGKgUyAsOcgaSIR6ewf/TFNRLUotL1AE "APL (Dyalog Unicode) – 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         
```
[Answer]
# [Wenyan](https://github.com/LingDong-/wenyan-lang), ~~350~~ ~~326~~ 308 bytes
```
吾有一術名之曰「A」欲行是術必先得一言曰「B」是術曰有數零名之曰「C」吾有一言名之曰「D」凡「B」中之「E」加五於「C」昔之「C」者今其是矣加「E」於「D」昔之「D」者今其是矣為是「C」遍夫「D」書之云云云云是謂「A」之術也
```
[IDE](http://wenyan-lang.lingdong.works/ide.html)
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.
[Answer]
## [Perl 5](https://www.perl.org/), 29 bytes
```
map{say}($x.=$_)x($y+=5)for@F
```
[Try it online!](https://tio.run/##K0gtyjH9r1Jpq1Jhq6Rk/T83saC6OLGyVkOlQs9WJV6zQkOlUtvWVDMtv8jB7f//jNScnHyu5MSSf/kFJZn5ecX/dXPc/uv6muoZGBoAAA "Perl 5 – Try It Online")
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 25 bytes
```
{(1..*X*5)RZxx[\~] .comb}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYKvwv1rDUE9PK0LLVDMoqqIiOqYuVkEvOT83qfZ/moaSoZGSpp2dXnFipfV/AA "Perl 6 – 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!](https://tio.run/##K0gtyjH7n1upoJamYKvwvzotJ7FEQcNQT08rQstUMyiqoiI6pi5WQS85Pzep9n@ahpKhkbGSpp2dXnFipfV/AA "Perl 6 – 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!](https://tio.run/##K0gtyjH7n1upoJamYKvwv1pDRdvWVLOiQisoqqIiOqYuVkEvOT83qfZ/moaSoZGxkqadnV5xYqX1fwA "Perl 6 – Try It Online")
Also works for the same amount of bytes.
[Answer]
# Japt, 10 bytes
Awaiting confirmation as to whether the output format is acceptable (+2 bytes if not).
```
å+ £T±5 ÇX
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.5&code=5Ssgo1SxNSDHWA==&input=ImNhdCIKLVE=)
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~15~~ 12 bytes
*-3 bytes from @Shaggy*
```
£¯°Y +R pY*5
```
[Try it online!](https://tio.run/##y0osKPn//9DiQ@sPbYhU0A5SKIjUMv3/XykjNScnXwkA "Japt – Try It Online")
[Answer]
# 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")
```
[Answer]
# [Forth (gforth)](http://www.complang.tuwien.ac.at/forth/gforth/Docs-html/), 48 bytes
```
: f 1+ 1 do i 5 * 0 do dup j type cr loop loop ;
```
[Try it online!](https://tio.run/##S8svKsnQTU8DUf//WymkKRhqKxgqpOQrZCqYKmgpGICYKaUFClkKJZUFqQrJRQo5@fkFEML6f7GSQkZqTk6@kkLafwA "Forth (gforth) – Try It Online")
### Explanation
1. Loop from 1 to string-length
2. for each iteration:
	1. Loop (5 \* loop index) times
	2. 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
```
[Answer]
# 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.](https://tio.run/##bY87DsIwDEB3TmF1SihEMLAQAisLLIyIIYQALiFFtYuEUM9eQunIYsnf91zYpx0Xp1vrgiWCjcUI7wEARvbV2ToP228K8CzxBE7suMJ4AZI6VZtBCsSW0cEWIhhoabx8n8tKpH0ozHSEZqpxYUgFHy98FVJjbvK8WOJwtkoD84ncvYj9XZU1q0c6ziEKUlQfqUOJyQil1E2rv7BHfQwJ1jM7p3tS7rX2B7DypxuVE9nah1BmnSrAH0zf6Wad5ax/qmk/)
**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`
```
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), 40 bytes
```
++++++++++>,[>>+++++[<<[<]>[.>]>>+<-]<,]
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fGw7sdKLt7MCsaBubaJtYu2g9u1igiI1urI1O7P//Gak5OfkA "brainfuck – 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
]
```
]