[Question]
  [
Given a non-empty string s, with even length, and a positive integer n, representing its height, compose a pyramid using the following rules:
The pyramid should contain n non-empty lines; trailing newlines are allowed. For each 1 <= i <= n, the i-th line should contain the string with each individual character repeated in-place i times; abcd repeated 3 times as such becomes aaabbbcccddd. Each line should be centered with padding spaces so that the middle of each line is vertically aligned. Trailing spaces at the end of each line are permitted. You can also have up to one leading newline but no other whitespace before the first line.
The input string is not guaranteed to be a palindrome.
# Test Case
```
s = 'o-o  o-o', n = 10:
                                    o-o  o-o                                    
                                oo--oo    oo--oo                                
                            ooo---ooo      ooo---ooo                            
                        oooo----oooo        oooo----oooo                        
                    ooooo-----ooooo          ooooo-----ooooo                    
                oooooo------oooooo            oooooo------oooooo                
            ooooooo-------ooooooo              ooooooo-------ooooooo            
        oooooooo--------oooooooo                oooooooo--------oooooooo        
    ooooooooo---------ooooooooo                  ooooooooo---------ooooooooo    
oooooooooo----------oooooooooo                    oooooooooo----------oooooooooo
```
  
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 9 bytes
```
γ².D)ƶJ.C
```
[Try it online!](https://tio.run/##MzBNTDJM/f//3OZDm/RcNI9t89Jz/v/fQNdAQQFIcBkaAAA "05AB1E – Try It Online")
---
`γ` was, in no short amount, inspired by Adnan's answer; but `S` would also work.
---
```
γ          # Split into runs.    | ['0','-','0']
 ².D)      # Push n times.       | [['0','-','0'],['0','-','0'],['0','-','0']]
     ƶ     # Lift by index.      | [['0','-','0'],['00','---','00'],['000','---','000']]
      J    # Inner join.         | ['0-0','00--00','000---000']
       .C  # Center.             | Expected output.
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 11 bytes
```
F²γN>×J}».C
```
Uses the **05AB1E** encoding. [Try it online!](https://tio.run/##MzBNTDJM/f/f7dCmc5v97A5P96o9tFvP@f9/QwOufN18BQUgAQA "05AB1E – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~14~~ 13 bytes
```
LH×Ḷ}Ṛ⁶ẋżxÐ€Y
```
[Try it online!](https://tio.run/##ATEAzv9qZWxsef//TEjDl@G4tn3huZrigbbhuovFvHjDkOKCrFn///8nUC1QICBDLUcn/zEw "Jelly – Try It Online")
### How it works
```
LH×Ḷ}Ṛ⁶ẋżxÐ€Y  Main link. Arguments: s (string), n (integer)
L              Get the length l of s.
 H             Halve it, yielding l/2.
   Ḷ}          Unlength right; yield [0, ... n-1].
  ×            Compute [0, l/2, ..., l(n-1)/2].
     Ṛ         Reverse; yield [l(n-1)/2, ..., l/2, 0].
      ⁶ẋ       Space repeat; create string of that many spaces.
         xÐ€   Repeat in-place each; repeat the individual characters of s
               1, ..., n times, yielding an array of n strings.
        ż      Zipwith; pair the k-th string of spaces with the k-th string of 
               repeated characters of s.
            Y  Sepatate the resulting pairs by linefeeds.
```
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 139 137 136 130 bytes
```
using System.Linq;s=>n=>Enumerable.Range(0,n).Select(i=>"".PadLeft((n+~i)*s.Length/2)+string.Concat(s.Select(c=>new string(c,i))))
```
[Try it online!](https://tio.run/##nZDRSsMwFIbv9xQhu0ltm7rdzhZBVJQKw13spiAxO62B9gSTVBGZz@Iz@ES@SU27ujEv/SHhcP783yFH2lhqA11rFVZk9WYdNDxX@LyYTIiXrIW1ZGl0ZUQzdN6Hu5d1wilJXrTakDuhkAV76/Co14i9alGeWWf8pOiop9DtGxe6rkE6pdHya0AwSvKbS2wbMOKxhjGfZRkpSTrpbJphmh18fi@wAnYaYcBX0JOYSjNK@VJscigdYxh@qODE8hywck/JPAh3SD8ZpXDM/uakR8Mr2blMRirw6sa9/Pmaz1rtp6@NcuDXB2yE3mq/F1ogjUjJ6PfX54M/hIwFDdhs5qmL/zPPaRwmxXSaFGHc4@ZHuO1Qbbsf "C# (.NET Core) – Try It Online")
Returns an enumeration of `string`s with the lines of the drawing. Once joined the result is like this:
```
                        ಠ_ಠ  ಠ_ಠ
                    ಠಠ__ಠಠ    ಠಠ__ಠಠ
                ಠಠಠ___ಠಠಠ      ಠಠಠ___ಠಠಠ
            ಠಠಠಠ____ಠಠಠಠ        ಠಠಠಠ____ಠಠಠಠ
        ಠಠಠಠಠ_____ಠಠಠಠಠ          ಠಠಠಠಠ_____ಠಠಠಠಠ
    ಠಠಠಠಠಠ______ಠಠಠಠಠಠ            ಠಠಠಠಠಠ______ಠಠಠಠಠಠ
ಠಠಠಠಠಠಠ_______ಠಠಠಠಠಠಠ              ಠಠಠಠಠಠಠ_______ಠಠಠಠಠಠಠ
```
* 2 bytes saved thanks to Kevin Cruijssen!
* 1 byte saved thanks to Value Ink!
* 6 bytes saved thanks to LiefdeWen!
[Answer]
## [Cheddar](https://cheddar.vihan.org), ~~71~~ 64 bytes
*Saved 7 bytes thanks to @ValueInk*
```
(s,n)->(1|>n=>i->(s.len*(n-i)/2)*" "+s.sub(/./g,"$&"*i)).asLines
```
[Try it online!](https://vihan.org/p/tio/?l=cheddar&p=y0ktUUizVdAo1snT1LXTMKyxy7O1ywSyivVyUvO0NPJ0MzX1jTS1lBSUtIv1ikuTNPT19NN1lFTUlLQyNTX1Eot9MvNSixWsuQqKMvOAZmmo5@vmKygACXUdBUMDzf8A) I will add explanation in a bit
Explanation
```
(string, count)->(
   1 |> count          // 1..count, the amount of rep/char per line
     => i -> (         // Map over the range       
        s.len*(n-i)/2  // Calculate amount of spaces and repeat by it.
     )*" "
     + s.sub(/./g,"$&"*i) // replace each character, duplicate the amount of times `*i`
).asLines              // return the above joined with newlines
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 58 bytes
```
->s,n{(1..n).map{|i|s.gsub(/./){$&*i}.center s.size*n}*$/}
```
[Try it online!](https://tio.run/##BcHRCoMgFADQX5GIoZd2pYcetx@ZCyxuIZhEVwdlfrs750jTWZeXqc83dyHLHjEo3Oyeb3czrpwmqVGr3D7AFZwpRDoEI7uLIBRodal7iiwWnK33AuhnvVwpsqqfBvQ4GgNNJ/rh@wc "Ruby – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), ~~75~~ 77 bytes
```
s,n=input()
for i in range(n):print''.join(c*-~i for c in s).center(len(s)*n)
```
[Try it online!](https://tio.run/##FcoxDoMwDAXQvafwFjsiiHas1MNUUQAj9B0lYWDh6mlZ3vTy2VbDq/c64KPIR2N5zFZISUHliyUx5J2Lojk3bqbg6MOldKd4pypjTGip8J7AVTykd2fBiP644Tn9AA "Python 2 – Try It Online")
[Answer]
# Java 11, ~~188~~ ~~186~~ ~~185~~ ~~183~~ ~~181~~ ~~173~~ ~~171~~ 133 bytes
```
s->n->{var r="";for(int l=s.length()/2,x=l*n,i=0;i++<n;r+="\n"){r+=" ".repeat(x-i*l);for(var c:s.split(""))r+=c.repeat(i);}return r;}
```
-2 bytes (185 → 183) due to a bug-fix (it was outputting `n+1` lines instead of `n`). Doesn't happen often that a bug-fix saves bytes. :)  
-2 bytes (183 → 181) thanks to *@OlivierGrégoire*  
-2 bytes (173 → 171) thanks to *@ceilingcat*
[Try it online.](https://tio.run/##PU89b8IwEN3zK06ebEjc0LEmGSt16MRIGdxgqKk5W/aFglB@e2pK6Pa@7vTeQZ90ddh@j/YYfCQ4ZC57sk7ueuzIepSvE1BF53RK8K4tXguARJpsBw97uaJocV/@8zckszexvOttC10zpqrFqr2edITYMKZ2PnKLBK5J0hnc0xcXT8/luXEzLG1TKzufL1HFecM@kInrDQCT0QSjiZ8rO3Pi78ntY/eSZArOEmdMiBztHkEr1BAN9REhqmFUUOT@of90uf804@TtFo55Gr/3XW9Ai9tMgNUlkTlK35MM2SKHvJM6BHfhel1vxITR/MC0OeuLjRBC5fuhGMbRVx6grupxUf8C)
**Explanation:**
```
s->n->{                    // Method with String & integer parameters and String return
  var r="";                //  Return-String, starting empty
  for(int l=s.length()/2,  //  Halve the length of the input-String
          x=l*n,           //  Set `x` to halve the length multiplied by the input
          i=0;i++<n;       //  Loop `i` in the range (0,n):
      r+="\n"){            //    And after every iteration, add a new-line
    r+=" ".repeat(x-i*l);  //   Add the appropriate amount of trailing spaces
    for(var c:s.split("")) //   Inner loop over the characters of the String:
      r+=c.repeat(i);}     //    Repeat each character `i` amount of times
  return r;}               //  Return the result-String
```
[Answer]
## JavaScript (ES6), 85 bytes
Takes input in currying syntax `(string)(height)`. Includes a leading newline.
```
s=>g=(n,p=`
`)=>n?g(n-1,p+' '.repeat(s.length/2))+p+s.replace(/./g,c=>c.repeat(n)):''
```
### Demo
```
let f =
s=>g=(n,p=`
`)=>n?g(n-1,p+' '.repeat(s.length/2))+p+s.replace(/./g,c=>c.repeat(n)):''
o.innerHTML = f('o-o  o-o')(10)
```
```
<pre id=o></pre>
```
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 19 bytes
```
Ｆ⁺¹Ｎ«Ｊ±×ι÷Ｌη²ιＦηＦικ
```
[Try it online!](https://tio.run/##HYw7DsIwEETr@BRb7kq2lNDS0oBQlCIXCMHEKxw78icN4uzGpJkp3ryZzRRmP9lSXj4ADjZH7CRc3ZZTn9eHDkhE8BHNLa/b6LHXy5Q0jrzqiPxfpgvv/NR4125JBg1JOFVHAtNZNMetITiaCYbALuG7om8pXSu88gA1itqLivYH "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
Ｆ⁺¹Ｎ«       for (Plus(1, InputNumber())) {
```
We need lines repeated `1..n` times. The easiest way to achieve this is to loop from 0 to n, as loop 0 is basically a no-op.
```
Ｊ±×ι÷Ｌη²ι       JumpTo(Negate(Times(i, IntDivide(Length(h), 2))), i);
```
Position the cursor so that the resulting line is centred.
```
ＦηＦικ           for (h) for (i) Print(k);
```
And this is how simple printing each character repeated `i` times is.
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGL), 14 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
ā.∫dI*Hd⁄»±IFž
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=JXUwMTAxLiV1MjIyQmRJKkhkJXUyMDQ0JUJCJUIxSUYldTAxN0U_,inputs=NCUwQW8tbyUyMCUyMG8tbw__)
[Answer]
# Javascript, 105 bytes
```
(s,n)=>Array(N=n).fill().reduce(a=>a+'\n'+' '.repeat(--n*s.length/2)+s.replace(/./g,_=>_.repeat(N-n)),'')
```
After a few years off, the Stretch Maniac is back, hopefully slightly more educated this time.
[Answer]
# [Haskell](https://www.haskell.org/), ~~79~~ ~~73~~ 69 bytes
* Saved 4 bytes thanks to [nimi](https://codegolf.stackexchange.com/users/34531/nimi)
```
s#n=unlines[(' '<$[1,3..(n-m)*length s])++((<$[1..m])=<<s)|m<-[1..n]]
```
[Try it online!](https://tio.run/##HYrBDoMgEETvfsVGTYRaSI1X@IPeejQcTEqq6bI0Xbz13yn4DpO8mdlWfnvEnLkjexDu5HkRAwymX6brrLUgFeQFPb3SBuzkOApRN62Dk9YYlr9gVHVyLod1J7DwjA0U0Cfgom1UEaBEe9aV@ppuzemfIz3S907Ql3cHlP8 "Haskell – Try It Online")
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), ~~33~~ 31 bytes
*2 bytes golfed thanks to @ZacharyT by removing unnecessary parentheses*
```
{↑((' '/⍨(.5×≢⍵)×⍺-⊢),⍵/⍨⊢)¨⍳⍺}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///3/FR24TqR20TNTTUFdT1H/Wu0NAzPTz9UeeiR71bNYGM3l26j7oWaeoAuSBZEPvQike9m4EStf//GxooOCqo5@vmKygACXUuJD5EBAA "APL (Dyalog Unicode) – Try It Online")
### Explanation
The right argument `⍵` is the string and the left argument `⍺` is the number.
```
{↑((' '/⍨(.5×≢⍵)×⍺-⊢),⍵/⍨⊢)¨⍳⍺}
                             ⍳⍺      Range 1 .. ⍺
  (                        )¨        For each element (let's call it i) do:
                      ⍵/⍨⊢          Replicate ⍵ i times
  (                 ),               Concatenated with
         (.5×≢⍵)×⍺-⊢                (⍺-i)×(len(⍵)×0.5)
   ' '/⍨                                spaces
 ↑                                    Convert the resulting array to a 2D matrix
```
[Answer]
**SWI Prolog, 398 bytes**
It is not the most compact solution (maybe somewhere reinventing the wheel instead of using built-in procedures), but it appers to work.
```
w(0).
w(X):-write(' '),Y is X-1,w(Y).
s(S,N):-string_length(S,X),Y is div(X,2)*N,w(Y).
d(S,N,R):-atom_chars(S,A),e([],A,N,R).
e(B,[H|T],N,R):-l(B,H,N,I),e(I,T,N,R).
e(B,[],_,B).
a([], L, L).
a([H|T],L,[H|R]):-a(T,L,R).
l(L,_,0,L).
l(L,I,N,R):-M is N-1,l(L,I,M,T),a(T,[I],R).
o([]):-nl.
o([H|T]):-write(H),o(T).
p(S,N):-p(S,N,N).
p(_,0,_).
p(S,N,L):-Q is N-1,p(S,Q,L),d(S,N,R),W is L-N,s(S,W),o(R).
```
Test:
```
?- p("o-o  o-o",10).
                                    o-o  o-o
                                oo--oo    oo--oo
                            ooo---ooo      ooo---ooo
                        oooo----oooo        oooo----oooo
                    ooooo-----ooooo          ooooo-----ooooo
                oooooo------oooooo            oooooo------oooooo
            ooooooo-------ooooooo              ooooooo-------ooooooo
        oooooooo--------oooooooo                oooooooo--------oooooooo
    ooooooooo---------ooooooooo                  ooooooooo---------ooooooooo
oooooooooo----------oooooooooo                    oooooooooo----------oooooooooo
true .
```
Explanation:
**w** and **s** writes proper amount of leading spaces:
```
w(0).
w(X):-write(' '),Y is X-1,w(Y).
s(S,N):-string_length(S,X),Y is div(X,2)*N,w(Y).
```
**d** manages the "duplication" of characters and **e** is it's recursive facility:
```
//d(String, Number of repetitions, Result)
d(S,N,R):-atom_chars(S,A),e([],A,N,R).
e(B,[H|T],N,R):-l(B,H,N,I),e(I,T,N,R).
e(B,[],_,B).
```
**a** and **l** append to the result (maybe there exists a built in procedure?):
```
a([], L, L).
a([H|T],L,[H|R]):-a(T,L,R).
l(L,_,0,L).
l(L,I,N,R):-M is N-1,l(L,I,M,T),a(T,[I],R).
```
**o** creates the output:
```
o([]):-nl.
o([H|T]):-write(H),o(T).
```
and finally the **p** is the *main method*:
```
p(S,N):-p(S,N,N).
p(_,0,_).
//p(String, Current level, Number of levels) :- go to the bottom, create pyramide level, write whitespaces, write the level
p(S,N,L):-Q is N-1,p(S,Q,L),d(S,N,R),W is L-N,s(S,W),o(R).
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-R`](https://codegolf.meta.stackexchange.com/a/14339/), ~~20~~ ~~19~~ ~~14~~ 8 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
õ@VmpXÃû
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVI&code=9UBWbXBYw/s&input=MTAKIm8tbyAgby1vIg)
* Saved 1 byte thanks to [ETHproductions](https://codegolf.stackexchange.com/users/42545/ethproductions)
[Answer]
# PHP, 113 bytes:
```
for([,$s,$n]=$argv;$i++<$n;)for(print($f=str_pad)("
",($n-$i)*strlen($s)/2+!$p=0);~$c=$s[$p++];)echo$f($c,$i,$c);
```
Run with `php -nr '<code>' '<string>' <N>` or [test it online](http://sandbox.onlinephpfunctions.com/code/b721c34d134f6aa882e336f0e2be54a6f3bf591b).
**breakdown**
```
# import input, loop $i from 1 to $n
for([,$s,$n]=$argv;$i++<$n;)
    # 1. print newline and padding, reset $p
    for(print($f=str_pad)("\n",($n-$i)*strlen($s)/2+!$p=0);
    # 2. loop $c through string
        ~$c=$s[$p++];)
        # print repeated character
        echo$f($c,$i,$c);
```
[Answer]
# [CJam](https://sourceforge.net/p/cjam/wiki/Home/), 36 bytes
```
l_,2/:T;]li:F{[_U)*zSTFU)-**\N]\}fU;
```
[Try it online!](http://cjam.aditsu.net/#code=l_%2C2%2F%3AT%3B%5Dli%3AF%7B%5B_U%29*zSTFU%29-**%5CN%5D%5C%7DfU%3B&input=o-o%20%20o-o%0A10)
[Answer]
# T-SQL, 223 bytes
```
DECLARE @ char(99),@n INT,@i INT=1,@j INT,@p varchar(max)SELECT @=s,@n=n FROM t
R:SET @j=0SET @p=SPACE((@n-@i)*len(@)/2)C:SET @j+=1SET @P+=REPLICATE(SUBSTRING(@,@j,1),@i)IF @j<LEN(@)GOTO C
PRINT @p SET @i+=1IF @i<=@n GOTO R
```
Input is via pre-existing table **t** with columns **s** and **n**, [per our IO standards](https://codegolf.meta.stackexchange.com/a/5341/70172).
Not much to explain, it's a pretty straightforward nested loop, using `@i` for the rows and `@j` to walk through the characters of the string which are `REPLICATED` `@i` times:
```
DECLARE @ char(99),@n INT,@i INT=1,@j INT,@p varchar(max)
SELECT @=s,@n=n FROM t
R:
    SET @j=0
    SET @p=SPACE((@n-@i)*len(@)/2) 
    C:
        SET @j+=1
        SET @P+=REPLICATE(SUBSTRING(@,@j,1),@i)
    IF @j<LEN(@)GOTO C
    PRINT @p
    SET @i+=1
IF @i<=@n GOTO R
```
[Answer]
# [R](https://www.r-project.org/), ~~125~~ 95 bytes
```
function(S,n)for(i in 1:n)cat(rep(' ',(n-i)/2*nchar(S)),rep(el(strsplit(S,'')),e=i),sep="",'
')
```
[Try it online!](https://tio.run/##FYsxDsIwDAD3vsLqYhslgjIi@oq@IIREtVScykkHXh/KcsOdzvomLwv2pU9qa3lXHjI8fc@HxiZFaXHKuRgJiML0UI6hkaWdENCReuHr/aJxDUYLs/uXtFFtVvdN2rkjnjrNwq6mfR5HhwNyz4TFF4AT6GC6cf8B "R – Try It Online")
### Explanation:
It's pretty straightforward, splitting the string and repeating the elements `i` times each `rep(s,e=i)` (`e` is short for `each`) as we loop. The tricky part is `rep('',(n-i)/2*length(s)+1)`. This is the padding string, but it's a bunch of empty strings. I need to add 1 because otherwise the result is `character(0)`, a zero-length vector, and `cat`, which by default separates its elements with spaces, misaligns the final line.
[Answer]
# [Python 2](https://docs.python.org/2/), ~~79~~ 77 bytes
```
s,n=input();m=n
while m:m-=1;print' '*(m*len(s)/2)+''.join(i*(n-m)for i in s)
```
[Try it online!](https://tio.run/##DcNJDoMwDADAO6/wzXYgbMeiPIcKI2xHJBXq69OONPlbD7e1tTJYEsufSrxpsu455NpBXxrTsuVbrCJgIA3XblR4WrlHHE8XIwlkUfntNwiIQeHW0KPDPw7L/AM "Python 2 – Try It Online")
Edit: -2 bytes courtesy @FlipTack
[Answer]
# Mathematica, 97 bytes
```
(c=Characters@#;T=Table;Column[T[""<>T[""<>T[c[[i]],j],{i,Length@c}],{j,#2}],Alignment->Center])&
```
  
**input**
> 
> ["o-o o-o", 10]
> 
> 
> 
[Answer]
# Tcl, ~~143~~ ~~142~~ ~~141~~ 138 bytes
```
proc p s\ n {set p [expr [set w [expr [string le $s]/2]]*$n];time {incr p $w;puts [format %$p\s [regsub -all . $s [append r \\0]]]} $n;cd}
```
Test:
```
% p "o-o  o-o" 5
                o-o  o-o
            oo--oo    oo--oo
        ooo---ooo      ooo---ooo
    oooo----oooo        oooo----oooo
ooooo-----ooooo          ooooo-----ooooo
```
Remark: the "cd" at the end of the procedure prevents time's result to be printed out below the pyramid, but changes the current directory - a side effect that's not explicitly forbidden.
Thanks to sergiol for a hint to save one byte.... and another hint to save one more byte.
Thanks to aspect (on tcl chat) for another 3 bytes saved!
[Answer]
# Swift, 232 bytes
Probably could be better, but I don't have much time to refactor.
This answer uses Swift 4, so it can't currently be run online.
```
var p:(String,Int)->String={s,i in let r=(1...i).map{n in return s.map{return String(repeating:$0,count:n)}.joined()};return(r.map{return String(repeating:" ",count:(r.last!.count-$0.count)/2)+$0}as[String]).joined(separator:"\n")}
```
[Answer]
## LOGO, ~~97~~ 95 bytes
```
to f :s :n
for[i 1 :n][repeat(:n-:i)/2*count :s[type "\ ]foreach :s[repeat :i[type ?]]pr "]
end
```
Try the code on FMSLogo interpreter.
Define a function `f` which takes two inputs, `:s` and `:n`, then print the result.
[Answer]
# Java 8, 164 148 bytes
```
s->n->{String o="";for(int i=0,m,j;i++<n;){o+="\n";for(m=0;m++<(n-i)*s.length()/2;)o+=" ";for(char c:s.toCharArray())for(j=0;j++<i;)o+=c;}return o;}
```
Explanation:
```
s->n->{
    String o = "";                                  //empty output string
    for (int i = 0, m, j; i++ < n; ) {              //for each row
        o += "\n";                                  //append a new line
        for (m = 0; m++ < (n - i)*s.length()/2; )   //for amount of spaces = inversed row_number * half length
            o += " ";                               //append a space
        for (char c : s.toCharArray())              //for each char of the string
            for (j = 0; j++ < i; )                  //row_number times
                o+=c;                               //append char
    }
    return o;
}
```
[Answer]
## Rust, 107 bytes
```
|a:&str,b|for i in 0..b{println!("{:^1$}",a.split("").map(|s|s.repeat(i+1)).collect::<String>(),a.len()*b)}
```
[playpen link](https://is.gd/N3KxON)
Defines an anonymous function that takes a string slice and number, printing the wanted pattern to standard output. It assumes that the string slice only contains ASCII characters, but the challenge never specifies that full unicode support is necessar. To be correct for unicode as well would require 117 bytes:
```
|a:&str,b|for i in 0..b{println!("{:^1$}",a.split("").map(|s|s.repeat(i+1)).collect::<String>(),a.chars().count()*b)}
```
The explanation is rather simple:
```
|a:&str,b|                             // arguments, compiler can't infer the type of a unfortunately
    for i in 0..b {                    // iterate from row 0 to row b - 1
        println!(
            "{:^1$}",                  // print a line containing arg 0, centered with the width specified as arg 1
            a.split("")                // split the string into slices of one character
                .map(|s|s.repeat(i+1)) // for each slice, yield a string containing row+1 times that slice
                .collect::<String>(),  // concatenate each of the strings into one string
            a.len()*b                  // total length should be the length of the string times the amount of rows
        )
    }
```
[Answer]
# [SOGL V0.12](https://github.com/dzaima/SOGL), 8 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
∫dč*∑}¹╚
```
[Try it Here!](https://dzaima.github.io/SOGLOnline/?code=JXUyMjJCZCV1MDEwRColdTIyMTElN0QlQjkldTI1NUE_,inputs=MTAlMEFvLW8lMjAlMjBvLW8_)
Explanation:
```
∫dč*∑}¹╚
∫    }    iterate over 1..input, pushing counter
 d        push the variable D, which sets itself to the next input as string
  č       chop into characters - a vertical array
   *      multiply horizontally by the counter
    ∑     join the array together
      ¹   wrap all that in an array
       ╚  center horizontally
```
I didn't feel like updating my old answer here as it uses a different method and uses a new(er than the challenge) feature - `╚`
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~6~~ 5 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
L€×.c
```
First input is \$n\$, second input is \$s\$ as character-list.
[Try it online.](https://tio.run/##yy9OTMpM/f/f51HTmsPT9ZL//zc04IpWslXSUdIFYkUgVoBiRaiYrVLsf13dvHzdnMSqSgA)
**Explanation:**
```
L      # Push a list in the range [1, first (implicit) input-integer]
 €     # Map over each integer:
  ×    #  Repeat each character in the (implicit) second input-list the integer
       #  amount of times as string
   .c  # Join each inner list to a string; then each string by newlines;
       # and then centralize each line by padding leading spaces
       # (after which it is output implicitly as result)
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 123 bytes
```
i,j,c;p(char*s,int n){for(i=0;i<n;){printf("\n%*s",strlen(s)/2*(n-++i),"");for(c=0;s[c];c++)for(j=0;j++<i;)putchar(s[c]);}}
```
[Try it online!](https://tio.run/##bY0xDsIwDEX3niKKhBQ3qSisLicBhuJScAVJlBSWqmcPyYBY8ODh/f/1qLkRpcRmMoRe0b0PdTRsZ2FhGV1QfGiRO4uw@JDxqOTJbuooTZzD42pVhO2@VrbRmsFICVhGlEfxSGckraGAKYNJ644R/GsuFlVywHVNRfbs2aq34wGqpRL5vJKucULkJ43YtYDi58@Wb6m/0PC/sKYP "C (gcc) – Try It Online")
## Pretty Code:
```
// declare variables gcc-style
i,j,c;
p(char *s, int n){
    // for every n
    for(i=0;i<n;){
        // print [ strlen(s)/2 * (n-(i+1)) ] spaces
        printf("\n%*s",strlen(s)/2*(n-++i),""); // increment i instead of (i+1)
        // for every character in the input string
        for(c=0;s[c];c++)
            // for every repetition required
            for(j=0;j++<i;)
                // print the current character
                putchar(s[c]);
    }
}
```
]